#line 1 "other/m2.cc" // #undef _GLIBCXX_DEBUG // #define NDEBUG #include <bits/extc++.h> #line 2 "Library/lib/alias" /** * @file alias * @brief Alias */ #line 13 "Library/lib/alias" #line 2 "Library/lib/bit" #if __cplusplus > 201703L #include <bit> #else #ifndef _GLIBCXX_BIT #define _GLIBCXX_BIT 1 #include <limits> #include <type_traits> namespace std { template <typename _Tp> constexpr _Tp __rotl(_Tp __x, int __s) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; const int __r = __s % _Nd; if (__r == 0) return __x; else if (__r > 0) return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); else return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); // rotr(x, -r) } template <typename _Tp> constexpr _Tp __rotr(_Tp __x, int __s) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; const int __r = __s % _Nd; if (__r == 0) return __x; else if (__r > 0) return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); else return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); // rotl(x, -r) } template <typename _Tp> constexpr int __countl_zero(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return _Nd; constexpr auto _Nd_ull = numeric_limits<unsigned long long>::digits; constexpr auto _Nd_ul = numeric_limits<unsigned long>::digits; constexpr auto _Nd_u = numeric_limits<unsigned>::digits; if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u) { constexpr int __diff = _Nd_u - _Nd; return __builtin_clz(__x) - __diff; } else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul) { constexpr int __diff = _Nd_ul - _Nd; return __builtin_clzl(__x) - __diff; } else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull) { constexpr int __diff = _Nd_ull - _Nd; return __builtin_clzll(__x) - __diff; } else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); unsigned long long __high = __x >> _Nd_ull; if (__high != 0) { constexpr int __diff = (2 * _Nd_ull) - _Nd; return __builtin_clzll(__high) - __diff; } constexpr auto __max_ull = numeric_limits<unsigned long long>::max(); unsigned long long __low = __x & __max_ull; return (_Nd - _Nd_ull) + __builtin_clzll(__low); } } template <typename _Tp> constexpr int __countl_one(_Tp __x) noexcept { if (__x == numeric_limits<_Tp>::max()) return numeric_limits<_Tp>::digits; return __countl_zero<_Tp>((_Tp)~__x); } template <typename _Tp> constexpr int __countr_zero(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return _Nd; constexpr auto _Nd_ull = numeric_limits<unsigned long long>::digits; constexpr auto _Nd_ul = numeric_limits<unsigned long>::digits; constexpr auto _Nd_u = numeric_limits<unsigned>::digits; if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u) return __builtin_ctz(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul) return __builtin_ctzl(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull) return __builtin_ctzll(__x); else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); constexpr auto __max_ull = numeric_limits<unsigned long long>::max(); unsigned long long __low = __x & __max_ull; if (__low != 0) return __builtin_ctzll(__low); unsigned long long __high = __x >> _Nd_ull; return __builtin_ctzll(__high) + _Nd_ull; } } template <typename _Tp> constexpr int __countr_one(_Tp __x) noexcept { if (__x == numeric_limits<_Tp>::max()) return numeric_limits<_Tp>::digits; return __countr_zero((_Tp)~__x); } template <typename _Tp> constexpr int __popcount(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return 0; constexpr auto _Nd_ull = numeric_limits<unsigned long long>::digits; constexpr auto _Nd_ul = numeric_limits<unsigned long>::digits; constexpr auto _Nd_u = numeric_limits<unsigned>::digits; if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u) return __builtin_popcount(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul) return __builtin_popcountl(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull) return __builtin_popcountll(__x); else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); constexpr auto __max_ull = numeric_limits<unsigned long long>::max(); unsigned long long __low = __x & __max_ull; unsigned long long __high = __x >> _Nd_ull; return __builtin_popcountll(__low) + __builtin_popcountll(__high); } } template <typename _Tp> constexpr bool __has_single_bit(_Tp __x) noexcept { return __popcount(__x) == 1; } template <typename _Tp> constexpr _Tp __bit_ceil(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0 || __x == 1) return 1; auto __shift_exponent = _Nd - __countl_zero((_Tp)(__x - 1u)); #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED if (!__builtin_is_constant_evaluated()) { __glibcxx_assert(__shift_exponent != numeric_limits<_Tp>::digits); } #endif using __promoted_type = decltype(__x << 1); if _GLIBCXX17_CONSTEXPR (!is_same<__promoted_type, _Tp>::value) { const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; } return (_Tp)1u << __shift_exponent; } template <typename _Tp> constexpr _Tp __bit_floor(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return 0; return (_Tp)1u << (_Nd - __countl_zero((_Tp)(__x >> 1))); } template <typename _Tp> constexpr _Tp __bit_width(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; return _Nd - __countl_zero(__x); } } // namespace std #endif #endif #line 2 "Library/lib/limits" #line 4 "Library/lib/limits" namespace std { #if defined(__STRICT_ANSI__) && defined(__SIZEOF_INT128__) template <> struct numeric_limits<__uint128_t> { constexpr static __uint128_t max() { return ~__uint128_t(0); } constexpr static __uint128_t min() { return 0; } }; template <> struct numeric_limits<__int128_t> { constexpr static __int128_t max() { return numeric_limits<__uint128_t>::max() >> 1; } constexpr static __int128_t min() { return -max() - 1; } }; #endif } // namespace std #line 16 "Library/lib/alias" namespace workspace { constexpr char eol = '\n'; using namespace std; using i32 = int_least32_t; using u32 = uint_least32_t; using i64 = int_least64_t; using u64 = uint_least64_t; #ifdef __SIZEOF_INT128__ using i128 = __int128_t; using u128 = __uint128_t; #else #warning 128bit integer is not available. #endif template <class T, class Comp = less<T>> using priority_queue = std::priority_queue<T, vector<T>, Comp>; template <class T> using stack = std::stack<T, vector<T>>; template <typename _Tp> constexpr _Tp __bsf(_Tp __x) noexcept { return std::__countr_zero(__x); } template <typename _Tp> constexpr _Tp __bsr(_Tp __x) noexcept { return std::__bit_width(__x) - 1; } } // namespace workspace #line 2 "Library/lib/cxx20" /* * @file cxx20 * @brief C++20 Features */ #line 9 "Library/lib/cxx20" #if __cplusplus <= 201703L #include <algorithm> #include <vector> namespace std { /* * @fn erase_if * @brief Erase the elements of a container that do not satisfy the condition. * @param __cont Container. * @param __pred Predicate. * @return Number of the erased elements. */ template <typename _Tp, typename _Alloc, typename _Predicate> inline typename vector<_Tp, _Alloc>::size_type erase_if( vector<_Tp, _Alloc>& __cont, _Predicate __pred) { const auto __osz = __cont.size(); __cont.erase(remove_if(__cont.begin(), __cont.end(), __pred), __cont.end()); return __osz - __cont.size(); } /* * @fn erase * @brief Erase the elements of a container that are equal to the given value. * @param __cont Container. * @param __value Value. * @return Number of the erased elements. */ template <typename _Tp, typename _Alloc, typename _Up> inline typename vector<_Tp, _Alloc>::size_type erase( vector<_Tp, _Alloc>& __cont, const _Up& __value) { const auto __osz = __cont.size(); __cont.erase(remove(__cont.begin(), __cont.end(), __value), __cont.end()); return __osz - __cont.size(); } } // namespace std #endif #line 2 "Library/lib/direct" /* * @file direct * @brief Pragma Directive */ #ifdef ONLINE_JUDGE #pragma GCC optimize("O3") #pragma GCC target("avx,avx2") #pragma GCC optimize("unroll-loops") #endif #line 2 "Library/src/opt/binary_search.hpp" /* * @file binary_search.hpp * @brief Binary Search */ #line 12 "Library/src/opt/binary_search.hpp" namespace workspace { /* * @fn binary_search * @brief binary search on a discrete range. * @param ok pred(ok) is true * @param ng pred(ng) is false * @param pred the predicate * @return the closest point to (ng) where pred is true */ template <class Iter, class Pred> typename std::enable_if< std::is_convertible<decltype(std::declval<Pred>()(std::declval<Iter>())), bool>::value, Iter>::type binary_search(Iter ok, Iter ng, Pred pred) { assert(ok != ng); typename std::make_signed<decltype(ng - ok)>::type dist(ng - ok); while (1 < dist || dist < -1) { const Iter mid(ok + dist / 2); if (pred(mid)) ok = mid, dist -= dist / 2; else ng = mid, dist /= 2; } return ok; } /* * @fn binary_search * @brief binary search on the real number line. * @param ok pred(ok) is true * @param ng pred(ng) is false * @param eps the error tolerance * @param pred the predicate * @return the boundary point */ template <class Real, class Pred> typename std::enable_if< std::is_convertible<decltype(std::declval<Pred>()(std::declval<Real>())), bool>::value, Real>::type binary_search(Real ok, Real ng, const Real eps, Pred pred) { assert(ok != ng); for (auto loops = 0; loops != std::numeric_limits<Real>::digits && (ok + eps < ng || ng + eps < ok); ++loops) { const Real mid{(ok + ng) / 2}; (pred(mid) ? ok : ng) = mid; } return ok; } /* * @fn parallel_binary_search * @brief parallel binary search on discrete ranges. * @param ends a vector of pairs; pred(first) is true, pred(second) is false * @param pred the predicate * @return the closest points to (second) where pred is true */ template <class Array, class Iter = typename std::decay< decltype(std::get<0>(std::declval<Array>()[0]))>::type, class Pred> typename std::enable_if< std::is_convertible< decltype(std::declval<Pred>()(std::declval<std::vector<Iter>>())[0]), bool>::value, std::vector<Iter>>::type parallel_binary_search(Array ends, Pred pred) { std::vector<Iter> mids(std::size(ends)); for (;;) { bool all_found = true; for (size_t i{}; i != std::size(ends); ++i) { const Iter &ok = std::get<0>(ends[i]); const Iter &ng = std::get<1>(ends[i]); const Iter mid( ok + typename std::make_signed<decltype(ng - ok)>::type(ng - ok) / 2); if (mids[i] != mid) { all_found = false; mids[i] = mid; } } if (all_found) break; const auto res = pred(mids); for (size_t i{}; i != std::size(ends); ++i) { (res[i] ? std::get<0>(ends[i]) : std::get<1>(ends[i])) = mids[i]; } } return mids; } /* * @fn parallel_binary_search * @brief parallel binary search on the real number line. * @param ends a vector of pairs; pred(first) is true, pred(second) is false * @param eps the error tolerance * @param pred the predicate * @return the boundary points */ template <class Array, class Real = typename std::decay< decltype(std::get<0>(std::declval<Array>()[0]))>::type, class Pred> typename std::enable_if< std::is_convertible< decltype(std::declval<Pred>()(std::declval<std::vector<Real>>())[0]), bool>::value, std::vector<Real>>::type parallel_binary_search(Array ends, const Real eps, Pred pred) { std::vector<Real> mids(std::size(ends)); for (auto loops = 0; loops != std::numeric_limits<Real>::digits; ++loops) { bool all_found = true; for (size_t i{}; i != std::size(ends); ++i) { const Real ok = std::get<0>(ends[i]); const Real ng = std::get<1>(ends[i]); if (ok + eps < ng || ng + eps < ok) { all_found = false; mids[i] = (ok + ng) / 2; } } if (all_found) break; const auto res = pred(mids); for (size_t i{}; i != std::size(ends); ++i) { (res[i] ? std::get<0>(ends[i]) : std::get<1>(ends[i])) = mids[i]; } } return mids; } } // namespace workspace #line 2 "Library/src/opt/exponential_search.hpp" /* * @file exponential_search.hpp * @brief Exponential Search */ #line 9 "Library/src/opt/exponential_search.hpp" namespace workspace { /* * @fn exponential_search * @brief Exponential search on a discrete range. * @param range Range of search, exclusive * @param pred Predicate * @return Minimum non-negative integer where pred is false. */ template <class Index, class Pred> typename std::enable_if< std::is_convertible<decltype(std::declval<Pred>()(std::declval<Index>())), bool>::value, Index>::type exponential_search(Index range, Pred pred) { Index step(1); while (step < range && pred(step)) step <<= 1; if (range < step) step = range; return binary_search(Index(0), step, pred); } /* * @fn exponential_search * @brief Exponential search on the real number line. * @param range Range of search * @param eps Error tolerance * @param pred Predicate * @return Boundary point. */ template <class Real, class Pred> typename std::enable_if< std::is_convertible<decltype(std::declval<Pred>()(std::declval<Real>())), bool>::value, Real>::type exponential_search(Real range, Real const &eps, Pred pred) { Real step(1); while (step < range && pred(step)) step += step; if (range < step) step = range; return binary_search(Real(0), step, eps, pred); } } // namespace workspace #line 2 "Library/src/opt/trinary_search.hpp" /* * @file trinary_search.hpp * @brief Trinary Search */ #line 9 "Library/src/opt/trinary_search.hpp" #include <type_traits> namespace workspace { /* * @brief Trinary search on discrete range. * @param first Left end, inclusive * @param last Right end, exclusive * @param comp Compare function * @return Local minimal point. */ template <class Iter, class Comp> typename std::enable_if< std::is_convertible<decltype(std::declval<Comp>()(std::declval<Iter>(), std::declval<Iter>())), bool>::value, Iter>::type trinary_search(Iter first, Iter last, Comp comp) { assert(first < last); typename std::make_signed<decltype(last - first)>::type dist(last - first); while (2 < dist) { Iter left(first + dist / 3), right(first + dist * 2 / 3); if (comp(left, right)) last = right, dist = (dist + dist) / 3; else first = left, dist -= dist / 3; } if (1 < dist && comp(first + 1, first)) ++first; return first; } /* * @brief Trinary search on discrete range. * @param first Left end, inclusive * @param last Right end, exclusive * @param func Function * @return Local minimal point. */ template <class Iter, class Func> typename std::enable_if< std::is_same<decltype(std::declval<Func>()(std::declval<Iter>()), nullptr), std::nullptr_t>::value, Iter>::type trinary_search(Iter const &first, Iter const &last, Func func) { return trinary_search(first, last, [&](Iter const &__i, Iter const &__j) { return func(__i) < func(__j); }); } /* * @brief Trinary search on the real number line. * @param first Left end * @param last Right end * @param eps Error tolerance * @param comp Compare function * @return Local minimal point. */ template <class Real, class Comp> typename std::enable_if< std::is_convertible<decltype(std::declval<Comp>()(std::declval<Real>(), std::declval<Real>())), bool>::value, Real>::type trinary_search(Real first, Real last, Real const &eps, Comp comp) { assert(first < last); while (eps < last - first) { Real left{(first * 2 + last) / 3}, right{(first + last * 2) / 3}; if (comp(left, right)) last = right; else first = left; } return first; } /* * @brief Trinary search on the real number line. * @param first Left end * @param last Right end * @param eps Error tolerance * @param func Function * @return Local minimal point. */ template <class Real, class Func> typename std::enable_if< std::is_same<decltype(std::declval<Func>()(std::declval<Real>()), nullptr), std::nullptr_t>::value, Real>::type trinary_search(Real const &first, Real const &last, Real const &eps, Func func) { return trinary_search( first, last, eps, [&](Real const &__i, Real const &__j) { return func(__i) < func(__j); }); } } // namespace workspace #line 2 "Library/src/sys/clock.hpp" /* * @fn clock.hpp * @brief Clock */ #line 9 "Library/src/sys/clock.hpp" namespace workspace { using namespace std::chrono; namespace internal { // The start time of the program. const auto start_time{system_clock::now()}; } // namespace internal /* * @fn elapsed * @return elapsed time of the program */ int64_t elapsed() { const auto end_time{system_clock::now()}; return duration_cast<milliseconds>(end_time - internal::start_time).count(); } } // namespace workspace #line 2 "Library/src/sys/ejection.hpp" /** * @file ejection.hpp * @brief Ejection */ #line 9 "Library/src/sys/ejection.hpp" namespace workspace { namespace internal { struct ejection { bool exit = 0; }; } // namespace internal /** * @brief eject from a try block, throw nullptr * @param arg output */ template <class Tp> void eject(Tp const &arg) { std::cout << arg << "\n"; throw internal::ejection{}; } void exit() { throw internal::ejection{true}; } } // namespace workspace #line 2 "Library/src/sys/iteration.hpp" /** * @file iteration.hpp * @brief Case Iteration */ #line 9 "Library/src/sys/iteration.hpp" #line 11 "Library/src/sys/iteration.hpp" namespace workspace { void main(); struct { // 1-indexed unsigned current{0}; unsigned total{1}; void read() { (std::cin >> total).ignore(); } int iterate() { static bool once = false; assert(!once); once = true; while (current++ < total) { try { main(); } catch (internal::ejection const& status) { if (status.exit) break; } } return 0; } } case_info; } // namespace workspace #line 2 "Library/src/utils/cat.hpp" /** * @file cat.hpp * @brief Cat */ #line 9 "Library/src/utils/cat.hpp" namespace workspace { template <class C1, class C2> constexpr C1 &&cat(C1 &&__c1, C2 const &__c2) noexcept { __c1.insert(__c1.end(), std::begin(__c2), std::end(__c2)); return __c1; } } // namespace workspace #line 2 "Library/src/utils/chval.hpp" /* * @file chval.hpp * @brief Change Less/Greater */ #line 9 "Library/src/utils/chval.hpp" namespace workspace { /* * @fn chle * @brief Substitute y for x if comp(y, x) is true. * @param x Reference * @param y Const reference * @param comp Compare function * @return Whether or not x is updated */ template <class Tp, class Comp = std::less<Tp>> bool chle(Tp &x, const Tp &y, Comp comp = Comp()) { return comp(y, x) ? x = y, true : false; } /* * @fn chge * @brief Substitute y for x if comp(x, y) is true. * @param x Reference * @param y Const reference * @param comp Compare function * @return Whether or not x is updated */ template <class Tp, class Comp = std::less<Tp>> bool chge(Tp &x, const Tp &y, Comp comp = Comp()) { return comp(x, y) ? x = y, true : false; } } // namespace workspace #line 2 "Library/src/utils/fixed_point.hpp" /** * @file fixed_point.hpp * @brief Fixed Point Combinator */ #line 9 "Library/src/utils/fixed_point.hpp" namespace workspace { /** * @brief Fixed Point Combinator */ template <class _F> class fixed_point { _F __fn; public: /** * @param __fn 1st argument callable with the rest of its arguments, and the * return type specified. */ fixed_point(_F &&__fn) noexcept : __fn(std::forward<_F>(__fn)) {} /** * @brief Apply *this to 1st argument. * @param __args Rest of arguments. */ template <class... _Args> decltype(auto) operator()(_Args &&... __args) const noexcept { return __fn(*this, std::forward<_Args>(__args)...); } }; /** * @brief Cached version of Fixed Point Combinator */ template <class _F> class cached_fixed_point { template <class...> struct _cache; template <class _G, class _R, class _H, class... _Args> struct _cache<_R (_G::*)(_H, _Args...) const> : std::map<std::tuple<_Args...>, _R> {}; using cache = _cache<decltype(&_F::template operator()<cached_fixed_point<_F> &>)>; _F __fn; static cache __ca; public: /** * @param __fn 1st argument callable with the rest of its arguments, and the * return type specified. */ cached_fixed_point(_F &&__fn) noexcept : __fn(std::forward<_F>(__fn)) {} /** * @brief Apply *this to 1st argument. * @param __args Rest of arguments. */ template <class... _Args> decltype(auto) operator()(_Args &&... __args) noexcept { typename cache::key_type __key(__args...); if (auto __i = __ca.lower_bound(__key); __i != __ca.end() && __i->first == __key) return __i->second; else return __ca .emplace_hint(__i, std::move(__key), __fn(*this, std::forward<_Args>(__args)...)) ->second; } }; template <class _F> typename cached_fixed_point<_F>::cache cached_fixed_point<_F>::__ca; } // namespace workspace #line 5 "Library/lib/utils" // #include "src/utils/grid.hpp" // #include "src/utils/hash.hpp" #line 2 "Library/src/utils/io/istream.hpp" /** * @file istream.hpp * @brief Input Stream */ #include <cxxabi.h> #line 13 "Library/src/utils/io/istream.hpp" #line 2 "Library/src/utils/sfinae.hpp" /** * @file sfinae.hpp * @brief SFINAE */ #line 11 "Library/src/utils/sfinae.hpp" #ifndef __INT128_DEFINED__ #ifdef __SIZEOF_INT128__ #define __INT128_DEFINED__ 1 #else #define __INT128_DEFINED__ 0 #endif #endif namespace std { #if __INT128_DEFINED__ template <> struct make_signed<__uint128_t> { using type = __int128_t; }; template <> struct make_signed<__int128_t> { using type = __int128_t; }; template <> struct make_unsigned<__uint128_t> { using type = __uint128_t; }; template <> struct make_unsigned<__int128_t> { using type = __uint128_t; }; #endif } // namespace std namespace workspace { template <class Tp, class... Args> struct variadic_front { using type = Tp; }; template <class... Args> struct variadic_back; template <class Tp> struct variadic_back<Tp> { using type = Tp; }; template <class Tp, class... Args> struct variadic_back<Tp, Args...> { using type = typename variadic_back<Args...>::type; }; template <class type, template <class> class trait> using enable_if_trait_type = typename std::enable_if<trait<type>::value>::type; template <class Container> using element_type = typename std::decay<decltype( *std::begin(std::declval<Container&>()))>::type; template <class T, class = std::nullptr_t> struct has_begin : std::false_type {}; template <class T> struct has_begin<T, decltype(std::begin(std::declval<T>()), nullptr)> : std::true_type {}; template <class T, class = int> struct mapped_of { using type = element_type<T>; }; template <class T> struct mapped_of<T, typename std::pair<int, typename T::mapped_type>::first_type> { using type = typename T::mapped_type; }; template <class T> using mapped_type = typename mapped_of<T>::type; template <class T, class = void> struct is_integral_ext : std::false_type {}; template <class T> struct is_integral_ext< T, typename std::enable_if<std::is_integral<T>::value>::type> : std::true_type {}; #if __INT128_DEFINED__ template <> struct is_integral_ext<__int128_t> : std::true_type {}; template <> struct is_integral_ext<__uint128_t> : std::true_type {}; #endif #if __cplusplus >= 201402 template <class T> constexpr static bool is_integral_ext_v = is_integral_ext<T>::value; #endif template <typename T, typename = void> struct multiplicable_uint { using type = uint_least32_t; }; template <typename T> struct multiplicable_uint< T, typename std::enable_if<(2 < sizeof(T)) && (!__INT128_DEFINED__ || sizeof(T) <= 4)>::type> { using type = uint_least64_t; }; #if __INT128_DEFINED__ template <typename T> struct multiplicable_uint<T, typename std::enable_if<(4 < sizeof(T))>::type> { using type = __uint128_t; }; #endif template <typename T> struct multiplicable_int { using type = typename std::make_signed<typename multiplicable_uint<T>::type>::type; }; } // namespace workspace #line 15 "Library/src/utils/io/istream.hpp" namespace workspace { namespace internal { template <class Tp, typename = std::nullptr_t> struct istream_helper { istream_helper(std::istream &is, Tp &x) { if constexpr (has_begin<Tp>::value) for (auto &&e : x) istream_helper<typename std::decay<decltype(e)>::type>(is, e); else static_assert(has_begin<Tp>::value, "istream unsupported type."); } }; template <class Tp> struct istream_helper< Tp, decltype(std::declval<std::decay<decltype(std::declval<std::istream &>() >> std::declval<Tp &>())>>(), nullptr)> { istream_helper(std::istream &is, Tp &x) { is >> x; } }; #ifdef __SIZEOF_INT128__ template <> struct istream_helper<__uint128_t, std::nullptr_t> { istream_helper(std::istream &__is, __uint128_t &__x) { std::string __s; __is >> __s; bool __neg = false; if (__s.front() == '-') __neg = true, __s.erase(__s.begin()); __x = 0; for (char __d : __s) { __x *= 10; __d -= '0'; if (__neg) __x -= __d; else __x += __d; } } }; template <> struct istream_helper<__int128_t, std::nullptr_t> { istream_helper(std::istream &__is, __int128_t &__x) { std::string __s; __is >> __s; bool __neg = false; if (__s.front() == '-') __neg = true, __s.erase(__s.begin()); __x = 0; for (char __d : __s) { __x *= 10; __d -= '0'; if (__neg) __x -= __d; else __x += __d; } } }; #endif // INT128 template <class T1, class T2> struct istream_helper<std::pair<T1, T2>> { istream_helper(std::istream &is, std::pair<T1, T2> &x) { istream_helper<T1>(is, x.first), istream_helper<T2>(is, x.second); } }; template <class... Tps> struct istream_helper<std::tuple<Tps...>> { istream_helper(std::istream &is, std::tuple<Tps...> &x) { iterate(is, x); } private: template <class Tp, size_t N = 0> void iterate(std::istream &is, Tp &x) { if constexpr (N == std::tuple_size<Tp>::value) return; else istream_helper<typename std::tuple_element<N, Tp>::type>(is, std::get<N>(x)), iterate<Tp, N + 1>(is, x); } }; } // namespace internal /** * @brief A wrapper class for std::istream. */ class istream : public std::istream { public: /** * @brief Wrapped operator. */ template <typename Tp> istream &operator>>(Tp &x) { internal::istream_helper<Tp>(*this, x); if (std::istream::fail()) { static auto once = atexit([] { std::cerr << "\n\033[43m\033[30mwarning: failed to read \'" << abi::__cxa_demangle(typeid(Tp).name(), 0, 0, 0) << "\'.\033[0m\n\n"; }); assert(!once); } return *this; } }; namespace internal { auto *const cin_ptr = (istream *)&std::cin; } auto &cin = *internal::cin_ptr; } // namespace workspace #line 2 "Library/src/utils/io/ostream.hpp" /** * @file ostream.hpp * @brief Output Stream */ #line 9 "Library/src/utils/io/ostream.hpp" namespace workspace { /** * @brief Stream insertion operator for std::pair. * * @param __os Output stream * @param __p Pair * @return Reference to __os. */ template <class Os, class T1, class T2> Os &operator<<(Os &__os, const std::pair<T1, T2> &__p) { return __os << __p.first << ' ' << __p.second; } /** * @brief Stream insertion operator for std::tuple. * * @param __os Output stream * @param __t Tuple * @return Reference to __os. */ template <class Os, class Tp, size_t N = 0> typename std::enable_if<bool(std::tuple_size<Tp>::value + 1), Os &>::type operator<<(Os &__os, const Tp &__t) { if constexpr (N != std::tuple_size<Tp>::value) { if constexpr (N) __os << ' '; __os << std::get<N>(__t); operator<<<Os, Tp, N + 1>(__os, __t); } return __os; } template <class Os, class Container, typename = decltype(std::begin(std::declval<Container>()))> typename std::enable_if< !std::is_same<typename std::decay<Container>::type, std::string>::value && !std::is_same<typename std::decay<Container>::type, char *>::value, Os &>::type operator<<(Os &__os, const Container &__cont) { bool __h = true; for (auto &&__e : __cont) __h ? __h = 0 : (__os << ' ', 0), __os << __e; return __os; } #ifdef __SIZEOF_INT128__ /** * @brief Stream insertion operator for __int128_t. * * @param __os Output Stream * @param __x 128-bit integer * @return Reference to __os. */ template <class Os> Os &operator<<(Os &__os, __int128_t __x) { if (!__x) return __os << '0'; if (__x < 0) __os << '-'; char __s[40], *__p = __s; while (__x) { auto __d = __x % 10; *__p++ = '0' + (__x < 0 ? -__d : __d); __x /= 10; } *__p = 0; for (char *__t = __s; __t < --__p; ++__t) *__t ^= *__p ^= *__t ^= *__p; return __os << __s; } /** * @brief Stream insertion operator for __uint128_t. * * @param __os Output Stream * @param __x 128-bit unsigned integer * @return Reference to __os. */ template <class Os> Os &operator<<(Os &__os, __uint128_t __x) { if (!__x) return __os << '0'; char __s[40], *__p = __s; while (__x) *__p++ = '0' + __x % 10, __x /= 10; *__p = 0; for (char *__t = __s; __t < --__p; ++__t) *__t ^= *__p ^= *__t ^= *__p; return __os << __s; } #endif } // namespace workspace #line 9 "Library/lib/utils" // #include "src/utils/io/read.hpp" #line 2 "Library/src/utils/io/setup.hpp" /* * @file setup.hpp * @brief I/O Setup */ #line 10 "Library/src/utils/io/setup.hpp" namespace workspace { /* * @fn io_setup * @brief Setup I/O. * @param precision Standard output precision */ void io_setup(int precision) { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); std::cout << std::fixed << std::setprecision(precision); #ifdef _buffer_check atexit([] { char bufc; if (std::cin >> bufc) std::cerr << "\n\033[43m\033[30mwarning: buffer not empty.\033[0m\n\n"; }); #endif } } // namespace workspace #line 2 "Library/src/utils/iterator/category.hpp" /* * @file category.hpp * @brief Iterator Category */ #line 10 "Library/src/utils/iterator/category.hpp" namespace workspace { /* * @tparam Tuple Tuple of iterator types */ template <class Tuple, size_t N = std::tuple_size<Tuple>::value - 1> struct common_iterator_category { using type = typename std::common_type< typename common_iterator_category<Tuple, N - 1>::type, typename std::iterator_traits<typename std::tuple_element< N, Tuple>::type>::iterator_category>::type; }; template <class Tuple> struct common_iterator_category<Tuple, 0> { using type = typename std::iterator_traits< typename std::tuple_element<0, Tuple>::type>::iterator_category; }; } // namespace workspace #line 12 "Library/lib/utils" // #include "src/utils/iterator/reverse.hpp" #line 2 "Library/src/utils/make_vector.hpp" /* * @file make_vector.hpp * @brief Multi-dimensional Vector */ #if __cplusplus >= 201703L #include <tuple> #include <vector> namespace workspace { /* * @brief Make a multi-dimensional vector. * @tparam Tp type of the elements * @tparam N dimension * @tparam S integer type * @param sizes The size of each dimension * @param init The initial value */ template <typename Tp, size_t N, typename S> constexpr auto make_vector([[maybe_unused]] S* sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v<S, size_t>); if constexpr (N) return std::vector(*sizes, make_vector<Tp, N - 1, S>(std::next(sizes), init)); else return init; } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template <typename Tp, size_t N, typename S> constexpr auto make_vector(const S (&sizes)[N], Tp const& init = Tp()) { return make_vector<Tp, N, S>((S*)sizes, init); } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template <typename Tp, size_t N, typename S, size_t I = 0> constexpr auto make_vector([[maybe_unused]] std::array<S, N> const& sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v<S, size_t>); if constexpr (I == N) return init; else return std::vector(sizes[I], make_vector<Tp, N, S, I + 1>(sizes, init)); } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template <typename Tp, size_t N = SIZE_MAX, size_t I = 0, class... Args> constexpr auto make_vector([[maybe_unused]] std::tuple<Args...> const& sizes, Tp const& init = Tp()) { using tuple_type = std::tuple<Args...>; if constexpr (I == std::tuple_size_v<tuple_type> || I == N) return init; else { static_assert( std::is_convertible_v<std::tuple_element_t<I, tuple_type>, size_t>); return std::vector(std::get<I>(sizes), make_vector<Tp, N, I + 1>(sizes, init)); } } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template <typename Tp, class Fst, class Snd> constexpr auto make_vector(std::pair<Fst, Snd> const& sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v<Fst, size_t>); static_assert(std::is_convertible_v<Snd, size_t>); return make_vector({(size_t)sizes.first, (size_t)sizes.second}, init); } } // namespace workspace #endif #line 14 "Library/lib/utils" // #include "src/utils/py-like/enumerate.hpp" #line 2 "Library/src/utils/py-like/range.hpp" /** * @file range.hpp * @brief Range */ #line 9 "Library/src/utils/py-like/range.hpp" #line 2 "Library/src/utils/iterator/reverse.hpp" /* * @file reverse_iterator.hpp * @brief Reverse Iterator */ #if __cplusplus >= 201703L #include <iterator> #include <optional> namespace workspace { /* * @class reverse_iterator * @brief Wrapper class for `std::reverse_iterator`. * @see http://gcc.gnu.org/PR51823 */ template <class Iterator> class reverse_iterator : public std::reverse_iterator<Iterator> { using base_std = std::reverse_iterator<Iterator>; std::optional<typename base_std::value_type> deref; public: using base_std::reverse_iterator; constexpr typename base_std::reference operator*() noexcept { if (!deref) { Iterator tmp = base_std::current; deref = *--tmp; } return deref.value(); } constexpr reverse_iterator &operator++() noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator &operator--() noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator operator++(int) noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator operator--(int) noexcept { base_std::operator++(); deref.reset(); return *this; } }; } // namespace workspace #endif #line 2 "Library/src/utils/py-like/reversed.hpp" /** * @file reversed.hpp * @brief Reversed */ #include <initializer_list> #line 10 "Library/src/utils/py-like/reversed.hpp" namespace workspace { namespace internal { template <class Container> class reversed { Container cont; public: constexpr reversed(Container &&cont) : cont(cont) {} constexpr auto begin() { return std::rbegin(cont); } constexpr auto end() { return std::rend(cont); } }; } // namespace internal template <class Container> constexpr auto reversed(Container &&cont) noexcept { return internal::reversed<Container>{std::forward<Container>(cont)}; } template <class Tp> constexpr auto reversed(std::initializer_list<Tp> &&cont) noexcept { return internal::reversed<std::initializer_list<Tp>>{ std::forward<std::initializer_list<Tp>>(cont)}; } } // namespace workspace #line 12 "Library/src/utils/py-like/range.hpp" #if __cplusplus >= 201703L namespace workspace { template <class Index> class range { Index first, last; public: class iterator { Index current; public: using difference_type = std::ptrdiff_t; using value_type = Index; using reference = typename std::add_const<Index>::type &; using pointer = iterator; using iterator_category = std::bidirectional_iterator_tag; constexpr iterator(Index const &__i = Index()) noexcept : current(__i) {} constexpr bool operator==(iterator const &rhs) const noexcept { return current == rhs.current; } constexpr bool operator!=(iterator const &rhs) const noexcept { return current != rhs.current; } constexpr iterator &operator++() noexcept { ++current; return *this; } constexpr iterator &operator--() noexcept { --current; return *this; } constexpr reference operator*() const noexcept { return current; } }; constexpr range(Index first, Index last) noexcept : first(first), last(last) {} constexpr range(Index last) noexcept : first(), last(last) {} constexpr iterator begin() const noexcept { return iterator{first}; } constexpr iterator end() const noexcept { return iterator{last}; } constexpr reverse_iterator<iterator> rbegin() const noexcept { return reverse_iterator<iterator>(end()); } constexpr reverse_iterator<iterator> rend() const noexcept { return reverse_iterator<iterator>(begin()); } }; template <class... Args> constexpr auto rrange(Args &&... args) noexcept { return internal::reversed(range(std::forward<Args>(args)...)); } } // namespace workspace #endif #line 16 "Library/lib/utils" // #include "src/utils/py-like/reversed.hpp" // #include "src/utils/py-like/zip.hpp" // #include "src/utils/rand/rng.hpp" // #include "src/utils/rand/shuffle.hpp" // #include "src/utils/round_div.hpp" // #include "src/utils/sfinae.hpp" #line 11 "other/m2.cc" signed main() { using namespace workspace; io_setup(15); /* given case_info.read(); //*/ /* unspecified case_info.total = -1; //*/ return case_info.iterate(); } #line 2 "Library/src/algebra/linear/matrix.hpp" /** * @file matrix.hpp * @brief Matrix * @date 2021-02-15 * * */ #line 13 "Library/src/algebra/linear/matrix.hpp" namespace workspace { template <class _Scalar, std::size_t _Rows = 0, std::size_t _Cols = _Rows> class matrix { public: using value_type = _Scalar; using size_type = std::size_t; value_type __data[_Rows][_Cols] = {}; constexpr static matrix eye() { static_assert(_Rows == _Cols); matrix __e; for (size_type __d = 0; __d != _Rows; ++__d) __e[__d][__d] = 1; return __e; } constexpr decltype(auto) operator[](size_type __r) { return __data[__r]; } constexpr decltype(auto) operator[](size_type __r) const { return __data[__r]; } constexpr auto begin() { return __data; } constexpr auto begin() const { return __data; } constexpr auto end() { return __data + _Rows; } constexpr auto end() const { return __data + _Rows; } constexpr size_type rows() const { return _Rows; } constexpr size_type cols() const { return _Cols; } auto transpose() const { matrix<_Scalar, _Cols, _Rows> __t; for (size_type __r = 0; __r != _Rows; ++__r) for (size_type __c = 0; __c != _Cols; ++__c) __t.__data[__c][__r] = __data[__r][__c]; return __t; } matrix operator+() const { return *this; } matrix operator-() const { matrix __cp = *this; for (auto& __v : __cp.__data) for (auto& __e : __v) __e = -__e; return __cp; } template <class _Matrix> matrix& operator+=(const _Matrix& __x) { auto __m = std::min(_Rows, __x.rows()); auto __n = std::min(_Cols, __x.cols()); for (size_type __r = 0; __r != __m; ++__r) for (size_type __c = 0; __c != __n; ++__c) __data[__r][__c] += __x[__r][__c]; return *this; } template <class _Matrix> matrix operator+(const _Matrix& __x) const { return matrix(*this) += __x; } template <class _Matrix> matrix& operator-=(const _Matrix& __x) { auto __m = std::min(_Rows, __x.rows()); auto __n = std::min(_Cols, __x.cols()); for (size_type __r = 0; __r != __m; ++__r) for (size_type __c = 0; __c != __n; ++__c) __data[__r][__c] -= __x[__r][__c]; return *this; } template <class _Matrix> matrix operator-(const _Matrix& __x) const { return matrix(*this) -= __x; } template <class _Matrix> typename std::enable_if<!std::is_convertible<_Matrix, value_type>::value, matrix&>::type operator*=(_Matrix&& __x) { return operator=(operator*(std::forward<_Matrix>(__x))); } template <class _Matrix> typename std::enable_if<!std::is_convertible<_Matrix, value_type>::value, matrix<_Scalar, 0, 0>>::type operator*(const _Matrix& __x) const { assert(_Cols <= __x.rows()); matrix<_Scalar> __m(_Rows, __x.cols()); for (size_type __r = 0; __r != _Rows; ++__r) for (size_type __c = 0; __c != _Cols; ++__c) for (size_type __i = 0; __i != __x.cols(); ++__i) __m[__r][__i] += __data[__r][__c] * __x[__c][__i]; return __m; } template <class _Scalar2, size_type _Cols2> auto operator*(const matrix<_Scalar2, _Cols, _Cols2>& __x) const { matrix<_Scalar, _Rows, _Cols2> __m; for (auto *__s = __data, __r = *__data, *__t = __m.__data, __w = *__m.__data; __s != __data + _Rows; __r = *++__s, __w = *++__t) for (size_type __c = 0; __c != _Cols2; ++__c, ++__w, __r = *__s) for (size_type __i = 0; __i != _Cols; ++__i, ++__r) *__w += *__r * *(*(__x.__data + __i) + __c); // for (size_type __c = 0; __c != _Cols2; ++__c) // for (size_type __i = 0; __i != _Cols; ++__i) // *(*__t + __c) += *(*__s + __i) * __x.__data[__i][__c]; return __m; } matrix& operator*=(const value_type& __x) { for (auto& __v : __data) for (auto& __e : __v) __e *= __x; return *this; } matrix operator*(const value_type& __x) const { return matrix(*this) *= __x; } matrix& operator/=(const value_type& __x) { assert(__x != value_type(0)); for (auto& __v : __data) for (auto& __e : __v) __e /= __x; return *this; } matrix operator/(const value_type& __x) const { return matrix(*this) /= __x; } template <class _Int> matrix pow(_Int __e) const { static_assert(_Rows == _Cols); assert(0 <= __e); matrix __m = eye(); for (matrix __cp = *this; __e; __cp *= __cp, __e >>= 1) if (__e & 1) __m *= __cp; return __m; } template <class _Os> friend _Os& operator<<(_Os& __os, const matrix& __x) { for (auto __i = __x.begin(); __i != __x.end(); ++__i, __os << '\n') for (size_type __c = 0; __c != _Cols; ++__c) __c ? void(__os << ' ') : (void)0, __os << *(*__i + __c); return __os; } }; template <class _Scalar> class matrix<_Scalar, 0, 0> : public std::valarray<std::valarray<_Scalar>> { using base = std::valarray<std::valarray<_Scalar>>; using row_type = typename base::value_type; public: using value_type = _Scalar; using size_type = std::size_t; using base::operator[]; static matrix eye(size_type __n) { matrix __e(__n, __n); for (size_type __d = 0; __d != __n; ++__d) __e[__d][__d] = 1; return __e; } matrix() = default; matrix(size_type __n) : matrix(__n, __n) {} matrix(size_type __m, size_type __n) : base(row_type(__n), __m) {} matrix(std::initializer_list<row_type> __x) : base(__x) {} size_type rows() const { return base::size(); } size_type cols() const { return rows() ? operator[](0).size() : 0; } matrix transpose() const { matrix __t(cols(), rows()); for (size_type __r = 0; __r != rows(); ++__r) for (size_type __c = 0; __c != cols(); ++__c) __t[__c][__r] = operator[](__r)[__c]; return __t; } void resize(size_type __m, size_type __n) { matrix __t(__m, __n); if (rows() < __m) __m = rows(); if (cols() < __n) __n = cols(); for (size_type __r = 0; __r != __m; ++__r) for (size_type __c = 0; __c != __n; ++__c) __t[__r][__c] = std::move(operator[](__r)[__c]); base::swap(__t); } // unary operators {{ matrix operator+() const { return *this; } matrix operator-() const { auto __cp = *this; for (size_type __r = 0; __r != rows(); ++__r) for (size_type __c = 0; __c != cols(); ++__c) __cp[__r][__c] = -__cp[__r][__c]; return __cp; } // }} unary operators // binary operators {{ template <class _Matrix> matrix& operator+=(const _Matrix& __x) { auto __m = std::min(rows(), __x.rows()); auto __n = std::min(cols(), __x.cols()); for (size_type __r = 0; __r != __m; ++__r) for (size_type __c = 0; __c != __n; ++__c) operator[](__r)[__c] += __x[__r][__c]; return *this; } template <class _Matrix> matrix operator+(const _Matrix& __x) const { return matrix(*this) += __x; } template <class _Matrix> matrix& operator-=(const _Matrix& __x) { auto __m = std::min(rows(), __x.rows()); auto __n = std::min(cols(), __x.cols()); for (size_type __r = 0; __r != __m; ++__r) for (size_type __c = 0; __c != __n; ++__c) operator[](__r)[__c] -= __x[__r][__c]; return *this; } template <class _Matrix> matrix operator-(const _Matrix& __x) const { return matrix(*this) -= __x; } template <class _Matrix, typename = void> struct is_valarray_based : std::false_type {}; template <class _Matrix> struct is_valarray_based< _Matrix, typename std::enable_if<std::is_same< row_type, typename std::decay<decltype( std::declval<_Matrix>()[0])>::type>::value>::type> : std::true_type {}; template <class _Matrix> typename std::enable_if<!std::is_convertible<_Matrix, value_type>::value, matrix&>::type operator*=(_Matrix&& __x) { return operator=(operator*(std::forward<_Matrix>(__x))); } template <class _Matrix> typename std::enable_if<!std::is_convertible<_Matrix, value_type>::value, matrix>::type operator*(const _Matrix& __x) const { assert(cols() <= __x.rows()); matrix __m(rows(), __x.cols()); if constexpr (is_valarray_based<_Matrix>::value) for (size_type __r = 0; __r != rows(); ++__r) for (size_type __c = 0; __c != cols(); ++__c) __m[__r] += operator[](__r)[__c] * __x[__c]; else for (size_type __r = 0; __r != rows(); ++__r) for (size_type __c = 0; __c != cols(); ++__c) for (size_type __i = 0; __i != __x.cols(); ++__i) __m[__r][__i] += operator[](__r)[__c] * __x[__c][__i]; return __m; } matrix& operator*=(const value_type& __x) { for (size_type __r = 0; __r != rows(); ++__r) operator[](__r).operator*=(__x); return *this; } matrix operator*(const value_type& __x) const { return matrix(*this) *= __x; } friend matrix operator*(const value_type& __x, matrix __y) { for (size_type __r = 0; __r != __y.rows(); ++__r) __y.operator[](__r) = __x * __y.operator[](__r); return __y; } matrix& operator/=(const value_type& __x) { assert(__x != value_type(0)); for (size_type __r = 0; __r != rows(); ++__r) operator[](__r).operator/=(__x); return *this; } matrix operator/(const value_type& __x) const { return matrix(*this) /= __x; } // }} binary operators template <class _Int> matrix pow(_Int __e) const { assert(0 <= __e); matrix __m = eye(rows()); for (matrix __cp = *this; __e; __cp *= __cp, __e >>= 1) if (__e & 1) __m *= __cp; return __m; } // template <class _Is> friend _Is& operator>>(_Is& __is, matrix& __x) { // for (size_type __r = 0; __r != __x.rows(); ++__r) // for (size_type __c = 0; __c != __x.cols(); ++__c) // __is >> __x.operator[](__r).operator[](__c); // return __is; // } template <class _Os> friend _Os& operator<<(_Os& __os, const matrix& __x) { for (size_type __r = 0; __r != __x.rows(); ++__r, __os << '\n') for (size_type __c = 0; __c != __x.cols(); ++__c) __c ? void(__os << ' ') : (void)0, __os << __x.operator[](__r).operator[](__c); return __os; } }; } // namespace workspace #line 2 "Library/src/modular/modint.hpp" /** * @file modint.hpp * * @brief Modular Arithmetic */ #line 12 "Library/src/modular/modint.hpp" #line 14 "Library/src/modular/modint.hpp" namespace workspace { namespace internal { /** * @brief Base of modular arithmetic. * * @tparam Mod identifier, which represents modulus if positive * @tparam Storage Reserved size for inverse calculation */ template <auto Mod, unsigned Storage> struct modint_base { static_assert(is_integral_ext<decltype(Mod)>::value, "Mod must be integral type."); using mod_type = typename std::make_signed<typename std::conditional< 0 < Mod, typename std::add_const<decltype(Mod)>::type, decltype(Mod)>::type>::type; using value_type = typename std::decay<mod_type>::type; using mul_type = typename multiplicable_uint<value_type>::type; static mod_type mod; static value_type storage; constexpr static void reserve(unsigned __n) noexcept { storage = __n; } protected: value_type value = 0; public: constexpr modint_base() noexcept = default; template <class int_type, typename std::enable_if<is_integral_ext<int_type>::value>::type * = nullptr> constexpr modint_base(int_type n) noexcept : value((n %= mod) < 0 ? n += mod : n) {} constexpr modint_base(bool n) noexcept : value(n) {} constexpr operator value_type() const noexcept { return value; } constexpr static modint_base one() noexcept { return 1; } // unary operators {{ constexpr modint_base operator++(int) noexcept { modint_base __t{*this}; operator++(); return __t; } constexpr modint_base operator--(int) noexcept { modint_base __t{*this}; operator--(); return __t; } constexpr modint_base &operator++() noexcept { if (++value == mod) value = 0; return *this; } constexpr modint_base &operator--() noexcept { if (!value) value = mod; --value; return *this; } constexpr modint_base operator-() const noexcept { modint_base __t; __t.value = value ? mod - value : 0; return __t; } // }} unary operators // operator+= {{ constexpr modint_base &operator+=(modint_base const &rhs) noexcept { if ((value += rhs.value) >= mod) value -= mod; return *this; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type & operator+=(int_type const &rhs) noexcept { if (((value += rhs) %= mod) < 0) value += mod; return *this; } // }} operator+= // operator+ {{ template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator+(int_type const &rhs) const noexcept { return modint_base{*this} += rhs; } constexpr modint_base operator+(modint_base rhs) const noexcept { return rhs += *this; } template <class int_type> constexpr friend typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator+(int_type const &lhs, modint_base rhs) noexcept { return rhs += lhs; } // }} operator+ // operator-= {{ constexpr modint_base &operator-=(modint_base const &rhs) noexcept { if ((value -= rhs.value) < 0) value += mod; return *this; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type & operator-=(int_type rhs) noexcept { if (((value -= rhs) %= mod) < 0) value += mod; return *this; } // }} operator-= // operator- {{ template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator-(int_type const &rhs) const noexcept { return modint_base{*this} -= rhs; } constexpr modint_base operator-(modint_base const &rhs) const noexcept { modint_base __t; if (((__t.value = value) -= rhs.value) < 0) __t.value += mod; return __t; } template <class int_type> constexpr friend typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator-(int_type lhs, modint_base const &rhs) noexcept { if (((lhs -= rhs.value) %= mod) < 0) lhs += mod; modint_base __t; __t.value = lhs; return __t; } // }} operator- // operator*= {{ constexpr modint_base &operator*=(modint_base const &rhs) noexcept { if (!rhs.value) value = 0; else if (value) { mul_type __r(value); value = static_cast<value_type>((__r *= rhs.value) %= mod); } return *this; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type & operator*=(int_type rhs) noexcept { if (!rhs) value = 0; else if (value) { if ((rhs %= mod) < 0) rhs += mod; mul_type __r(value); value = static_cast<value_type>((__r *= rhs) %= mod); } return *this; } // }} operator*= // operator* {{ constexpr modint_base operator*(modint_base const &rhs) const noexcept { if (!value or !rhs.value) return {}; mul_type __r(value); modint_base __t; __t.value = static_cast<value_type>((__r *= rhs.value) %= mod); return __t; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator*(int_type rhs) const noexcept { if (!value or !rhs) return {}; if ((rhs %= mod) < 0) rhs += mod; mul_type __r(value); modint_base __t; __t.value = static_cast<value_type>((__r *= rhs) %= mod); return __t; } template <class int_type> constexpr friend typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator*(int_type lhs, modint_base const &rhs) noexcept { if (!lhs or !rhs.value) return {}; if ((lhs %= mod) < 0) lhs += mod; mul_type __r(lhs); modint_base __t; __t.value = (__r *= rhs.value) %= mod; return __t; } // }} operator* protected: static value_type _mem(value_type __x) { static std::vector<value_type> __m{0, 1}; static value_type __i = (__m.reserve(Storage), 1); while (__i < __x) { ++__i; __m.emplace_back(mod - mul_type(mod / __i) * __m[mod % __i] % mod); } return __m[__x]; } template <class int_type> constexpr static typename std::enable_if<is_integral_ext<int_type>::value, value_type>::type _div(mul_type __r, int_type __x) noexcept { assert(__x); if (!__r) return 0; int_type __v{}; bool __neg = __x < 0 ? __x = -__x, true : false; if (__x < storage) __v = _mem(__x); else { int_type __y{mod}, __u{1}, __t; while (__x) __t = __y / __x, __y ^= __x ^= (__y -= __t * __x) ^= __x, __v ^= __u ^= (__v -= __t * __u) ^= __u; if (__y < 0) __neg ^= 1; } if (__neg) __v = 0 < __v ? mod - __v : -__v; else if (__v < 0) __v += mod; if (__r == 1) return static_cast<value_type>(__v); return static_cast<value_type>((__r *= __v) %= mod); } public: // operator/= {{ constexpr modint_base &operator/=(modint_base const &rhs) noexcept { if (value) value = _div(value, rhs.value); return *this; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type & operator/=(int_type rhs) noexcept { if (value) value = _div(value, rhs %= mod); return *this; } // }} operator/= // operator/ {{ constexpr modint_base operator/(modint_base const &rhs) const noexcept { if (!value) return {}; modint_base __t; __t.value = _div(value, rhs.value); return __t; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator/(int_type rhs) const noexcept { if (!value) return {}; modint_base __t; __t.value = _div(value, rhs %= mod); return __t; } template <class int_type> constexpr friend typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type operator/(int_type lhs, modint_base const &rhs) noexcept { if (!lhs) return {}; if ((lhs %= mod) < 0) lhs += mod; modint_base __t; __t.value = _div(lhs, rhs.value); return __t; } // }} operator/ constexpr modint_base inv() const noexcept { return _div(1, value); } template <class int_type> friend constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type pow(modint_base b, int_type e) noexcept { if (e < 0) { e = -e; b.value = _div(1, b.value); } modint_base __r; for (__r.value = 1; e; e >>= 1, b *= b) if (e & 1) __r *= b; return __r; } template <class int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, modint_base>::type pow(int_type e) const noexcept { modint_base __r, b; __r.value = 1; for (b.value = e < 0 ? e = -e, _div(1, value) : value; e; e >>= 1, b *= b) if (e & 1) __r *= b; return __r; } friend std::ostream &operator<<(std::ostream &os, const modint_base &rhs) noexcept { return os << rhs.value; } friend std::istream &operator>>(std::istream &is, modint_base &rhs) noexcept { intmax_t value; rhs = (is >> value, value); return is; } }; template <auto Mod, unsigned Storage> typename modint_base<Mod, Storage>::mod_type modint_base<Mod, Storage>::mod = Mod > 0 ? Mod : 0; template <auto Mod, unsigned Storage> typename modint_base<Mod, Storage>::value_type modint_base<Mod, Storage>::storage = Storage; } // namespace internal /** * @brief Modular arithmetic. * * @tparam Mod modulus * @tparam Storage Reserved size for inverse calculation */ template <auto Mod, unsigned Storage = 0, typename std::enable_if<(Mod > 0)>::type * = nullptr> using modint = internal::modint_base<Mod, Storage>; /** * @brief Runtime modular arithmetic. * * @tparam type_id uniquely assigned * @tparam Storage Reserved size for inverse calculation */ template <unsigned type_id = 0, unsigned Storage = 0> using modint_runtime = internal::modint_base<-(signed)type_id, Storage>; // #define modint_newtype modint_runtime<__COUNTER__> } // namespace workspace #line 28 "other/m2.cc" namespace workspace { using mint = modint<998244353>; constexpr int msiz = 125; using mat = matrix<mint, msiz>; void main() { // start here! int n, k; cin >> n >> k; mat a; auto cvrt = [&](auto x) -> auto { return x[0] + k * x[1] + k * k * x[2]; }; for (auto i : range(a.cols())) { array<int, 3> id; { auto cp = i; for (auto j : range(3)) { id[j] = cp % k; cp /= k; } } { auto cp = id; (++cp[0]) %= k; ++a[i][cvrt(cp)]; // ++a.at(i * a.cols() + cvrt(cp)); } { auto cp = id; (cp[1] += cp[0]) %= k; ++a[i][cvrt(cp)]; // ++a.at(i * a.cols() + cvrt(cp)); } { auto cp = id; (cp[2] += cp[1]) %= k; ++a[i][cvrt(cp)]; // ++a.at(i * a.cols() + cvrt(cp)); } } a = a.pow(n); mint ans; for (auto i : range(k * k)) { // ans += a.at(i); ans += a[0][i]; } cout << ans << "\n"; } } // namespace workspace