結果
| 問題 | No.1388 Less than K |
| ユーザー |
 jell
|
| 提出日時 | 2021-02-19 12:50:16 |
| 言語 | C++17(gcc12) (gcc 12.3.0 + boost 1.87.0) |
| 結果 |
CE
(最新)
AC
(最初)
|
| 実行時間 | - |
| コード長 | 64,351 bytes |
| コンパイル時間 | 9,187 ms |
| コンパイル使用メモリ | 328,752 KB |
| 最終ジャッジ日時 | 2025-01-08 19:49:42 |
| 合計ジャッジ時間 | 10,235 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge2 |
（要ログイン）
コンパイルエラー時のメッセージ・ソースコードは、提出者また管理者しか表示できないようにしております。（リジャッジ後のコンパイルエラーは公開されます）
ただし、clay言語の場合は開発者のデバッグのため、公開されます。
ただし、clay言語の場合は開発者のデバッグのため、公開されます。
コンパイルメッセージ
Library/lib/limits:9:20: error: redefinition of 'struct std::numeric_limits<__int128 unsigned>'
In file included from /home/linuxbrew/.linuxbrew/Cellar/gcc@12/12.4.0/include/c++/12/bits/specfun.h:46,
from /home/linuxbrew/.linuxbrew/Cellar/gcc@12/12.4.0/include/c++/12/cmath:1935,
from /home/linuxbrew/.linuxbrew/Cellar/gcc@12/12.4.0/include/c++/12/x86_64-pc-linux-gnu/bits/stdc++.h:41,
from /home/linuxbrew/.linuxbrew/Cellar/gcc@12/12.4.0/include/c++/12/x86_64-pc-linux-gnu/bits/extc++.h:32,
from other/y.cc:3:
/home/linuxbrew/.linuxbrew/Cellar/gcc@12/12.4.0/include/c++/12/limits:1658:3: note: previous definition of 'struct std::numeric_limits<__int128 unsigned>'
1658 | __INT_N(__int128, 128,
| ^~~~~~~
Library/lib/limits:14:20: error: redefinition of 'struct std::numeric_limits<__int128>'
/home/linuxbrew/.linuxbrew/Cellar/gcc@12/12.4.0/include/c++/12/limits:1658:3: note: previous definition of 'struct std::numeric_limits<__int128>'
1658 | __INT_N(__int128, 128,
| ^~~~~~~
ソースコード
#line 1 "other/y.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));elsereturn (__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));elsereturn (__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_EVALUATEDif (!__builtin_is_constant_evaluated()) {__glibcxx_assert(__shift_exponent != numeric_limits<_Tp>::digits);}#endifusing __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.#endiftemplate <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 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<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-indexedunsigned 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;elsereturn __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 10 "Library/src/utils/sfinae.hpp"#include <type_traits>#ifndef __INT128_DEFINED__#ifdef __SIZEOF_INT128__#define __INT128_DEFINED__ 1#else#define __INT128_DEFINED__ 0#endif#endifnamespace 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 stdnamespace 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 >= 201402template <class T>constexpr static bool is_integral_ext_v = is_integral_ext<T>::value;#endiftemplate <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;};#endiftemplate <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);elsestatic_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 // INT128template <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;elseistream_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;}};decltype(auto) cin = static_cast<istream &>(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 {/*** @brief Stream insertion operator for C-style array.** @param __os Output stream* @param __a Array* @return Reference to __os.*/template <class _Os, class _Tp, size_t _Nm>typename std::enable_if<bool(sizeof(_Tp) > 2), _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 <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 _Nm = 0>typename std::enable_if<bool(std::tuple_size<_Tp>::value + 1), _Os &>::typeoperator<<(_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 <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 &>::typeoperator<<(_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_checkatexit([] {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 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/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));elsereturn 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;elsereturn 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 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 <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 internaltemplate <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 >= 201703Lnamespace 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 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 >= 201703Lnamespace workspace {namespace internal {template <class> struct zipped_iterator;template <class...> struct zipped_iterator_tuple;template <class... Args> class zipped {using ref_tuple = std::tuple<Args...>;ref_tuple args;template <size_t N = 0> constexpr auto begin_cat() const noexcept {if constexpr (N != std::tuple_size<ref_tuple>::value) {return std::tuple_cat(std::tuple(std::begin(std::get<N>(args))),begin_cat<N + 1>());} elsereturn std::tuple<>();}template <size_t N = 0> constexpr auto end_cat() const noexcept {if constexpr (N != std::tuple_size<ref_tuple>::value) {return std::tuple_cat(std::tuple(std::end(std::get<N>(args))),end_cat<N + 1>());} elsereturn std::tuple<>();}public:constexpr zipped(Args &&... args) noexcept : args(args...) {}class iterator {using base_tuple = typename zipped_iterator_tuple<Args...>::type;public:using iterator_category =typename common_iterator_category<base_tuple>::type;using difference_type = std::ptrdiff_t;using value_type = zipped_iterator<base_tuple>;using reference = zipped_iterator<base_tuple> &;using pointer = iterator;protected:value_type current;template <size_t N = 0>constexpr bool equal(const iterator &rhs) const noexcept {if constexpr (N != std::tuple_size<base_tuple>::value) {return std::get<N>(current) == std::get<N>(rhs.current) ||equal<N + 1>(rhs);} elsereturn false;}template <size_t N = 0> constexpr void increment() noexcept {if constexpr (N != std::tuple_size<base_tuple>::value) {++std::get<N>(current);increment<N + 1>();}}template <size_t N = 0> constexpr void decrement() noexcept {if constexpr (N != std::tuple_size<base_tuple>::value) {--std::get<N>(current);decrement<N + 1>();}}template <size_t N = 0>constexpr void advance(difference_type __d) noexcept {if constexpr (N != std::tuple_size<base_tuple>::value) {std::get<N>(current) += __d;advance<N + 1>(__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<iterator> rbegin() const noexcept {return reverse_iterator<iterator>{end()};}constexpr reverse_iterator<iterator> rend() const noexcept {return reverse_iterator<iterator>{begin()};}};template <class Tp, class... Args> struct zipped_iterator_tuple<Tp, Args...> {using type = decltype(std::tuple_cat(std::declval<std::tuple<decltype(std::begin(std::declval<Tp>()))>>(),std::declval<typename zipped_iterator_tuple<Args...>::type>()));};template <> struct zipped_iterator_tuple<> { using type = std::tuple<>; };template <class Iter_tuple> 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<zipped_iterator const &>(__t)) {}// Avoid move assignment.zipped_iterator &operator=(zipped_iterator &&__t) {return operator=(static_cast<zipped_iterator const &>(__t));}template <size_t N>friend constexpr auto &get(zipped_iterator<Iter_tuple> const &__z) noexcept {return *std::get<N>(__z);}template <size_t N>friend constexpr auto get(zipped_iterator<Iter_tuple> &&__z) noexcept {return *std::get<N>(__z);}};} // namespace internal} // namespace workspacenamespace std {template <size_t N, class Iter_tuple>struct tuple_element<N, workspace::internal::zipped_iterator<Iter_tuple>> {using type = typename remove_reference<typename iterator_traits<typename tuple_element<N, Iter_tuple>::type>::reference>::type;};template <class Iter_tuple>struct tuple_size<workspace::internal::zipped_iterator<Iter_tuple>>: tuple_size<Iter_tuple> {};} // namespace stdnamespace workspace {template <class... Args> constexpr auto zip(Args &&... args) noexcept {return internal::zipped<Args...>(std::forward<Args>(args)...);}template <class... Args>constexpr auto zip(std::initializer_list<Args> const &... args) noexcept {return internal::zipped<const std::initializer_list<Args>...>(args...);}} // namespace workspace#endif#line 10 "Library/src/utils/py-like/enumerate.hpp"#if __cplusplus >= 201703Lnamespace workspace {constexpr size_t min_size() noexcept { return SIZE_MAX; }template <class Container, class... Args>constexpr size_t min_size(Container const &cont, Args &&... args) noexcept {return std::min(std::size(cont), min_size(std::forward<Args>(args)...));}template <class... Args> constexpr auto enumerate(Args &&... args) noexcept {return zip(range(min_size(args...)), std::forward<Args>(args)...);}template <class... Args>constexpr auto enumerate(std::initializer_list<Args> const &... args) noexcept {return zip(range(min_size(args...)), std::vector(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"#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 <typename T1, typename T2>constexpr typename std::enable_if<(is_integral_ext<T1>::value &&is_integral_ext<T2>::value),typename std::common_type<T1, T2>::type>::typefloor_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 <typename T1, typename T2>constexpr typename std::enable_if<(is_integral_ext<T1>::value &&is_integral_ext<T2>::value),typename std::common_type<T1, T2>::type>::typeceil_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 21 "Library/lib/utils"// #include "src/utils/sfinae.hpp"#line 11 "other/y.cc"signed main() {using namespace workspace;io_setup(15);/* givencase_info.read(); //*//* unspecifiedcase_info.total = -1; //*/return case_info.iterate();}#line 2 "Library/src/combinatorics/binomial.hpp"/*** @file binomial.hpp* @brief Binomial Coefficient* @date 2021-01-15***/#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>::typeoperator+(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>::typeoperator+(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>::typeoperator-(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>::typeoperator-(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>::typeoperator*(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>::typeoperator*(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 = static_cast<value_type &&>((__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>::typeoperator/(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>::typeoperator/(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>::typepow(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>::typepow(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_typemodint_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 2 "Library/src/combinatorics/factorial.hpp"/*** @file factorial.hpp* @brief Factorial* @date 2021-01-15***/#line 14 "Library/src/combinatorics/factorial.hpp"namespace workspace {template <class Tp> Tp factorial(int_fast32_t __x) noexcept {if (__x < 0) return 0;static std::vector<Tp> __t{1};static int_fast32_t __i = (__t.reserve(0x1000000), 0);while (__i < __x) {++__i;__t.emplace_back(__t.back() * __i);}return __t[__x];}template <class Tp> Tp factorial_inverse(int_fast32_t __x) noexcept {if (__x < 0) return 0;static std::vector<Tp> __t{1};static int_fast32_t __i = (__t.reserve(0x1000000), 0);while (__i < __x) {++__i;__t.emplace_back(__t.back() / __i);}return __t[__x];}} // namespace workspace#line 13 "Library/src/combinatorics/binomial.hpp"namespace workspace {/*** @brief Binomial coefficient for integer args.*/template <class Tp> Tp binomial(int_fast32_t __x, int_fast32_t __y) {if (!__y) return 1;if (__y < 0 || __x < __y) return 0;return factorial<Tp>(__x) * factorial_inverse<Tp>(__y) *factorial_inverse<Tp>(__x - __y);}} // namespace workspace#line 2 "Library/src/algebra/polynomial.hpp"/*** @file polynomial.hpp* @brief Polynomial* @date 2021-02-19***/#line 12 "Library/src/algebra/polynomial.hpp"#line 2 "Library/src/algebra/convolution/ntt.hpp"#line 2 "Library/src/number_theory/ext_gcd.hpp"/** @file ext_gcd* @brief Extended Euclidean Algorithm*/#line 9 "Library/src/number_theory/ext_gcd.hpp"#line 11 "Library/src/number_theory/ext_gcd.hpp"namespace workspace {/*** @param a Integer* @param b Integer* @return Pair of integers (x, y) s.t. ax + by = g = gcd(a, b), |x| < |b/g|,* |y| < |a/g|.* @note return (0, 0) if (a, b) = (0, 0)*/template <typename T1, typename T2> constexpr auto ext_gcd(T1 a, T2 b) {static_assert(is_integral_ext<T1>::value);static_assert(is_integral_ext<T2>::value);using result_type =typename std::make_signed<typename std::common_type<T1, T2>::type>::type;result_type p{1}, q{}, r{}, s{1}, t{};while (b) {r ^= p ^= r ^= p -= (t = a / b) * r;s ^= q ^= s ^= q -= t * s;b ^= a ^= b ^= a %= b;}if (a < 0) p = -p, q = -q;return std::make_pair(p, q);}} // 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 A positive integer* @return Minimum positive one if it exists. Otherwise 0.*/template <class Tp>constexpr typename std::enable_if<(is_integral_ext<Tp>::value), Tp>::typeprimitive_root(const Tp __mod) noexcept {assert(__mod > 0);using int_type = typename multiplicable_uint<Tp>::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 6 "Library/src/algebra/convolution/ntt.hpp"namespace workspace {namespace ntt_impl {template <class _Tp> struct __coef {_Tp sum_e[30]; // sum_e[i] = ies[0] * ... * ies[i - 1] * es[i]constexpr __coef() : sum_e{} {_Tp es[30] = {}, ies[30] = {}; // es[i]^(2^(2+i)) == 1int cnt2 = __builtin_ctz(_Tp::mod - 1);_Tp e = 1;{auto p = (_Tp::mod - 1) >> cnt2;_Tp w = primitive_root(_Tp::mod);while (p) {if (p & 1) e *= w;p >>= 1;w *= w;}}_Tp ie = ext_gcd(decltype(_Tp::mod)(e), _Tp::mod).first;for (int i = cnt2; i >= 2; i--) {// e^(2^i) == 1es[i - 2] = e;ies[i - 2] = ie;e *= e;ie *= ie;}_Tp now = 1;for (int i = 0; i <= cnt2 - 2; i++) {sum_e[i] = es[i] * now;now *= ies[i];}}};template <class _Tp> struct __icoef {_Tp sum_ie[30]; // sum_e[i] = ies[0] * ... * ies[i - 1] * es[i]constexpr __icoef() : sum_ie{} {_Tp es[30] = {}, ies[30] = {}; // es[i]^(2^(2+i)) == 1int cnt2 = __builtin_ctz(_Tp::mod - 1);_Tp e = 1;{auto p = (_Tp::mod - 1) >> cnt2;_Tp w = primitive_root(_Tp::mod);while (p) {if (p & 1) e *= w;p >>= 1;w *= w;}}_Tp ie = ext_gcd(decltype(_Tp::mod)(e), _Tp::mod).first;for (int i = cnt2; i >= 2; i--) {// e^(2^i) == 1es[i - 2] = e;ies[i - 2] = ie;e *= e;ie *= ie;}_Tp now = 1;for (int i = 0; i <= cnt2 - 2; i++) {sum_ie[i] = ies[i] * now;now *= es[i];}}};template <class _Tp> struct __ipow2 {_Tp __ip2[30];constexpr __ipow2() : __ip2{1, (1 + _Tp::mod) / 2} {for (size_t __i = 1; __i + 1 != std::size(__ip2); ++__i)__ip2[__i + 1] = __ip2[__i] * __ip2[1];}};template <class _RAIter> constexpr void ntt(_RAIter __first, _RAIter __last) {using modint = typename std::decay<decltype(*__first)>::type;constexpr __coef<modint> _;int h = __builtin_ctz(__last - __first);for (int ph = 1; ph <= h; ph++) {int w = 1 << (ph - 1), p = 1 << (h - ph);modint now = -1;for (int s = 0; s < w; s++) {auto __l = __first + (s << (h - ph + 1));auto __r = __first + p + (s << (h - ph + 1));for (int i = 0; i < p; ++i, ++__l, ++__r) {auto __tmp = *__l;*__r *= now;*__l -= *__r;*__r += __tmp;}now *= _.sum_e[__builtin_ctz(~(unsigned int)(s))];}}}template <class _RAIter> constexpr void intt(_RAIter __first, _RAIter __last) {using modint = typename std::decay<decltype(*__first)>::type;constexpr __icoef<modint> _;int h = __builtin_ctz(__last - __first);for (int ph = h; ph >= 1; ph--) {int w = 1 << (ph - 1), p = 1 << (h - ph);modint inow = 1;for (int s = 0; s < w; s++) {auto __l = __first + (s << (h - ph + 1));auto __r = __first + p + (s << (h - ph + 1));for (int i = 0; i < p; ++i, ++__l, ++__r) {auto __tmp = (*__l - *__r) * inow;*__l += *__r;*__r = __tmp;}inow *= _.sum_ie[__builtin_ctz(~(unsigned int)(s))];}}constexpr __ipow2<modint> __;while (__first != __last) *--__last *= __.__ip2[h];}template <class _A> constexpr void ntt(_A &a) {using modint = typename std::decay<decltype(a[0])>::type;constexpr __coef<modint> _;int h = __builtin_ctz(a.size());for (int ph = 1; ph <= h; ph++) {int w = 1 << (ph - 1), p = 1 << (h - ph);modint now = 1;for (int s = 0; s < w; s++) {int offset = s << (h - ph + 1);for (int i = 0; i < p; i++) {auto l = a[i + offset];auto r = a[i + offset + p] * now;a[i + offset] = l + r;a[i + offset + p] = l - r;}now *= _.sum_e[__builtin_ctz(~(unsigned int)(s))];}}}template <class _A> constexpr void intt(_A &a) {using modint = typename std::decay<decltype(a[0])>::type;constexpr __icoef<modint> _;int h = __builtin_ctz(a.size());for (int ph = h; ph >= 1; ph--) {int w = 1 << (ph - 1), p = 1 << (h - ph);modint inow = 1;for (int s = 0; s < w; s++) {int offset = s << (h - ph + 1);for (int i = 0; i < p; i++) {auto l = a[i + offset];auto r = a[i + offset + p];a[i + offset] = l + r;a[i + offset + p] = (l - r) * inow;}inow *= _.sum_ie[__builtin_ctz(~(unsigned int)(s))];}}constexpr __ipow2<modint> __;for (auto &x : a) x *= __.__ip2[h];}} // namespace ntt_implusing ntt_impl::intt;using ntt_impl::ntt;} // namespace workspace#line 14 "Library/src/algebra/polynomial.hpp"namespace workspace {template <class _Tp> class polynomial : public std::vector<_Tp> {protected:using vector = std::vector<_Tp>;using poly = polynomial;public:using vector::vector;using size_type = typename vector::size_type;typename vector::reference operator[](size_type __i) {if (size_type __n = vector::_M_impl._M_finish - vector::_M_impl._M_start;__n <= __i) {vector::_M_default_append(__i + 1 - __n);}return *(vector::_M_impl._M_start + __i);}typename vector::const_reference operator[](size_type __i) const {return __i < size_type(vector::_M_impl._M_finish - vector::_M_impl._M_start)? *(vector::_M_impl._M_start + __i): 0;}poly operator+() const { return *this; }poly operator-() const {poly __x = *this;for (auto __i = __x._M_impl._M_start; __i != __x._M_impl._M_finish; ++__i)*__i = -*__i;return __x;}poly& operator+=(const poly& __x) {if (vector::size() < __x.size())vector::_M_default_append(__x.size() - vector::size());for (auto __i = vector::_M_impl._M_start, __j = __x._M_impl._M_start;__j != __x._M_impl._M_finish; ++__i, ++__j)*__i += *__j;return *this;}poly& operator+=(const _Tp& __x) {if (__x != static_cast<_Tp>(0)) {if (vector::_M_impl._M_start == vector::_M_impl._M_finish)vector::emplace_back(__x);else*vector::_M_impl._M_start = __x;}return *this;}poly& operator-=(const poly& __x) {if (vector::size() < __x.size())vector::_M_default_append(__x.size() - vector::size());for (auto __i = vector::_M_impl._M_start, __j = __x._M_impl._M_start;__j != __x._M_impl._M_finish; ++__i, ++__j)*__i -= *__j;return *this;}poly& operator-=(const _Tp& __x) {if (__x != static_cast<_Tp>(0)) {if (vector::_M_impl._M_start == vector::_M_impl._M_finish)vector::emplace_back(-__x);else*vector::_M_impl._M_start -= __x;}return *this;}typename std::enable_if<bool(_Tp::mod > 2), poly&>::type operator*=(poly __x) {size_type __n = vector::size(), __m = __x.size();if (std::min(__n, __m) < 60)if (!__m)vector::_M_erase_at_end(vector::_M_impl._M_start);else {vector::_M_default_append(__m - 1);for (auto __i = vector::_M_impl._M_finish;__i-- != vector::_M_impl._M_start;) {auto __j = __i, __k = __x._M_impl._M_start;*__i *= *__k++;while (__j != vector::_M_impl._M_start &&__k != __x._M_impl._M_finish)*__i += *--__j * *__k++;}}else {size_type __len = 1 << (32 - __builtin_clz(__n + __m - 1));vector::_M_default_append(__len - __n);__x._M_default_append(__len - __m);ntt(vector::_M_impl._M_start, vector::_M_impl._M_finish);ntt(__x._M_impl._M_start, __x._M_impl._M_finish);for (auto __i = vector::_M_impl._M_start, __j = __x._M_impl._M_start;__i != vector::_M_impl._M_finish; ++__i, ++__j)*__i *= *__j;intt(vector::_M_impl._M_start, vector::_M_impl._M_finish);vector::_M_erase_at_end(vector::_M_impl._M_start + __n + __m - 1);}return *this;}poly& operator*=(const _Tp& __x) {if (__x == static_cast<_Tp>(0))vector::_M_erase_at_end(vector::_M_impl._M_start);elsefor (auto __i = vector::_M_impl._M_start;__i != vector::_M_impl._M_finish; ++__i)*__i *= __x;return *this;}poly& operator/=(const _Tp& __x) {assert(__x != static_cast<_Tp>(0));for (auto __i = vector::_M_impl._M_start; __i != vector::_M_impl._M_finish;++__i)*__i /= __x;return *this;}poly& operator%=(const poly& __x);template <class _T> poly operator+(const _T& __x) const {return poly(*this).operator+=(__x);}template <class _T> poly operator-(const _T& __x) const {return poly(*this).operator-=(__x);}template <class _T> poly operator*(const _T& __x) const {return poly(*this).operator*=(__x);}template <class _T> poly operator/(const _T& __x) const {return poly(*this).operator/=(__x);}};} // namespace workspace#line 28 "other/y.cc"namespace workspace {using mint = modint<998244353>;using poly = polynomial<mint>;auto fa = factorial<mint>;auto fi = factorial_inverse<mint>;auto b = binomial<mint>;void main() {// start here!int h, w, k;cin >> h >> w >> k;--h, --w;k /= 2;++k;const auto n = min(h, w);poly fv;for (auto r : range(k * 2)) {poly p;for (auto i : range(n / k + 1)) {p[i] = fi(k * 2 * i + r);}p *= p;for (auto i = r, j = 0; i <= n; i += k * 2, j += 2) {fv[i] += p[j];}for (auto i = r < k ? r + k : r - k; i <= n; i += k * 2) {if (i >= k) fv[i] -= p[(i - k) / k / 2 + (i + k) / k / 2];}}mint ans;for (auto i : range(n + 1)) {ans += fv[i] * fi(h - i) * fi(w - i);}ans *= fa(h + w);cout << ans << "\n";}} // namespace workspace