#line 1 "other/y.cc" // #undef _GLIBCXX_DEBUG // #define NDEBUG #include #line 2 "Library/lib/alias" /** * @file alias * @brief Alias */ #line 13 "Library/lib/alias" #line 2 "Library/lib/bit" #if __cplusplus > 201703L #include #else #ifndef _GLIBCXX_BIT #define _GLIBCXX_BIT 1 #include #include namespace std { template 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 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 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::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::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::max(); unsigned long long __low = __x & __max_ull; return (_Nd - _Nd_ull) + __builtin_clzll(__low); } } template 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 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::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::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::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 constexpr int __countr_one(_Tp __x) noexcept { if (__x == numeric_limits<_Tp>::max()) return numeric_limits<_Tp>::digits; return __countr_zero((_Tp)~__x); } template constexpr int __popcount(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return 0; constexpr auto _Nd_ull = numeric_limits::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::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::max(); unsigned long long __low = __x & __max_ull; unsigned long long __high = __x >> _Nd_ull; return __builtin_popcountll(__low) + __builtin_popcountll(__high); } } template constexpr bool __has_single_bit(_Tp __x) noexcept { return __popcount(__x) == 1; } template 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 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 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 > using priority_queue = std::priority_queue, Comp>; template using stack = std::stack>; template constexpr _Tp __bsf(_Tp __x) noexcept { return std::__countr_zero(__x); } template constexpr _Tp __bsr(_Tp __x) noexcept { return std::__bit_width(__x) - 1; } } // namespace workspace #line 6 "other/y.cc" // #include "lib/cxx20" #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 8 "other/y.cc" // #include "lib/opt" #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(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 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/cached.hpp" /** * @file cached.hpp * @brief Cached * @date 2021-02-25 * * */ #line 12 "Library/src/utils/cached.hpp" #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 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 decltype(auto) operator()(_Args &&... __args) const noexcept { return __fn(*this, std::forward<_Args>(__args)...); } }; /** * @brief Cached version of Fixed Point Combinator */ template class cached_fixed_point { template struct _cache; template struct _cache<_R (_G::*)(_H, _Args...) const> : std::map, _R> {}; using cache = _cache &>)>; _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 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 typename cached_fixed_point<_F>::cache cached_fixed_point<_F>::__ca; } // namespace workspace #line 14 "Library/src/utils/cached.hpp" namespace workspace { namespace cached_impl { // Convert keys to tuple. template struct get_tuple { using type = decltype(std::tuple_cat( std::declval, _Args>, std::decay_t<_Args>, _Args>>>()...)); }; // Associative array. template struct assoc : std::bool_constant>, std::conditional_t, std::set::type>, std::map::type, _Value>> { }; // Non-resursive lambda type. template struct is_recursive : std::false_type {}; // Resursive lambda type. template struct is_recursive< _F, std::void_t &>)>> : std::true_type {}; // Recursive ver. template class _recursive { template struct _cache; template struct _cache<_R (_G::*)(_H, _Args...)> : assoc<_R, _Args...> {}; template struct _cache<_R (_G::*)(_H, _Args...) const> : assoc<_R, _Args...> {}; using cache = _cache &>)>; _F __fn; static cache __ca; public: _recursive(_F __x) noexcept : __fn(__x) {} /** * @brief Apply `*this` to 1st argument of the lambda. * @param __args Rest of arguments. */ template decltype(auto) operator()(_Args &&...__args) noexcept { typename cache::key_type __key(__args...); if constexpr (cache::value) { 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; } else if (auto __i = __ca.lower_bound(__key); __i == __ca.end() || *__i != __key) __ca.emplace_hint(__i, std::move(__key)), __fn(*this, std::forward<_Args>(__args)...); } }; template typename _recursive<_F>::cache _recursive<_F>::__ca; // Non-recursive ver. template class _non_recursive { template struct _get_func { using type = _T; }; template struct _get_func<_T, std::void_t> { using type = decltype(&_T::operator()); }; template struct _cache; template struct _cache<_R(_Args...)> : assoc<_R, _Args...> {}; template struct _cache<_R (*)(_Args...)> : assoc<_R, _Args...> {}; template struct _cache<_R (_G::*)(_Args...)> : assoc<_R, _Args...> {}; template struct _cache<_R (_G::*)(_Args...) const> : assoc<_R, _Args...> {}; using cache = _cache::type>; _F __fn; cache __ca; public: _non_recursive(_F __fn) noexcept : __fn(__fn) {} /** * @param __args */ template decltype(auto) operator()(_Args &&...__args) noexcept { typename cache::key_type __key(__args...); if constexpr (cache::value) { 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(std::forward<_Args>(__args)...)) ->second; } else if (auto __i = __ca.lower_bound(__key); __i == __ca.end() || *__i != __key) __ca.emplace_hint(__i, std::move(__key)), __fn(std::forward<_Args>(__args)...); } }; template using _cached = std::conditional_t::value, _recursive<_F>, _non_recursive<_F>>; } // namespace cached_impl /** * @brief Cached caller of function */ template class cached : public cached_impl::_cached<_F> { public: /** * @brief Construct a new cached object * * @param __x Function */ cached(_F __x = _F()) noexcept : cached_impl::_cached<_F>(__x) {} }; } // namespace workspace #line 2 "Library/src/utils/cat.hpp" /** * @file cat.hpp * @brief Cat */ #line 9 "Library/src/utils/cat.hpp" namespace workspace { /** * @brief Concatenate two sequences. * * @param __c1 * @param __c2 * @return Concatenated sequence. */ template constexpr decltype(auto) cat(_C1 &&__c1, _C2 &&__c2) noexcept { auto __c = std::forward<_C1>(__c1); if constexpr (std::is_rvalue_reference::value) __c.insert(std::end(__c), std::move_iterator(std::begin(__c2)), std::move_iterator(std::end(__c2))); else __c.insert(std::end(__c), std::cbegin(__c2), std::cend(__c2)); return __c; } /** * @return Concatenated sequence. */ template constexpr decltype(auto) cat(_C1 &&__c1, _C2 &&__c2, _Args &&...__args) noexcept { return cat(cat(std::forward<_C1>(__c1), std::forward<_C2>(__c2)), std::forward<_Args>(__args)...); } } // 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 > 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 > bool chge(Tp &x, const Tp &y, Comp comp = Comp()) { return comp(x, y) ? x = y, true : false; } } // namespace workspace #line 6 "Library/lib/utils" // #include "src/utils/grid.hpp" #line 2 "Library/src/utils/hash.hpp" #line 8 "Library/src/utils/hash.hpp" #line 2 "Library/src/utils/sfinae.hpp" /** * @file sfinae.hpp * @brief SFINAE */ #line 10 "Library/src/utils/sfinae.hpp" #include #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 struct variadic_front { using type = Tp; }; template struct variadic_back; template struct variadic_back { using type = Tp; }; template struct variadic_back { using type = typename variadic_back::type; }; template class trait> using enable_if_trait_type = typename std::enable_if::value>::type; /** * @brief Return type of subscripting ( @c [] ) access. */ template using subscripted_type = typename std::decay()[0])>::type; template using element_type = typename std::decay()))>::type; template struct has_begin : std::false_type {}; template struct has_begin<_Tp, decltype(std::begin(std::declval<_Tp>()), nullptr)> : std::true_type {}; template struct has_mod : std::false_type {}; template struct has_mod<_Tp, decltype(_Tp::mod, nullptr)> : std::true_type {}; template struct is_integral_ext : std::false_type {}; template struct is_integral_ext< _Tp, typename std::enable_if::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 constexpr static bool is_integral_ext_v = is_integral_ext<_Tp>::value; #endif template struct multiplicable_uint { using type = uint_least32_t; }; template struct multiplicable_uint< _Tp, typename std::enable_if<(2 < sizeof(_Tp)) && (!__INT128_DEFINED__ || sizeof(_Tp) <= 4)>::type> { using type = uint_least64_t; }; #if __INT128_DEFINED__ template struct multiplicable_uint<_Tp, typename std::enable_if<(4 < sizeof(_Tp))>::type> { using type = __uint128_t; }; #endif template struct multiplicable_int { using type = typename std::make_signed::type>::type; }; } // namespace workspace #line 10 "Library/src/utils/hash.hpp" namespace workspace { template struct hash : std::hash {}; #if __cplusplus >= 201703L template struct hash> { size_t operator()(uint64_t x) const { static const uint64_t m = std::random_device{}(); x ^= x >> 23; x ^= m; x ^= x >> 47; return x - (x >> 32); } }; #endif template size_t hash_combine(const size_t &seed, const Key &key) { return seed ^ (hash()(key) + 0x9e3779b9 /* + (seed << 6) + (seed >> 2) */); } template struct hash> { size_t operator()(const std::pair &pair) const { return hash_combine(hash()(pair.first), pair.second); } }; template class hash> { template ::value - 1> struct tuple_hash { static uint64_t apply(const Tuple &t) { return hash_combine(tuple_hash::apply(t), std::get(t)); } }; template struct tuple_hash { static uint64_t apply(const Tuple &t) { return 0; } }; public: uint64_t operator()(const std::tuple &t) const { return tuple_hash>::apply(t); } }; template struct hash_table_wrapper : hash_table { using key_type = typename hash_table::key_type; size_t count(const key_type &key) const { return hash_table::find(key) != hash_table::end(); } template auto emplace(Args &&... args) { return hash_table::insert(typename hash_table::value_type(args...)); } }; template using cc_hash_table = hash_table_wrapper<__gnu_pbds::cc_hash_table>>; template using gp_hash_table = hash_table_wrapper<__gnu_pbds::gp_hash_table>>; template using unordered_map = std::unordered_map>; template using unordered_set = std::unordered_set>; } // namespace workspace #line 2 "Library/src/utils/io/istream.hpp" /** * @file istream.hpp * @brief Input Stream */ #include #line 13 "Library/src/utils/io/istream.hpp" #line 15 "Library/src/utils/io/istream.hpp" namespace workspace { namespace internal { template struct istream_helper { istream_helper(std::istream &is, Tp &x) { if constexpr (has_begin::value) for (auto &&e : x) istream_helper::type>(is, e); else static_assert(has_begin::value, "istream unsupported type."); } }; template struct istream_helper< Tp, decltype(std::declval() >> std::declval())>>(), 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 struct istream_helper> { istream_helper(std::istream &is, std::pair &x) { istream_helper(is, x.first), istream_helper(is, x.second); } }; template struct istream_helper> { istream_helper(std::istream &is, std::tuple &x) { iterate(is, x); } private: template void iterate(std::istream &is, Tp &x) { if constexpr (N == std::tuple_size::value) return; else istream_helper::type>(is, std::get(x)), iterate(is, x); } }; } // namespace internal /** * @brief A wrapper class for std::istream. */ class istream : public std::istream { public: /** * @brief Wrapped operator. */ template istream &operator>>(Tp &x) { internal::istream_helper(*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; } }; decltype(auto) cin = static_cast(std::cin); } // 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 { template struct is_ostream { template static std::true_type __test(std::basic_ostream<_Args...> *); static std::false_type __test(void *); constexpr static bool value = decltype(__test(std::declval<_Os *>()))::value; }; template using ostream_ref = typename std::enable_if::value, _Os &>::type; /** * @brief Stream insertion operator for C-style array. * * @param __os Output stream * @param __a Array * @return Reference to __os. */ template typename std::enable_if 2), ostream_ref<_Os>>::type operator<<(_Os &__os, const _Tp (&__a)[_Nm]) { if constexpr (_Nm) { __os << *__a; for (auto __i = __a + 1, __e = __a + _Nm; __i != __e; ++__i) __os << ' ' << *__i; } return __os; } /** * @brief Stream insertion operator for std::pair. * * @param __os Output stream * @param __p Pair * @return Reference to __os. */ template ostream_ref<_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 typename std::enable_if::value + 1), ostream_ref<_Os>>::type operator<<(_Os &__os, const _Tp &__t) { if constexpr (_Nm != std::tuple_size<_Tp>::value) { if constexpr (_Nm) __os << ' '; __os << std::get<_Nm>(__t); operator<<<_Os, _Tp, _Nm + 1>(__os, __t); } return __os; } template ()))> typename std::enable_if< !std::is_same::type, std::string>::value && !std::is_same::type, char *>::value, ostream_ref<_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 ostream_ref<_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 ostream_ref<_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 10 "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 ::value - 1> struct common_iterator_category { using type = typename std::common_type< typename common_iterator_category::type, typename std::iterator_traits::type>::iterator_category>::type; }; template struct common_iterator_category { using type = typename std::iterator_traits< typename std::tuple_element<0, Tuple>::type>::iterator_category; }; } // namespace workspace #line 2 "Library/src/utils/iterator/reverse.hpp" /* * @file reverse_iterator.hpp * @brief Reverse Iterator */ #if __cplusplus >= 201703L #include #include namespace workspace { /* * @class reverse_iterator * @brief Wrapper class for `std::reverse_iterator`. * @see http://gcc.gnu.org/PR51823 */ template class reverse_iterator : public std::reverse_iterator { using base_std = std::reverse_iterator; std::optional 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/make_vector.hpp" /* * @file make_vector.hpp * @brief Multi-dimensional Vector */ #if __cplusplus >= 201703L #include #include 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 constexpr auto make_vector([[maybe_unused]] S* sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v); if constexpr (N) return std::vector(*sizes, make_vector(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 constexpr auto make_vector(const S (&sizes)[N], Tp const& init = Tp()) { return make_vector((S*)sizes, init); } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template constexpr auto make_vector([[maybe_unused]] std::array const& sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v); if constexpr (I == N) return init; else return std::vector(sizes[I], make_vector(sizes, init)); } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template constexpr auto make_vector([[maybe_unused]] std::tuple const& sizes, Tp const& init = Tp()) { using tuple_type = std::tuple; if constexpr (I == std::tuple_size_v || I == N) return init; else { static_assert( std::is_convertible_v, size_t>); return std::vector(std::get(sizes), make_vector(sizes, init)); } } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template constexpr auto make_vector(std::pair const& sizes, Tp const& init = Tp()) { static_assert(std::is_convertible_v); static_assert(std::is_convertible_v); return make_vector({(size_t)sizes.first, (size_t)sizes.second}, init); } } // namespace workspace #endif #line 2 "Library/src/utils/py-like/enumerate.hpp" /* * @file enumerate.hpp * @brief Enumerate */ #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/py-like/reversed.hpp" /** * @file reversed.hpp * @brief Reversed */ #include #line 10 "Library/src/utils/py-like/reversed.hpp" namespace workspace { namespace internal { template 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 constexpr auto reversed(Container &&cont) noexcept { return internal::reversed{std::forward(cont)}; } template constexpr auto reversed(std::initializer_list &&cont) noexcept { return internal::reversed>{ std::forward>(cont)}; } } // namespace workspace #line 12 "Library/src/utils/py-like/range.hpp" #if __cplusplus >= 201703L namespace workspace { template 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::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 rbegin() const noexcept { return reverse_iterator(end()); } constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); } }; template constexpr auto rrange(Args &&... args) noexcept { return internal::reversed(range(std::forward(args)...)); } } // namespace workspace #endif #line 2 "Library/src/utils/py-like/zip.hpp" /** * @file zip.hpp * @brief Zip */ #line 11 "Library/src/utils/py-like/zip.hpp" #line 14 "Library/src/utils/py-like/zip.hpp" #if __cplusplus >= 201703L namespace workspace { namespace internal { template struct zipped_iterator; template struct zipped_iterator_tuple; template class zipped { using ref_tuple = std::tuple; ref_tuple args; template constexpr auto begin_cat() const noexcept { if constexpr (N != std::tuple_size::value) { return std::tuple_cat(std::tuple(std::begin(std::get(args))), begin_cat()); } else return std::tuple<>(); } template constexpr auto end_cat() const noexcept { if constexpr (N != std::tuple_size::value) { return std::tuple_cat(std::tuple(std::end(std::get(args))), end_cat()); } else return std::tuple<>(); } public: constexpr zipped(Args &&... args) noexcept : args(args...) {} class iterator { using base_tuple = typename zipped_iterator_tuple::type; public: using iterator_category = typename common_iterator_category::type; using difference_type = std::ptrdiff_t; using value_type = zipped_iterator; using reference = zipped_iterator &; using pointer = iterator; protected: value_type current; template constexpr bool equal(const iterator &rhs) const noexcept { if constexpr (N != std::tuple_size::value) { return std::get(current) == std::get(rhs.current) || equal(rhs); } else return false; } template constexpr void increment() noexcept { if constexpr (N != std::tuple_size::value) { ++std::get(current); increment(); } } template constexpr void decrement() noexcept { if constexpr (N != std::tuple_size::value) { --std::get(current); decrement(); } } template constexpr void advance(difference_type __d) noexcept { if constexpr (N != std::tuple_size::value) { std::get(current) += __d; advance(__d); } } public: constexpr iterator() noexcept = default; constexpr iterator(base_tuple const ¤t) noexcept : current(current) {} constexpr bool operator==(const iterator &rhs) const noexcept { return equal(rhs); } constexpr bool operator!=(const iterator &rhs) const noexcept { return !equal(rhs); } constexpr iterator &operator++() noexcept { increment(); return *this; } constexpr iterator &operator--() noexcept { decrement(); return *this; } constexpr bool operator<(const iterator &rhs) const noexcept { return std::get<0>(current) < std::get<0>(rhs.current); } constexpr bool operator<=(const iterator &rhs) const noexcept { return std::get<0>(current) <= std::get<0>(rhs.current); } constexpr iterator &operator+=(difference_type __d) noexcept { advance(__d); return *this; } constexpr iterator &operator-=(difference_type __d) noexcept { advance(-__d); return *this; } constexpr iterator operator+(difference_type __d) const noexcept { return iterator{*this} += __d; } constexpr iterator operator-(difference_type __d) const noexcept { return iterator{*this} -= __d; } constexpr difference_type operator-(const iterator &rhs) const noexcept { return std::get<0>(current) - std::get<0>(rhs.current); } constexpr reference operator*() noexcept { return current; } }; constexpr iterator begin() const noexcept { return iterator{begin_cat()}; } constexpr iterator end() const noexcept { return iterator{end_cat()}; } constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } }; template struct zipped_iterator_tuple { using type = decltype(std::tuple_cat( std::declval()))>>(), std::declval::type>())); }; template <> struct zipped_iterator_tuple<> { using type = std::tuple<>; }; template struct zipped_iterator : Iter_tuple { constexpr zipped_iterator(Iter_tuple const &__t) noexcept : Iter_tuple::tuple(__t) {} constexpr zipped_iterator(zipped_iterator const &__t) = default; constexpr zipped_iterator &operator=(zipped_iterator const &__t) = default; // Avoid move initialization. constexpr zipped_iterator(zipped_iterator &&__t) : zipped_iterator(static_cast(__t)) {} // Avoid move assignment. zipped_iterator &operator=(zipped_iterator &&__t) { return operator=(static_cast(__t)); } template friend constexpr auto &get(zipped_iterator const &__z) noexcept { return *std::get(__z); } template friend constexpr auto get(zipped_iterator &&__z) noexcept { return *std::get(__z); } }; } // namespace internal } // namespace workspace namespace std { template struct tuple_element> { using type = typename remove_reference::type>::reference>::type; }; template struct tuple_size> : tuple_size {}; } // namespace std namespace workspace { template constexpr auto zip(Args &&... args) noexcept { return internal::zipped(std::forward(args)...); } template constexpr auto zip(std::initializer_list const &... args) noexcept { return internal::zipped...>(args...); } } // namespace workspace #endif #line 10 "Library/src/utils/py-like/enumerate.hpp" #if __cplusplus >= 201703L namespace workspace { constexpr size_t min_size() noexcept { return SIZE_MAX; } template constexpr size_t min_size(Container const &cont, Args &&... args) noexcept { return std::min(std::size(cont), min_size(std::forward(args)...)); } template constexpr auto enumerate(Args &&... args) noexcept { return zip(range(min_size(args...)), std::forward(args)...); } template constexpr auto enumerate(std::initializer_list const &... args) noexcept { return zip(range(min_size(args...)), std::vector(args)...); } } // namespace workspace #endif #line 17 "Library/lib/utils" // #include "src/utils/py-like/reversed.hpp" // #include "src/utils/py-like/zip.hpp" #line 2 "Library/src/utils/rand/rng.hpp" /** * @file rng.hpp * @brief Random Number Generator */ #line 9 "Library/src/utils/rand/rng.hpp" namespace workspace { template using uniform_distribution = typename std::conditional< std::is_integral<_Arithmetic>::value, std::uniform_int_distribution<_Arithmetic>, std::uniform_real_distribution<_Arithmetic>>::type; template class random_number_generator : uniform_distribution<_Arithmetic> { using base = uniform_distribution<_Arithmetic>; _Engine __engine; public: random_number_generator(_Arithmetic __min, _Arithmetic __max) : base(__min, __max), __engine(std::random_device{}()) {} random_number_generator(_Arithmetic __max = 1) : random_number_generator(0, __max) {} random_number_generator(typename base::param_type const& __param) : base(__param), __engine(std::random_device{}()) {} decltype(auto) operator()() noexcept { return base::operator()(__engine); } }; } // namespace workspace #line 2 "Library/src/utils/rand/shuffle.hpp" /** * @file shuffle.hpp * @brief Shuffle */ #line 10 "Library/src/utils/rand/shuffle.hpp" namespace workspace { template void shuffle(RAIter const& __first, RAIter const& __last) { static std::mt19937 engine(std::random_device{}()); std::shuffle(__first, __last, engine); } } // namespace workspace #line 2 "Library/src/utils/round_div.hpp" /* * @file round_div.hpp * @brief Round Integer Division */ #line 9 "Library/src/utils/round_div.hpp" #line 11 "Library/src/utils/round_div.hpp" namespace workspace { /* * @fn floor_div * @brief floor of fraction. * @param x the numerator * @param y the denominator * @return maximum integer z s.t. z <= x / y * @note y must be nonzero. */ template constexpr typename std::enable_if<(is_integral_ext::value && is_integral_ext::value), typename std::common_type::type>::type floor_div(T1 x, T2 y) { assert(y != 0); if (y < 0) x = -x, y = -y; return x < 0 ? (x - y + 1) / y : x / y; } /* * @fn ceil_div * @brief ceil of fraction. * @param x the numerator * @param y the denominator * @return minimum integer z s.t. z >= x / y * @note y must be nonzero. */ template constexpr typename std::enable_if<(is_integral_ext::value && is_integral_ext::value), typename std::common_type::type>::type ceil_div(T1 x, T2 y) { assert(y != 0); if (y < 0) x = -x, y = -y; return x < 0 ? x / y : (x + y - 1) / y; } } // namespace workspace #line 22 "Library/lib/utils" // #include "src/utils/sfinae.hpp" #line 11 "other/y.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/modular/inverse.hpp" /* * @file inverse.hpp * @brief Inverse Table */ #line 9 "Library/src/modular/inverse.hpp" #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 struct modint_base { static_assert(is_integral_ext::value, "Mod must be integral type."); using mod_type = typename std::make_signed::type, decltype(Mod)>::type>::type; using value_type = typename std::decay::type; using mul_type = typename multiplicable_uint::type; static mod_type mod; static value_type storage; constexpr static void reserve(unsigned __n) noexcept { storage = __n; } value_type value = 0; public: constexpr modint_base() noexcept = default; template ::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+=(const modint_base &rhs) noexcept { if ((value += rhs.value) >= mod) value -= mod; return *this; } template constexpr typename std::enable_if::value, modint_base>::type & operator+=(int_type const &rhs) noexcept { if (((value += rhs) %= mod) < 0) value += mod; return *this; } // }} operator+= // operator+ {{ template constexpr typename std::enable_if::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 constexpr friend typename std::enable_if::value, modint_base>::type operator+(int_type const &lhs, modint_base rhs) noexcept { return rhs += lhs; } // }} operator+ // operator-= {{ constexpr modint_base &operator-=(const modint_base &rhs) noexcept { if ((value -= rhs.value) < 0) value += mod; return *this; } template constexpr typename std::enable_if::value, modint_base>::type & operator-=(int_type rhs) noexcept { if (((value -= rhs) %= mod) < 0) value += mod; return *this; } // }} operator-= // operator- {{ template constexpr typename std::enable_if::value, modint_base>::type operator-(int_type const &rhs) const noexcept { return modint_base{*this} -= rhs; } constexpr modint_base operator-(const modint_base &rhs) const noexcept { modint_base __t; if (((__t.value = value) -= rhs.value) < 0) __t.value += mod; return __t; } template constexpr friend typename std::enable_if::value, modint_base>::type operator-(int_type lhs, const modint_base &rhs) noexcept { if (((lhs -= rhs.value) %= mod) < 0) lhs += mod; modint_base __t; __t.value = lhs; return __t; } // }} operator- // operator*= {{ constexpr modint_base &operator*=(const modint_base &rhs) noexcept { value = static_cast(value) * rhs.value % mod; return *this; } template constexpr typename std::enable_if::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((__r *= rhs) %= mod); } return *this; } // }} operator*= // operator* {{ constexpr modint_base operator*(const modint_base &rhs) const noexcept { modint_base __t; __t.value = static_cast(value) * rhs.value % mod; return __t; } template constexpr typename std::enable_if::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((__r *= rhs) %= mod); return __t; } template constexpr friend typename std::enable_if::value, modint_base>::type operator*(int_type lhs, const modint_base &rhs) noexcept { if (!lhs or !rhs.value) return {}; if ((lhs %= mod) < 0) lhs += mod; mul_type __r(lhs); modint_base __t; __t.value = static_cast((__r *= rhs.value) %= mod); return __t; } // }} operator* protected: static value_type _mem(value_type __x) { static std::vector __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 constexpr static typename std::enable_if::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(__v); return static_cast((__r *= __v) %= mod); } public: // operator/= {{ constexpr modint_base &operator/=(const modint_base &rhs) noexcept { if (value) value = _div(value, rhs.value); return *this; } template constexpr typename std::enable_if::value, modint_base>::type & operator/=(int_type rhs) noexcept { if (value) value = _div(value, rhs %= mod); return *this; } // }} operator/= // operator/ {{ constexpr modint_base operator/(const modint_base &rhs) const noexcept { if (!value) return {}; modint_base __t; __t.value = _div(value, rhs.value); return __t; } template constexpr typename std::enable_if::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 constexpr friend typename std::enable_if::value, modint_base>::type operator/(int_type lhs, const modint_base &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 friend constexpr typename std::enable_if::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 constexpr typename std::enable_if::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 typename modint_base::mod_type modint_base::mod = Mod > 0 ? Mod : 0; template typename modint_base::value_type modint_base::storage = Storage; } // namespace internal /** * @brief Modular arithmetic. * * @tparam Mod modulus * @tparam Storage Reserved size for inverse calculation */ template 0)>::type * = nullptr> using modint = internal::modint_base; /** * @brief Runtime modular arithmetic. * * @tparam type_id uniquely assigned * @tparam Storage Reserved size for inverse calculation */ template using modint_runtime = internal::modint_base<-(signed)type_id, Storage>; // #define modint_newtype modint_runtime<__COUNTER__> } // namespace workspace #line 11 "Library/src/modular/inverse.hpp" namespace workspace { // Modulus must be prime. template struct inverse_table { static_assert(std::is_same::value); using value_type = Modint; constexpr value_type operator()(int n) const { constexpr int_fast64_t mod = value_type::mod; assert(n %= mod); if (n < 0) n += mod; if (inv.empty()) inv = {1, mod != 1}; for (int m(inv.size()); m <= n; ++m) inv.emplace_back(mod / m * -inv[mod % m]); return inv[n]; } private: static std::vector inv; }; template std::vector inverse_table::inv; } // namespace workspace #line 2 "Library/src/number_theory/primitive_root.hpp" /** * @file primitive_root.hpp * @brief Primitive Root * @date 2020-12-28 */ #line 10 "Library/src/number_theory/primitive_root.hpp" namespace workspace { /** * @brief Compile time primitive root. * * @tparam __mod Positive integer * @return Minimum positive one if it exists. Otherwise 0. */ template constexpr typename std::enable_if<(is_integral_ext::value), Tp>::type primitive_root(const Tp __mod) noexcept { assert(__mod > 0); using int_type = typename multiplicable_uint::type; int_type __r = __mod, __p[16] = {}, *__q = __p; for (int_type __i = 2; __i <= __r / __i; ++__i) { if (__r % __i) continue; *__q++ = __i; while (!(__r % __i)) __r /= __i; } if (__r != 1) *__q++ = __r; int_type __tot = __mod; for (__q = __p; *__q; *__q++ = 0) (__tot /= *__q) *= *__q - 1; __r = __tot, __q = __p + 1, __p[0] = 1; for (int_type __i = 2; __i <= __r / __i; ++__i) { if (__r % __i) continue; *__q++ = __i; while (!(__r % __i)) __r /= __i; } if (__r != 1) *__q++ = __r; for (Tp __r = 1; __r != __mod; ++__r) { auto __cnt = 0; for (__q = __p; *__q; ++__q) { int_type __w = 1; for (int_type __e = __tot / *__q, __x = __r; __e; __e >>= 1, (__x *= __x) %= __mod) if (__e & 1) (__w *= __x) %= __mod; if (__w == 1 && ++__cnt > 1) break; } if (__cnt == 1) return __r; } return 0; }; } // namespace workspace #line 28 "other/y.cc" namespace workspace { using mint = modint_runtime<>; void main() { // start here! int x, v; cin >> v >> x; mint::mod = v * x + 1; mint r = primitive_root(mint::mod); r = r.pow(v); mint rp{1}; vector ans; for (auto i : range(x)) { ans.emplace_back(rp); rp *= r; } sort(begin(ans), end(ans)); cout << ans << eol; } } // namespace workspace