結果
問題 | No.1520 Zigzag Sum |
ユーザー |
![]() |
提出日時 | 2021-05-28 21:44:03 |
言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
結果 |
AC
|
実行時間 | 72 ms / 2,000 ms |
コード長 | 54,472 bytes |
コンパイル時間 | 4,015 ms |
コンパイル使用メモリ | 266,716 KB |
最終ジャッジ日時 | 2025-01-21 19:58:09 |
ジャッジサーバーID (参考情報) |
judge2 / judge3 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 1 |
other | AC * 7 |
ソースコード
#line 1 "other-workspace\\yuki.cc"// #undef _GLIBCXX_DEBUG// #define NDEBUG#include <bits/extc++.h>#line 2 "Library\\lib\\alias"/*** @file alias* @brief Alias*/#line 10 "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 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 __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 __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 _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 workspace {template <class _Tp> struct numeric_limits : std::numeric_limits<_Tp> {};#ifdef __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 workspace#line 13 "Library\\lib\\alias"namespace workspace {constexpr static 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 128-bit integer is not available.#endiftemplate <class _T1, class _T2,typename = decltype(std::declval<const _T2 &>() <std::declval<const _T1 &>())>constexprtypename std::conditional<std::is_same<_T1, _T2>::value, const _T1 &,typename std::common_type<_T1, _T2>::type>::typemin(const _T1 &__x, const _T2 &__y) noexcept {return __y < __x ? __y : __x;}template <class _T1, class _T2, class _Compare,typename = decltype(std::declval<_Compare>()(std::declval<const _T2 &>(), std::declval<const _T1 &>()))>constexprtypename std::conditional<std::is_same<_T1, _T2>::value, const _T1 &,typename std::common_type<_T1, _T2>::type>::typemin(const _T1 &__x, const _T2 &__y, _Compare __comp) noexcept {return __comp(__y, __x) ? __y : __x;}template <class _Tp, typename = decltype(std::declval<const _Tp &>() <std::declval<const _Tp &>())>constexpr _Tp min(std::initializer_list<_Tp> __x) noexcept {return *std::min_element(__x.begin(), __x.end());}template <class _Tp, class _Compare,typename = decltype(std::declval<_Compare>()(std::declval<const _Tp &>(), std::declval<const _Tp &>()))>constexpr _Tp min(std::initializer_list<_Tp> __x, _Compare __comp) noexcept {return *std::min_element(__x.begin(), __x.end(), __comp);}template <class _T1, class _T2,typename = decltype(std::declval<const _T1 &>() <std::declval<const _T2 &>())>constexprtypename std::conditional<std::is_same<_T1, _T2>::value, const _T1 &,typename std::common_type<_T1, _T2>::type>::typemax(const _T1 &__x, const _T2 &__y) noexcept {return __x < __y ? __y : __x;}template <class _T1, class _T2, class _Compare,typename = decltype(std::declval<_Compare>()(std::declval<const _T1 &>(), std::declval<const _T2 &>()))>constexprtypename std::conditional<std::is_same<_T1, _T2>::value, const _T1 &,typename std::common_type<_T1, _T2>::type>::typemax(const _T1 &__x, const _T2 &__y, _Compare __comp) noexcept {return __comp(__x, __y) ? __y : __x;}template <class _Tp, typename = decltype(std::declval<const _Tp &>() <std::declval<const _Tp &>())>constexpr _Tp max(std::initializer_list<_Tp> __x) noexcept {return *std::max_element(__x.begin(), __x.end());}template <class _Tp, class _Compare,typename = decltype(std::declval<_Compare>()(std::declval<const _Tp &>(), std::declval<const _Tp &>()))>constexpr _Tp max(std::initializer_list<_Tp> __x, _Compare __comp) noexcept {return *std::max_element(__x.begin(), __x.end(), __comp);}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 6 "other-workspace\\yuki.cc"// #include "lib/cxx20"#line 1 "Library\\lib\\direct"#ifdef ONLINE_JUDGE#pragma GCC optimize("O3")#pragma GCC target("avx,avx2")#pragma GCC optimize("unroll-loops")#endif#line 8 "other-workspace\\yuki.cc"// #include "lib/opt"#line 2 "Library\\src\\sys\\call_once.hpp"/*** @file call_once.hpp* @brief Call Once*/#line 9 "Library\\src\\sys\\call_once.hpp"namespace workspace {/*** @brief Call once.*/template <class _F> void call_once(_F &&__f) {static std::unordered_set<void *> __called;if (__called.count(std::addressof(__f))) return;__called.emplace(std::addressof(__f));__f();}} // namespace workspace#line 2 "Library\\src\\sys\\clock.hpp"/** @fn clock.hpp* @brief Clock*/#line 9 "Library\\src\\sys\\clock.hpp"namespace workspace {using namespace std::chrono;namespace internal {// The start time of the program.const auto start_time{system_clock::now()};} // namespace internal/** @fn elapsed* @return elapsed time of the program*/int64_t elapsed() {const auto end_time{system_clock::now()};return duration_cast<milliseconds>(end_time - internal::start_time).count();}} // namespace workspace#line 2 "Library\\src\\sys\\ejection.hpp"/*** @file ejection.hpp* @brief Ejection*/#line 9 "Library\\src\\sys\\ejection.hpp"namespace workspace {namespace internal {struct ejection {bool exit = 0;};} // namespace internal/*** @brief eject from a try block, throw nullptr* @param arg output*/template <class Tp> void eject(Tp const &arg) {std::cout << arg << "\n";throw internal::ejection{};}void exit() { throw internal::ejection{true}; }} // namespace workspace#line 2 "Library\\src\\sys\\iteration.hpp"/*** @file iteration.hpp* @brief Case Iteration*/#line 9 "Library\\src\\sys\\iteration.hpp"#line 11 "Library\\src\\sys\\iteration.hpp"namespace workspace {void main();struct {// 1-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\\lib\\utils"// #include "src/utils/cached.hpp"#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 <class _C1, class _C2>constexpr decltype(auto) cat(_C1 &&__c1, _C2 &&__c2) noexcept {auto __c = std::forward<_C1>(__c1);if constexpr (std::is_rvalue_reference<decltype(__c2)>::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 <class _C1, class _C2, class... _Args>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 {/*** @brief Substitute __y for __x if __y < __x.* @param __x Reference* @param __y Comparison target* @return Whether or not __x is updated.*/template <class _T1, class _T2,typename = decltype(std::declval<_T2>() < std::declval<_T1 &>())>typename std::enable_if<std::is_assignable<_T1 &, _T2>::value, bool>::type chle(_T1 &__x, _T2 &&__y) noexcept {return __y < __x ? __x = std::forward<_T2>(__y), true : false;}/*** @brief Substitute __y for __x if __x < __y.* @param __x Reference* @param __y Comparison target* @return Whether or not __x is updated.*/template <class _T1, class _T2,typename = decltype(std::declval<_T1 &>() < std::declval<_T2>())>typename std::enable_if<std::is_assignable<_T1 &, _T2>::value, bool>::type chgr(_T1 &__x, _T2 &&__y) noexcept {return __x < __y ? __x = std::forward<_T2>(__y), true : false;}/*** @brief Substitute __y for __x if __comp(__y, __x) is true.* @param __x Reference* @param __y Comparison target* @param __comp Compare function object* @return Whether or not __x is updated.*/template <class _T1, class _T2, class _Compare,typename = decltype(std::declval<_Compare>()(std::declval<_T2>(),std::declval<_T1 &>()))>typename std::enable_if<std::is_assignable<_T1 &, _T2>::value, bool>::type chle(_T1 &__x, _T2 &&__y, _Compare __comp) noexcept {return __comp(__y, __x) ? __x = std::forward<_T2>(__y), true : false;}/*** @brief Substitute __y for __x if __comp(__x, __y) is true.* @param __x Reference* @param __y Comparison target* @param __comp Compare function object* @return Whether or not __x is updated.*/template <class _T1, class _T2, class _Compare,typename = decltype(std::declval<_Compare>()(std::declval<_T1 &>(),std::declval<_T2>()))>typename std::enable_if<std::is_assignable<_T1 &, _T2>::value, bool>::type chgr(_T1 &__x, _T2 &&__y, _Compare __comp) noexcept {return __comp(__x, __y) ? __x = std::forward<_T2>(__y), true : false;}} // namespace workspace#line 1 "Library\\src\\utils\\compare.hpp"/*** @file compare.hpp* @brief Compare*/#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; };template <> struct is_signed<__uint128_t> : std::false_type {};template <> struct is_signed<__int128_t> : std::true_type {};template <> struct is_unsigned<__uint128_t> : std::true_type {};template <> struct is_unsigned<__int128_t> : std::false_type {};#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;/*** @brief Return type of subscripting ( @c [] ) access.*/template <class _Tp>using subscripted_type =typename std::decay<decltype(std::declval<_Tp&>()[0])>::type;template <class Container>using element_type = typename std::decay<decltype(*std::begin(std::declval<Container&>()))>::type;template <class _Tp, class = std::nullptr_t>struct has_begin : std::false_type {};template <class _Tp>struct has_begin<_Tp, decltype(std::begin(std::declval<_Tp>()), nullptr)>: std::true_type {};template <class _Tp, class = void> struct has_mod : std::false_type {};template <class _Tp>struct has_mod<_Tp, std::__void_t<decltype(_Tp::mod)>> : std::true_type {};template <class _Tp, class = void> struct is_integral_ext : std::false_type {};template <class _Tp>struct is_integral_ext<_Tp, typename std::enable_if<std::is_integral<_Tp>::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 _Tp>constexpr static bool is_integral_ext_v = is_integral_ext<_Tp>::value;#endiftemplate <typename _Tp, typename = void> struct multiplicable_uint {using type = uint_least32_t;};template <typename _Tp>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 <typename _Tp>struct multiplicable_uint<_Tp,typename std::enable_if<(4 < sizeof(_Tp))>::type> {using type = __uint128_t;};#endiftemplate <typename _Tp> struct multiplicable_int {using type =typename std::make_signed<typename multiplicable_uint<_Tp>::type>::type;};template <typename _Tp> struct multiplicable {using type = std::conditional_t<is_integral_ext<_Tp>::value,std::conditional_t<std::is_signed<_Tp>::value,typename multiplicable_int<_Tp>::type,typename multiplicable_uint<_Tp>::type>,_Tp>;};template <class> struct first_arg { using type = void; };template <class _R, class _Tp, class... _Args>struct first_arg<_R(_Tp, _Args...)> {using type = _Tp;};template <class _R, class _Tp, class... _Args>struct first_arg<_R (*)(_Tp, _Args...)> {using type = _Tp;};template <class _G, class _R, class _Tp, class... _Args>struct first_arg<_R (_G::*)(_Tp, _Args...)> {using type = _Tp;};template <class _G, class _R, class _Tp, class... _Args>struct first_arg<_R (_G::*)(_Tp, _Args...) const> {using type = _Tp;};template <class _Tp, class = void> struct parse_compare : first_arg<_Tp> {};template <class _Tp>struct parse_compare<_Tp, std::__void_t<decltype(&_Tp::operator())>>: first_arg<decltype(&_Tp::operator())> {};} // namespace workspace#line 7 "Library\\src\\utils\\compare.hpp"namespace workspace {/*** @brief Compare 2 points by their value of `atan2`.** @return*/template <class _Tp>bool compare_arg(const _Tp& __p1, const _Tp& __p2) noexcept {const auto& [__x1, __y1] = __p1;const auto& [__x2, __y2] = __p2;using value_type = std::decay_t<decltype(__x1)>;using mul_type = typename multiplicable<value_type>::type;if (__y1 == value_type(0))return value_type(0) <= __x1 &&(value_type(0) < __y2 ||(__y2 == value_type(0) && __x2 < value_type(0)));return value_type(0) < __y1? value_type(0) <= __y2 &&mul_type(__y1) * __x2 < mul_type(__x1) * __y2: value_type(0) <= __y2 ||mul_type(__y1) * __x2 < mul_type(__x1) * __y2;}} // 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:/*** @brief Construct a new fixed point object** @param __fn 1st argument callable with the rest of its arguments.* 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 {return __fn(*this, std::forward<_Args>(__args)...);}};} // namespace workspace#line 2 "Library\\src\\utils\\hash.hpp"#line 8 "Library\\src\\utils\\hash.hpp"#line 10 "Library\\src\\utils\\hash.hpp"namespace workspace {template <class T, class = void> struct hash : std::hash<T> {};template <class _Tp> struct hash<_Tp *> : std::hash<_Tp *> {};#if __cplusplus >= 201703Ltemplate <class Unique_bits_type>struct hash<Unique_bits_type,enable_if_trait_type<Unique_bits_type,std::has_unique_object_representations>> {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);}};#endiftemplate <class Key> size_t hash_combine(const size_t &seed, const Key &key) {return seed ^(hash<Key>()(key) + 0x9e3779b9 /* + (seed << 6) + (seed >> 2) */);}template <class T1, class T2> struct hash<std::pair<T1, T2>> {size_t operator()(const std::pair<T1, T2> &pair) const {return hash_combine(hash<T1>()(pair.first), pair.second);}};template <class... T> class hash<std::tuple<T...>> {template <class Tuple, size_t index = std::tuple_size<Tuple>::value - 1>struct tuple_hash {static uint64_t apply(const Tuple &t) {return hash_combine(tuple_hash<Tuple, index - 1>::apply(t),std::get<index>(t));}};template <class Tuple> struct tuple_hash<Tuple, size_t(-1)> {static uint64_t apply(const Tuple &t) { return 0; }};public:uint64_t operator()(const std::tuple<T...> &t) const {return tuple_hash<std::tuple<T...>>::apply(t);}};template <class hash_table> 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 <class... Args> auto emplace(Args &&... args) {return hash_table::insert(typename hash_table::value_type(args...));}};template <class Key, class Mapped = __gnu_pbds::null_type>using cc_hash_table =hash_table_wrapper<__gnu_pbds::cc_hash_table<Key, Mapped, hash<Key>>>;template <class Key, class Mapped = __gnu_pbds::null_type>using gp_hash_table =hash_table_wrapper<__gnu_pbds::gp_hash_table<Key, Mapped, hash<Key>>>;template <class Key, class Mapped>using unordered_map = std::unordered_map<Key, Mapped, hash<Key>>;template <class Key> using unordered_set = std::unordered_set<Key, hash<Key>>;} // namespace workspace#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 15 "Library\\src\\utils\\io\\istream.hpp"namespace workspace {namespace _istream_impl {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<std::decay_t<decltype(__e)>>(__is, __e);elsestatic_assert(has_begin<_Tp>::value, "istream unsupported type.");}};template <class _Tp>struct istream_helper<_Tp,decltype(std::declval<std::decay_t<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 _istream_impl/*** @brief A wrapper class for std::istream.*/class istream : public std::istream {public:/*** @brief Wrapped operator.*/template <typename _Tp> istream &operator>>(_Tp &__x) {_istream_impl::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 9 "Library\\lib\\utils"// #include "src/utils/io/ostream.hpp"// #include "src/utils/io/read.hpp"#line 2 "Library\\src\\utils\\grid\\motion.hpp"/*** @file motion.hpp* @brief Motion*/#line 9 "Library\\src\\utils\\grid\\motion.hpp"namespace workspace {/*** @brief Transpose.** @param __grid*/template <class _Grid,typename = decltype(std::declval<std::decay_t<_Grid>>()[0].resize(0))>constexpr decltype(auto) transpose(_Grid &&__grid) noexcept {auto __h = std::size(__grid), __w = std::size(__grid[0]);std::decay_t<_Grid> __t(__w);for (auto &&__r : __t) __r.resize(__h);for (size_t __i = 0; __i != __h; ++__i)for (size_t __j = 0; __j != __w; ++__j)if constexpr (std::is_rvalue_reference<decltype(__grid)>::value)__t[__j][__i] = std::move(__grid[__i][__j]);else__t[__j][__i] = __grid[__i][__j];return __t;}/*** @brief Transpose.** @param __grid*/template <class _Tp, size_t _Rows, size_t _Cols>constexpr decltype(auto) transpose(const _Tp (&__grid)[_Rows][_Cols]) noexcept {std::array<std::array<_Tp, _Rows>, _Cols> __t;for (size_t __i = 0; __i != _Rows; ++__i)for (size_t __j = 0; __j != _Cols; ++__j) __t[__j][__i] = __grid[__i][__j];return __t;}/*** @brief Transpose.** @param __grid*/template <class _Tp, size_t _Rows, size_t _Cols>constexpr decltype(auto) transpose(_Tp(&&__grid)[_Rows][_Cols]) noexcept {std::array<std::array<_Tp, _Rows>, _Cols> __t;for (size_t __i = 0; __i != _Rows; ++__i)for (size_t __j = 0; __j != _Cols; ++__j)__t[__j][__i] = std::move(__grid[__i][__j]);return __t;}/*** @brief Transpose.** @param __grid*/template <class _Tp, size_t _Rows, size_t _Cols>constexpr decltype(auto) transpose(const std::array<std::array<_Tp, _Cols>, _Rows> &__grid) noexcept {std::array<std::array<_Tp, _Rows>, _Cols> __t;for (size_t __i = 0; __i != _Rows; ++__i)for (size_t __j = 0; __j != _Cols; ++__j) __t[__j][__i] = __grid[__i][__j];return __t;}/*** @brief Transpose.** @param __grid*/template <class _Tp, size_t _Rows, size_t _Cols>constexpr decltype(auto) transpose(std::array<std::array<_Tp, _Cols>, _Rows> &&__grid) noexcept {std::array<std::array<_Tp, _Rows>, _Cols> __t;for (size_t __i = 0; __i != _Rows; ++__i)for (size_t __j = 0; __j != _Cols; ++__j)__t[__j][__i] = std::move(__grid[__i][__j]);return __t;}/*** @brief Roll the grid counter-clockwise.** @param __grid* @return*/template <class _Grid> decltype(auto) roll_ccw(_Grid &&__grid) noexcept {if constexpr (std::is_rvalue_reference<decltype(__grid)>::value) {auto __t = transpose(std::move(__grid));std::reverse(std::begin(__t), std::end(__t));return __t;}else {auto __t = transpose(__grid);std::reverse(std::begin(__t), std::end(__t));return __t;}}/*** @brief Roll the grid clockwise.** @param __grid* @return*/template <class _Grid> decltype(auto) roll_cw(_Grid &&__grid) noexcept {if constexpr (std::is_rvalue_reference<decltype(__grid)>::value) {std::reverse(std::begin(__grid), std::end(__grid));return transpose(std::move(__grid));}else {auto __t = transpose(__grid);for (auto &&__r : __t) std::reverse(std::begin(__r), std::end(__r));return __t;}}} // namespace workspace#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 {/*** @brief Setup I/O.* @param __n Standard output precision*/void io_setup(int __n) {std::cin.tie(0)->sync_with_stdio(0);std::cout << std::fixed << std::setprecision(__n);#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 15 "Library\\lib\\utils"// #include "src/utils/make_vector.hpp"// #include "src/utils/py-like/enumerate.hpp"#line 2 "Library\\src\\utils\\py-like\\range.hpp"/*** @file range.hpp* @brief Range*/#line 9 "Library\\src\\utils\\py-like\\range.hpp"#line 2 "Library\\src\\utils\\py-like\\reversed.hpp"/*** @file reversed.hpp* @brief Reversed*/#include <initializer_list>#line 10 "Library\\src\\utils\\py-like\\reversed.hpp"namespace workspace {namespace _reversed_impl {template <class _Container> class reversed {_Container __cont;public:constexpr reversed(_Container &&__cont) noexcept : __cont(__cont) {}constexpr decltype(auto) begin() noexcept { return std::rbegin(__cont); }constexpr decltype(auto) begin() const noexcept {return std::rbegin(__cont);}constexpr decltype(auto) end() noexcept { return std::rend(__cont); }constexpr decltype(auto) end() const noexcept { return std::rend(__cont); }constexpr decltype(auto) size() const noexcept { return std::size(__cont); }};} // namespace _reversed_impltemplate <class _Container>constexpr decltype(auto) reversed(_Container &&__cont) noexcept {return _reversed_impl::reversed<_Container>{std::forward<_Container>(__cont)};}template <class _Tp>constexpr decltype(auto) reversed(std::initializer_list<_Tp> &&__cont) noexcept {return _reversed_impl::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::random_access_iterator_tag;constexpr iterator(const _Index &__i = _Index()) noexcept : current(__i) {}constexpr bool operator==(const iterator &__x) const noexcept {return current == __x.current;}constexpr bool operator!=(const iterator &__x) const noexcept {return current != __x.current;}constexpr bool operator<(const iterator &__x) const noexcept {return current < __x.current;}constexpr bool operator<=(const iterator &__x) const noexcept {return current <= __x.current;}constexpr bool operator>(const iterator &__x) const noexcept {return current > __x.current;}constexpr bool operator>=(const iterator &__x) const noexcept {return current >= __x.current;}constexpr iterator &operator++() noexcept {++current;return *this;}constexpr iterator &operator++(int) noexcept {auto __tmp = *this;++current;return __tmp;}constexpr iterator &operator--() noexcept {--current;return *this;}constexpr iterator &operator--(int) noexcept {auto __tmp = *this;--current;return __tmp;}constexpr difference_type operator-(const iterator &__x) const noexcept {return current - __x.current;}constexpr iterator &operator+=(difference_type __x) noexcept {current += __x;return *this;}constexpr iterator operator+(difference_type __x) const noexcept {return iterator(*this) += __x;}constexpr iterator &operator-=(difference_type __x) noexcept {current -= __x;return *this;}constexpr iterator operator-(difference_type __x) const noexcept {return iterator(*this) -= __x;}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());}constexpr size_t size() const noexcept {return std::distance(__first, __last);}};template <class... _Args>constexpr decltype(auto) rrange(_Args &&...__args) noexcept {return reversed(range(std::forward<_Args>(__args)...));}template <class _Container>constexpr decltype(auto) iterate(_Container &&__cont) noexcept {return range(std::begin(__cont), std::end(__cont));}template <class _Container>constexpr decltype(auto) riterate(_Container &&__cont) noexcept {return range(std::rbegin(__cont), std::rend(__cont));}} // namespace workspace#endif#line 18 "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 <typename _Arithmetic>using uniform_distribution = typename std::conditional<std::is_integral<_Arithmetic>::value,std::uniform_int_distribution<_Arithmetic>,std::uniform_real_distribution<_Arithmetic>>::type;template <typename _Arithmetic, class _Engine = std::mt19937>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 <class _RAIter, class _Engine = std::mt19937>void shuffle(_RAIter __first, _RAIter __last) {static _Engine __engine(std::random_device{}());std::shuffle(__first, __last, __engine);}} // namespace workspace#line 2 "Library\\src\\utils\\rand\\tree.hpp"#line 4 "Library\\src\\utils\\rand\\tree.hpp"#line 6 "Library\\src\\utils\\rand\\tree.hpp"namespace workspace {auto random_tree(std::size_t __n) {std::vector<std::pair<std::size_t, std::size_t>> __edges;random_number_generator rng(std::size_t(0), __n);for (std::size_t __i = 1; __i != __n; ++__i)__edges.emplace_back(__i + 1, rng() % __i + 1);return __edges;}} // 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 <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 24 "Library\\lib\\utils"// #include "src\utils\reference_list.hpp"#line 11 "other-workspace\\yuki.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*/#line 2 "Library\\src\\modular\\modint.hpp"/*** @file modint.hpp** @brief Modular Arithmetic*/#line 12 "Library\\src\\modular\\modint.hpp"#line 2 "Library\\src\\number_theory\\sqrt_mod.hpp"/*** @file sqrt_mod.hpp* @brief Tonelli-Shanks Algorithm*/#line 2 "Library\\src\\number_theory\\pow_mod.hpp"/*** @file mod_pow.hpp* @brief Modular Exponentiation*/#line 9 "Library\\src\\number_theory\\pow_mod.hpp"#line 11 "Library\\src\\number_theory\\pow_mod.hpp"namespace workspace {/*** @brief Compile time modular exponentiation.** @param __x* @param __n Exponent* @param __mod Modulus* @return*/template <class _Tp>constexpr std::enable_if_t<(is_integral_ext<_Tp>::value), _Tp> pow_mod(_Tp __x, _Tp __n, _Tp __mod) noexcept {assert(__mod > 0);using mul_type = typename multiplicable_uint<_Tp>::type;if ((__x %= __mod) < 0) __x += __mod;mul_type __y{1};while (__n) {if (__n & 1) (__y *= __x) %= __mod;__x = (mul_type)__x * __x % __mod;__n >>= 1;}return __y;};} // namespace workspace#line 10 "Library\\src\\number_theory\\sqrt_mod.hpp"namespace workspace {/*** @brief Compile time modular square root.** @param __x* @param __mod Modulus* @return One if it exists. Otherwise -1.*/template <class _Tp>constexpr std::enable_if_t<(is_integral_ext<_Tp>::value), _Tp> sqrt_mod(_Tp __x, _Tp __mod) noexcept {assert(__mod > 0);using mul_type = typename multiplicable_uint<_Tp>::type;if ((__x %= __mod) < 0) __x += __mod;if (!__x) return 0;if (__mod == 2) return __x;if (pow_mod(__x, __mod >> 1, __mod) != 1) return -1;_Tp __z = __builtin_ctz(__mod - 1), __q = __mod >> __z;mul_type __a = pow_mod(__x, (__q + 1) >> 1, __mod), __b = 2;while (pow_mod<_Tp>(__b, __mod >> 1, __mod) == 1) ++__b;__b = pow_mod<_Tp>(__b, __q, __mod);_Tp __shift = 0;for (auto __r = __a * __a % __mod * pow_mod(__x, __mod - 2, __mod) % __mod;__r != 1; (__r *= (__b *= __b) %= __mod) %= __mod) {auto __bsf = __z;for (auto __e = __r; __e != 1; --__bsf) (__e *= __e) %= __mod;while (++__shift != __bsf) (__b *= __b) %= __mod;(__a *= __b) %= __mod;}return __a;};} // namespace workspace#line 15 "Library\\src\\modular\\modint.hpp"namespace workspace {namespace _modint_impl {template <auto _Mod, unsigned _Storage> struct modint {static_assert(is_integral_ext<decltype(_Mod)>::value,"_Mod must be integral type.");using mod_type = std::make_signed_t<typename std::conditional<0 < _Mod, std::add_const_t<decltype(_Mod)>, decltype(_Mod)>::type>;using value_type = std::decay_t<mod_type>;using mul_type = typename multiplicable_uint<value_type>::type;// Modulusstatic mod_type mod;static unsigned storage;private:value_type value = 0;struct direct_ctor_t {};constexpr static direct_ctor_t direct_ctor_tag{};// Direct constructortemplate <class _Tp>constexpr modint(_Tp __n, direct_ctor_t) noexcept : value(__n) {}public:constexpr modint() noexcept = default;template <class _Tp, typename = std::enable_if_t<is_integral_ext<_Tp>::value>>constexpr modint(_Tp __n) noexcept: value((__n %= mod) < 0 ? __n += mod : __n) {}constexpr modint(bool __n) noexcept : value(__n) {}constexpr operator value_type() const noexcept { return value; }// unary operators {{constexpr modint operator++(int) noexcept {modint __t{*this};operator++();return __t;}constexpr modint operator--(int) noexcept {modint __t{*this};operator--();return __t;}constexpr modint &operator++() noexcept {if (++value == mod) value = 0;return *this;}constexpr modint &operator--() noexcept {if (!value)value = mod - 1;else--value;return *this;}constexpr modint operator+() const noexcept { return *this; }constexpr modint operator-() const noexcept {return {value ? mod - value : 0, direct_ctor_tag};}// }} unary operators// operator+= {{constexpr modint &operator+=(const modint &__x) noexcept {if ((value += __x.value) >= mod) value -= mod;return *this;}template <class _Tp>constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> &operator+=(_Tp const &__x) noexcept {if (((value += __x) %= mod) < 0) value += mod;return *this;}// }} operator+=// operator+ {{template <class _Tp>constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> operator+(_Tp const &__x) const noexcept {return modint{*this} += __x;}constexpr modint operator+(modint __x) const noexcept { return __x += *this; }template <class _Tp>constexpr friend std::enable_if_t<is_integral_ext<_Tp>::value, modint>operator+(_Tp const &__x, modint __y) noexcept {return __y += __x;}// }} operator+// operator-= {{constexpr modint &operator-=(const modint &__x) noexcept {if ((value -= __x.value) < 0) value += mod;return *this;}template <class _Tp>constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> &operator-=(_Tp __x) noexcept {if (((value -= __x) %= mod) < 0) value += mod;return *this;}// }} operator-=// operator- {{template <class _Tp>constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> operator-(_Tp const &__x) const noexcept {return modint{*this} -= __x;}constexpr modint operator-(const modint &__x) const noexcept {return modint{*this} -= __x;}template <class _Tp>constexpr friend std::enable_if_t<is_integral_ext<_Tp>::value, modint>operator-(_Tp __x, const modint &__y) noexcept {if (((__x -= __y.value) %= mod) < 0) __x += mod;return {__x, direct_ctor_tag};}// }} operator-// operator*= {{constexpr modint &operator*=(const modint &__x) noexcept {value =static_cast<value_type>(value * static_cast<mul_type>(__x.value) % mod);return *this;}template <class _Tp>constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> &operator*=(_Tp __x) noexcept {value = static_cast<value_type>(value * mul_type((__x %= mod) < 0 ? __x + mod : __x) % mod);return *this;}// }} operator*=// operator* {{constexpr modint operator*(const modint &__x) const noexcept {return {static_cast<mul_type>(value) * __x.value % mod, direct_ctor_tag};}template <class _Tp>constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> operator*(_Tp __x) const noexcept {__x %= mod;if (__x < 0) __x += mod;return {static_cast<mul_type>(value) * __x % mod, direct_ctor_tag};}template <class _Tp>constexpr friend std::enable_if_t<is_integral_ext<_Tp>::value, modint>operator*(_Tp __x, const modint &__y) noexcept {__x %= mod;if (__x < 0) __x += mod;return {static_cast<mul_type>(__x) * __y.value % mod, direct_ctor_tag};}// }} 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];}static value_type _div(mul_type __r, value_type __x) noexcept {assert(__x != value_type(0));if (!__r) return 0;std::make_signed_t<value_type> __v{};bool __neg = __x < 0 ? __x = -__x, true : false;if (static_cast<decltype(storage)>(__x) < storage)__v = _mem(__x);else {value_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;return __r == mul_type(1) ? static_cast<value_type>(__v): static_cast<value_type>(__r * __v % mod);}public:// operator/= {{constexpr modint &operator/=(const modint &__x) noexcept {if (value) value = _div(value, __x.value);return *this;}template <class _Tp>constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> &operator/=(_Tp __x) noexcept {if (value) value = _div(value, __x %= mod);return *this;}// }} operator/=// operator/ {{constexpr modint operator/(const modint &__x) const noexcept {if (!value) return {};return {_div(value, __x.value), direct_ctor_tag};}template <class _Tp>constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> operator/(_Tp __x) const noexcept {if (!value) return {};return {_div(value, __x %= mod), direct_ctor_tag};}template <class _Tp>constexpr friend std::enable_if_t<is_integral_ext<_Tp>::value, modint>operator/(_Tp __x, const modint &__y) noexcept {if (!__x) return {};if ((__x %= mod) < 0) __x += mod;return {_div(__x, __y.value), direct_ctor_tag};}// }} operator/constexpr modint inv() const noexcept { return _div(1, value); }template <class _Tp>constexpr std::enable_if_t<is_integral_ext<_Tp>::value, modint> pow(_Tp __e) const noexcept {modint __r{1, direct_ctor_tag};for (modint __b{__e < 0 ? __e = -__e, _div(1, value) : value,direct_ctor_tag};__e; __e >>= 1, __b *= __b)if (__e & 1) __r *= __b;return __r;}template <class _Tp>constexpr friend std::enable_if_t<is_integral_ext<_Tp>::value, modint> pow(modint __b, _Tp __e) noexcept {if (__e < 0) {__e = -__e;__b.value = _div(1, __b.value);}modint __r{1, direct_ctor_tag};for (; __e; __e >>= 1, __b *= __b)if (__e & 1) __r *= __b;return __r;}constexpr modint sqrt() const noexcept {return {sqrt_mod(value, mod), direct_ctor_tag};}friend constexpr modint sqrt(const modint &__x) noexcept {return {sqrt_mod(__x.value, mod), direct_ctor_tag};}template <class _Os>friend _Os &operator<<(_Os &__os, const modint &__x) noexcept {return __os << __x.value;}friend std::istream &operator>>(std::istream &__is, modint &__x) noexcept {std::string __s;__is >> __s;bool __neg = false;if (__s.front() == '-') {__neg = true;__s.erase(__s.begin());}__x = 0;for (char __c : __s) __x = __x * 10 + (__c - '0');if (__neg) __x = -__x;return __is;}};template <auto _Mod, unsigned _Storage>typename modint<_Mod, _Storage>::mod_type modint<_Mod, _Storage>::mod =_Mod > 0 ? _Mod : 0;template <auto _Mod, unsigned _Storage>unsigned modint<_Mod, _Storage>::storage = _Storage;} // namespace _modint_impltemplate <auto _Mod, unsigned _Storage = 0,typename = std::enable_if_t<(_Mod > 0)>>using modint = _modint_impl::modint<_Mod, _Storage>;template <unsigned _Id = 0>using modint_runtime = _modint_impl::modint<-(signed)_Id, 0>;} // namespace workspace#line 2 "Library\\src\\combinatorics\\factorial.hpp"/*** @file factorial.hpp* @brief Factorial* @date 2021-01-15***/#line 12 "Library\\src\\combinatorics\\factorial.hpp"namespace workspace {template <class _Tp> _Tp factorial(int32_t __x) noexcept {if (__x < 0) return 0;static std::vector<_Tp> __t{1};static int32_t __i = (__t.reserve(0x1000000), 0);while (__i < __x) {++__i;__t.emplace_back(__t.back() * _Tp(__i));}return __t[__x];}template <class _Tp> _Tp factorial_inverse(int32_t __x) noexcept {if (__x < 0) return 0;static std::vector<_Tp> __t{1};static int32_t __i = (__t.reserve(0x1000000), 0);while (__i < __x) {++__i;__t.emplace_back(__t.back() / _Tp(__i));}return __t[__x];}} // namespace workspace#line 10 "Library\\src\\combinatorics\\binomial.hpp"namespace workspace {namespace _binom_impl {struct _binom_table {constexpr static int size = 132;__uint128_t __b[size][size]{1};constexpr _binom_table() noexcept {for (int __i = 1; __i != size; ++__i)for (int __j = 0; __j != __i; ++__j)__b[__i][__j] += __b[__i - 1][__j],__b[__i][__j + 1] += __b[__i - 1][__j];}constexpr auto operator()(int __x, int __y) const noexcept {return __x < 0 || __x < __y ? 0 : (assert(__x < size), __b[__x][__y]);}};constexpr _binom_table table;} // namespace _binom_impl/*** @brief Binomial coefficient for integer args. Be careful with overflow.*/template <class _Tp> constexpr _Tp binomial(int32_t __x, int32_t __y) {if constexpr (is_integral_ext<_Tp>::value)return _binom_impl::table(__x, __y);if (__y < 0 || __x < __y) return 0;return factorial<_Tp>(__x) * factorial_inverse<_Tp>(__y) *factorial_inverse<_Tp>(__x - __y);}/*** @brief Catalan number.*/template <class _Tp> constexpr _Tp catalan(int32_t __x) {return binomial<_Tp>(__x << 1, __x) - binomial<_Tp>(__x << 1, __x + 1);}} // namespace workspace#line 28 "other-workspace\\yuki.cc"namespace workspace {using mint = modint<1000000007>;auto binom = binomial<mint>;void main() {// start here!int h, w;cin >> h >> w;--h, --w;mint ans;ans += binom(h + w - 2, h - 1);ans *= 2 * (h + w - 1);cout << ans << "\n";}} // namespace workspace