#line 1 "other-workspace\\tmp.cpp" #if defined(ONLINE_JUDGE) // && 0 #pragma GCC optimize("Ofast,unroll-loops") #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,mmx,avx,avx2") #endif // #undef _GLIBCXX_DEBUG #include #line 2 "Library\\lib\\alias" /** * @file alias * @brief Alias */ #line 10 "Library\\lib\\alias" // #include "bit" #line 2 "Library\\lib\\limits" #line 4 "Library\\lib\\limits" namespace workspace { template 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. #endif template () < std::declval())> constexpr typename std::conditional::value, const _T1 &, typename std::common_type<_T1, _T2>::type>::type min(const _T1 &__x, const _T2 &__y) noexcept { return __y < __x ? __y : __x; } template ()( std::declval(), std::declval()))> constexpr typename std::conditional::value, const _T1 &, typename std::common_type<_T1, _T2>::type>::type min(const _T1 &__x, const _T2 &__y, _Compare __comp) noexcept { return __comp(__y, __x) ? __y : __x; } template () < std::declval())> constexpr _Tp min(std::initializer_list<_Tp> __x) noexcept { return *std::min_element(__x.begin(), __x.end()); } template ()( std::declval(), std::declval()))> constexpr _Tp min(std::initializer_list<_Tp> __x, _Compare __comp) noexcept { return *std::min_element(__x.begin(), __x.end(), __comp); } template () < std::declval())> constexpr typename std::conditional::value, const _T1 &, typename std::common_type<_T1, _T2>::type>::type max(const _T1 &__x, const _T2 &__y) noexcept { return __x < __y ? __y : __x; } template ()( std::declval(), std::declval()))> constexpr typename std::conditional::value, const _T1 &, typename std::common_type<_T1, _T2>::type>::type max(const _T1 &__x, const _T2 &__y, _Compare __comp) noexcept { return __comp(__x, __y) ? __y : __x; } template () < std::declval())> constexpr _Tp max(std::initializer_list<_Tp> __x) noexcept { return *std::max_element(__x.begin(), __x.end()); } template ()( std::declval(), std::declval()))> constexpr _Tp max(std::initializer_list<_Tp> __x, _Compare __comp) noexcept { return *std::max_element(__x.begin(), __x.end(), __comp); } } // namespace workspace #line 2 "Library\\lib\\cxx20" /* * @file cxx20 * @brief C++20 Features */ #line 2 "Library\\lib\\bit" #if __cplusplus > 201703L #include #elif __cplusplus > 201402L #ifndef _GLIBCXX_BIT #define _GLIBCXX_BIT 1 #include #include namespace std { template constexpr int __countl_zero(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return _Nd; constexpr auto _Nd_ull = numeric_limits::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::digits; if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u) { constexpr int __diff = _Nd_u - _Nd; return __builtin_clz(__x) - __diff; } else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul) { constexpr int __diff = _Nd_ul - _Nd; return __builtin_clzl(__x) - __diff; } else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull) { constexpr int __diff = _Nd_ull - _Nd; return __builtin_clzll(__x) - __diff; } else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); unsigned long long __high = __x >> _Nd_ull; if (__high != 0) { constexpr int __diff = (2 * _Nd_ull) - _Nd; return __builtin_clzll(__high) - __diff; } constexpr auto __max_ull = numeric_limits::max(); unsigned long long __low = __x & __max_ull; return (_Nd - _Nd_ull) + __builtin_clzll(__low); } } template constexpr int __countr_zero(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return _Nd; constexpr auto _Nd_ull = numeric_limits::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::digits; if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u) return __builtin_ctz(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul) return __builtin_ctzl(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull) return __builtin_ctzll(__x); else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); constexpr auto __max_ull = numeric_limits::max(); unsigned long long __low = __x & __max_ull; if (__low != 0) return __builtin_ctzll(__low); unsigned long long __high = __x >> _Nd_ull; return __builtin_ctzll(__high) + _Nd_ull; } } template constexpr int __popcount(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return 0; constexpr auto _Nd_ull = numeric_limits::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::digits; if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u) return __builtin_popcount(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul) return __builtin_popcountl(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull) return __builtin_popcountll(__x); else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); constexpr auto __max_ull = numeric_limits::max(); unsigned long long __low = __x & __max_ull; unsigned long long __high = __x >> _Nd_ull; return __builtin_popcountll(__low) + __builtin_popcountll(__high); } } template constexpr _Tp __bit_ceil(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0 || __x == 1) return 1; auto __shift_exponent = _Nd - __countl_zero((_Tp)(__x - 1u)); #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED if (!__builtin_is_constant_evaluated()) { __glibcxx_assert(__shift_exponent != numeric_limits<_Tp>::digits); } #endif using __promoted_type = decltype(__x << 1); if _GLIBCXX17_CONSTEXPR (!is_same<__promoted_type, _Tp>::value) { const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; } return (_Tp)1u << __shift_exponent; } template constexpr _Tp __bit_floor(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return 0; return (_Tp)1u << (_Nd - __countl_zero((_Tp)(__x >> 1))); } template constexpr _Tp __bit_width(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; return _Nd - __countl_zero(__x); } } // namespace std #endif #endif namespace workspace { #ifdef _GLIBCXX_BIT template constexpr _Tp bsf(_Tp __x) noexcept { return std::__countr_zero(__x); } template constexpr _Tp bsr(_Tp __x) noexcept { return std::__bit_width(__x) - 1; } template constexpr _Tp popcount(_Tp __x) noexcept { return std::__popcount(__x); } #endif template constexpr _Tp test_bit(const _Tp& __b, std::size_t __n) noexcept { return __b >> __n & 1; } } // namespace workspace #line 9 "Library\\lib\\cxx20" #if __cplusplus <= 201703L #include #include namespace std { /** * @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 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(); } /** * @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 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\\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 void call_once(_F &&__f) { static std::unordered_set __called; if (__called.count(std::addressof(__f))) return; __called.emplace(std::addressof(__f)); __f(); } } // namespace workspace #line 2 "Library\\src\\sys\\clock.hpp" /** * @file 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 /** * @return Elapsed time of the program. */ decltype(auto) elapsed() noexcept { const auto end_time{system_clock::now()}; return duration_cast(end_time - internal::start_time).count(); } } // namespace workspace #line 2 "Library\\src\\sys\\ejection.hpp" /** * @file ejection.hpp * @brief Ejection */ #line 9 "Library\\src\\sys\\ejection.hpp" namespace workspace { namespace internal { struct ejection { bool exit = 0; }; } // namespace internal /** * @brief eject from a try block, throw nullptr * @param arg output */ template void eject(Tp const &arg) { std::cout << arg << "\n"; throw internal::ejection{}; } void exit() { throw internal::ejection{true}; } } // namespace workspace #line 2 "Library\\src\\sys\\iteration.hpp" /** * @file iteration.hpp * @brief Case Iteration */ #line 9 "Library\\src\\sys\\iteration.hpp" #line 11 "Library\\src\\sys\\iteration.hpp" namespace workspace { void main(); struct { // 1-indexed unsigned current{0}; unsigned total{1}; void read() { (std::cin >> total).ignore(); } int iterate() { static bool once = false; assert(!once); once = true; while (current++ < total) { try { main(); } catch (internal::ejection const& status) { if (status.exit) break; } } return 0; } } case_info; } // namespace workspace #line 2 "Library\\src\\utils\\cached.hpp" /** * @file cached.hpp * @brief Cached */ #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 { // Fixed Point Combinator. template class fixed_point { struct _wrapper { _F &__ref; template decltype(auto) operator()(_Args &&...__args) { return __ref(*this, std::forward<_Args>(__args)...); } }; _F __fn; public: // Construct a new fixed-point object. fixed_point(_F __x) noexcept : __fn(__x) {} // Function call. template decltype(auto) operator()(_Args &&...__args) noexcept(noexcept(_wrapper{ __fn}(std::forward<_Args>(__args)...))) { return _wrapper{__fn}(std::forward<_Args>(__args)...); } }; } // namespace workspace #line 2 "Library\\src\\utils\\hash.hpp" #line 8 "Library\\src\\utils\\hash.hpp" #line 2 "Library\\src\\utils\\sfinae.hpp" /** * @file sfinae.hpp * @brief SFINAE */ #line 10 "Library\\src\\utils\\sfinae.hpp" #include #ifndef __INT128_DEFINED__ #ifdef __SIZEOF_INT128__ #define __INT128_DEFINED__ 1 #else #define __INT128_DEFINED__ 0 #endif #endif namespace std { #if __INT128_DEFINED__ template <> struct make_signed<__uint128_t> { using type = __int128_t; }; template <> struct make_signed<__int128_t> { using type = __int128_t; }; template <> struct make_unsigned<__uint128_t> { using type = __uint128_t; }; template <> struct make_unsigned<__int128_t> { using type = __uint128_t; }; 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 std namespace workspace { template struct variadic_front { using type = Tp; }; template struct variadic_back; template struct variadic_back { using type = Tp; }; template struct variadic_back { using type = typename variadic_back::type; }; template class trait> using enable_if_trait_type = typename std::enable_if::value>::type; /** * @brief Return type of subscripting ( @c [] ) access. */ template using subscripted_type = typename std::decay()[0])>::type; template using element_type = typename std::decay()))>::type; template struct has_begin : std::false_type {}; template struct has_begin< _Tp, std::__void_t()))>> : std::true_type { using type = decltype(std::begin(std::declval())); }; template struct has_size : std::false_type {}; template struct has_size<_Tp, std::__void_t()))>> : std::true_type {}; template struct has_resize : std::false_type {}; template struct has_resize<_Tp, std::__void_t().resize( std::declval()))>> : std::true_type {}; template struct has_mod : std::false_type {}; template struct has_mod<_Tp, std::__void_t> : std::true_type {}; template struct is_integral_ext : std::false_type {}; template struct is_integral_ext< _Tp, typename std::enable_if::value>::type> : std::true_type {}; #if __INT128_DEFINED__ template <> struct is_integral_ext<__int128_t> : std::true_type {}; template <> struct is_integral_ext<__uint128_t> : std::true_type {}; #endif #if __cplusplus >= 201402 template constexpr static bool is_integral_ext_v = is_integral_ext<_Tp>::value; #endif template struct multiplicable_uint { using type = uint_least32_t; }; template struct multiplicable_uint< _Tp, typename std::enable_if<(2 < sizeof(_Tp)) && (!__INT128_DEFINED__ || sizeof(_Tp) <= 4)>::type> { using type = uint_least64_t; }; #if __INT128_DEFINED__ template struct multiplicable_uint<_Tp, typename std::enable_if<(4 < sizeof(_Tp))>::type> { using type = __uint128_t; }; #endif template struct multiplicable_int { using type = typename std::make_signed::type>::type; }; template struct multiplicable { using type = std::conditional_t< is_integral_ext<_Tp>::value, std::conditional_t::value, typename multiplicable_int<_Tp>::type, typename multiplicable_uint<_Tp>::type>, _Tp>; }; template struct first_arg { using type = void; }; template struct first_arg<_R(_Tp, _Args...)> { using type = _Tp; }; template struct first_arg<_R (*)(_Tp, _Args...)> { using type = _Tp; }; template struct first_arg<_R (_G::*)(_Tp, _Args...)> { using type = _Tp; }; template struct first_arg<_R (_G::*)(_Tp, _Args...) const> { using type = _Tp; }; template struct parse_compare : first_arg<_Tp> {}; template struct parse_compare<_Tp, std::__void_t> : first_arg {}; template struct get_dimension { static constexpr size_t value = 0; }; template struct get_dimension<_Container, std::enable_if_t::value>> { static constexpr size_t value = 1 + get_dimension::type>::value_type>::value; }; } // namespace workspace #line 10 "Library\\src\\utils\\hash.hpp" namespace workspace { template struct hash : std::hash {}; template struct hash<_Tp *> : std::hash<_Tp *> {}; #if __cplusplus >= 201703L template struct hash> { size_t operator()(uint64_t x) const { static const uint64_t m = std::random_device{}(); x ^= x >> 23; x ^= m; x ^= x >> 47; return x - (x >> 32); } }; #endif template size_t hash_combine(const size_t &seed, const Key &key) { return seed ^ (hash()(key) + 0x9e3779b9 /* + (seed << 6) + (seed >> 2) */); } template struct hash> { size_t operator()(const std::pair &pair) const { return hash_combine(hash()(pair.first), pair.second); } }; template class hash> { template ::value - 1> struct tuple_hash { static uint64_t apply(const Tuple &t) { return hash_combine(tuple_hash::apply(t), std::get(t)); } }; template struct tuple_hash { static uint64_t apply([[maybe_unused]] const Tuple &t) { return 0; } }; public: uint64_t operator()(const std::tuple &t) const { return tuple_hash>::apply(t); } }; template struct hash_table_wrapper : hash_table { using key_type = typename hash_table::key_type; size_t count(const key_type &key) const { return hash_table::find(key) != hash_table::end(); } template auto emplace(Args &&...args) { return hash_table::insert(typename hash_table::value_type(args...)); } }; template using cc_hash_table = hash_table_wrapper<__gnu_pbds::cc_hash_table>>; template using gp_hash_table = hash_table_wrapper<__gnu_pbds::gp_hash_table>>; template using unordered_map = std::unordered_map>; template using unordered_set = std::unordered_set>; template struct is_hashable : std::false_type {}; template struct is_hashable<_Tp, std::__void_t>()( std::declval()))>> : std::true_type {}; } // namespace workspace #line 2 "Library\\lib\\cxx17" #line 2 "Library\\lib\\cxx14" #ifndef _CXX14_CONSTEXPR #if __cplusplus >= 201402L #define _CXX14_CONSTEXPR constexpr #else #define _CXX14_CONSTEXPR #endif #endif #line 4 "Library\\lib\\cxx17" #ifndef _CXX17_CONSTEXPR #if __cplusplus >= 201703L #define _CXX17_CONSTEXPR constexpr #else #define _CXX17_CONSTEXPR #endif #endif #ifndef _CXX17_STATIC_ASSERT #if __cplusplus >= 201703L #define _CXX17_STATIC_ASSERT static_assert #else #define _CXX17_STATIC_ASSERT assert #endif #endif #line 22 "Library\\lib\\cxx17" #if __cplusplus < 201703L namespace std { /** * @brief Return the size of a container. * @param __cont Container. */ template constexpr auto size(const _Container& __cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size()) { return __cont.size(); } /** * @brief Return the size of an array. */ template constexpr size_t size(const _Tp (&)[_Nm]) noexcept { return _Nm; } /** * @brief Return whether a container is empty. * @param __cont Container. */ template [[nodiscard]] constexpr auto empty(const _Container& __cont) noexcept( noexcept(__cont.empty())) -> decltype(__cont.empty()) { return __cont.empty(); } /** * @brief Return whether an array is empty (always false). */ template [[nodiscard]] constexpr bool empty(const _Tp (&)[_Nm]) noexcept { return false; } /** * @brief Return whether an initializer_list is empty. * @param __il Initializer list. */ template [[nodiscard]] constexpr bool empty(initializer_list<_Tp> __il) noexcept { return __il.size() == 0; } struct monostate {}; } // namespace std #else #include #endif #line 11 "Library\\src\\utils\\cached.hpp" namespace workspace { namespace _cached_impl { // Convert keys to tuple. template using as_tuple = decltype(std::tuple_cat( std::declval, _Args>::value, std::decay_t<_Args>, _Args>>>()...)); template struct hash_map : unordered_map<_Tp, _V> { template decltype(auto) lower_bound(_Args &&...__args) noexcept { return unordered_map<_Tp, _V>::find(std::forward<_Args>(__args)...); } }; template struct hash_set : unordered_set<_Tp> { template decltype(auto) lower_bound(_Args &&...__args) noexcept { return unordered_set<_Tp>::find(std::forward<_Args>(__args)...); } }; // Associative array. template struct assoc : std::integral_constant::value>, std::conditional_t< std::is_void<_Value>::value, std::conditional_t>::value, hash_set>, std::set>>, std::conditional_t< // is_hashable>::value, false, hash_map, _Value>, std::map, _Value>>> {}; // Non-resursive lambda type. template struct is_recursive : std::false_type {}; // Resursive lambda type. template struct is_recursive< _F, std::__void_t &>)>> : std::true_type {}; // Recursive ver. template class _recursive { template struct _cache; template struct _cache<_R (_G::*)(_H, _Args...)> : assoc<_R, _Args...> {}; template struct _cache<_R (_G::*)(_H, _Args...) const> : assoc<_R, _Args...> {}; template struct _cache<_R (_G::*)(_H, _Args...) noexcept> : assoc<_R, _Args...> {}; template struct _cache<_R (_G::*)(_H, _Args...) const noexcept> : assoc<_R, _Args...> { }; public: using cache_type = _cache &>)>; private: _F __fn; cache_type __c; struct _wrapper { _F &__fn; cache_type &__c; template decltype(auto) operator()(_Args &&...__args) noexcept( noexcept(__fn(*this, std::forward<_Args>(__args)...))) { typename cache_type::key_type __key{__args...}; auto __i = __c.lower_bound(__key); if _CXX17_CONSTEXPR (cache_type::value) { if (__i != __c.end() && __i->first == __key) return __i->second; return __c .emplace_hint(__i, std::move(__key), __fn(*this, std::forward<_Args>(__args)...)) ->second; } else if (__i == __c.end() || *__i != __key) __c.emplace_hint(__i, std::move(__key)), __fn(*this, std::forward<_Args>(__args)...); } }; public: _recursive(_F &&__x) noexcept : __fn(__x) {} // Function call. template decltype(auto) operator()(_Args &&...__args) noexcept(noexcept(_wrapper{ __fn, __c}(std::forward<_Args>(__args)...))) { return _wrapper{__fn, __c}(std::forward<_Args>(__args)...); } }; // Non-recursive ver. template class _non_recursive { template struct _get_func { using type = _T; }; template struct _get_func<_T, std::__void_t> { using type = decltype(&_T::operator()); }; template struct _cache; template struct _cache<_R(_Args...)> : assoc<_R, _Args...> {}; template struct _cache<_R (*)(_Args...)> : assoc<_R, _Args...> {}; template struct _cache<_R (_G::*)(_Args...)> : assoc<_R, _Args...> {}; template struct _cache<_R (_G::*)(_Args...) const> : assoc<_R, _Args...> {}; template struct _cache<_R(_Args...) noexcept> : assoc<_R, _Args...> {}; template struct _cache<_R (*)(_Args...) noexcept> : assoc<_R, _Args...> {}; template struct _cache<_R (_G::*)(_Args...) noexcept> : assoc<_R, _Args...> {}; template struct _cache<_R (_G::*)(_Args...) const noexcept> : assoc<_R, _Args...> {}; public: using cache_type = _cache::type>; private: _F __fn; cache_type __c; public: _non_recursive(_F &&__x) noexcept : __fn(__x) {} // Function call. template decltype(auto) operator()(_Args &&...__args) noexcept( noexcept(__fn(std::forward<_Args>(__args)...))) { typename cache_type::key_type __key{__args...}; auto __i = __c.lower_bound(__key); if _CXX17_CONSTEXPR (cache_type::value) { if (__i != __c.end() && __i->first == __key) return __i->second; return __c .emplace_hint(__i, std::move(__key), __fn(std::forward<_Args>(__args)...)) ->second; } else if (__i == __c.end() || *__i != __key) __c.emplace_hint(__i, std::move(__key)), __fn(std::forward<_Args>(__args)...); } }; template using _cached = std::conditional_t::value, _recursive<_F>, _non_recursive<_F>>; } // namespace _cached_impl /** * @brief Cached caller of function */ template class cached : public _cached_impl::_cached<_F> { public: // Construct a new cached object. cached() noexcept : _cached_impl::_cached<_F>(_F{}) {} // Construct a new cached object. cached(_F __x) noexcept : _cached_impl::_cached<_F>(std::move(__x)) {} }; } // namespace workspace #line 2 "Library\\lib\\utils" // #include "src/utils/cat.hpp" #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 () < std::declval<_T1 &>())> typename std::enable_if::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 () < std::declval<_T2>())> typename std::enable_if::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 ()(std::declval<_T2>(), std::declval<_T1 &>()))> typename std::enable_if::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 ()(std::declval<_T1 &>(), std::declval<_T2>()))> typename std::enable_if::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 2 "Library\\src\\utils\\io\\istream.hpp" /** * @file istream.hpp * @brief Input Stream */ #include #line 13 "Library\\src\\utils\\io\\istream.hpp" #line 16 "Library\\src\\utils\\io\\istream.hpp" namespace workspace { namespace _istream_impl { template struct helper { helper(std::istream &__is, _Tp &__x) { if _CXX17_CONSTEXPR (has_begin<_Tp &>::value) for (auto &&__e : __x) helper>(__is, __e); else static_assert(has_begin<_Tp>::value, "istream unsupported type."); } }; template struct helper<_Tp, std::__void_t() >> std::declval<_Tp &>())>> { helper(std::istream &__is, _Tp &__x) { __is >> __x; } }; #ifdef __SIZEOF_INT128__ template <> struct helper<__uint128_t, void> { 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 helper<__int128_t, void> { helper(std::istream &__is, __int128_t &__x) { std::string __s; __is >> __s; bool __neg = false; if (__s.front() == '-') __neg = true, __s.erase(__s.begin()); __x = 0; for (char __d : __s) { __x *= 10; __d -= '0'; if (__neg) __x -= __d; else __x += __d; } } }; #endif // INT128 template struct helper> { helper(std::istream &__is, std::pair<_T1, _T2> &__x) { helper<_T1>(__is, __x.first), helper<_T2>(__is, __x.second); } }; template struct helper> { helper(std::istream &__is, std::tuple<_Tp...> &__x) { iterate(__is, __x); } private: template void iterate(std::istream &__is, _Tuple &__x) { if _CXX17_CONSTEXPR (_Nm != std::tuple_size<_Tuple>::value) { helper::type>( __is, std::get<_Nm>(__x)), iterate<_Tuple, _Nm + 1>(__is, __x); } } }; } // namespace _istream_impl /** * @brief A wrapper class for std::istream. */ class istream : public std::istream { public: /** * @brief Wrapped operator. */ template istream &operator>>(_Tp &__x) { _istream_impl::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(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" #line 11 "Library\\src\\utils\\io\\ostream.hpp" namespace workspace { template struct is_ostream { template static std::true_type __test(std::basic_ostream<_Args...> *); static std::false_type __test(void *); constexpr static bool value = decltype(__test(std::declval<_Os *>()))::value; }; template using ostream_ref = typename std::enable_if::value, _Os &>::type; /** * @brief Stream insertion operator for C-style array. * * @param __os Output stream * @param __a Array * @return Reference to __os. */ template typename std::enable_if 2), ostream_ref<_Os>>::type operator<<(_Os &__os, const _Tp (&__a)[_Nm]) { if _CXX17_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::array. * * @param __os Output stream * @param __a Array * @return Reference to __os. */ template ostream_ref<_Os> operator<<(_Os &__os, const std::array<_Tp, _Nm> &__a) { if _CXX17_CONSTEXPR (_Nm) { __os << __a[0]; for (size_t __i = 1; __i != _Nm; ++__i) __os << ' ' << __a[__i]; } return __os; } /** * @brief Stream insertion operator for std::pair. * * @param __os Output stream * @param __p Pair * @return Reference to __os. */ template ostream_ref<_Os> operator<<(_Os &__os, const std::pair<_T1, _T2> &__p) { return __os << __p.first << ' ' << __p.second; } /** * @brief Stream insertion operator for std::tuple. * * @param __os Output stream * @param __t Tuple * @return Reference to __os. */ template typename std::enable_if::value + 1), ostream_ref<_Os>>::type operator<<(_Os &__os, const _Tp &__t) { if _CXX17_CONSTEXPR (_Nm != std::tuple_size<_Tp>::value) { if _CXX17_CONSTEXPR (_Nm) __os << ' '; __os << std::get<_Nm>(__t); operator<<<_Os, _Tp, _Nm + 1>(__os, __t); } return __os; } template ()))> typename std::enable_if< !std::is_convertible, std::string>::value && !std::is_convertible, char *>::value, ostream_ref<_Os>>::type operator<<(_Os &__os, const _Container &__cont) { bool __h = true; for (auto &&__e : __cont) __h ? __h = 0 : (__os << ' ', 0), __os << __e; return __os; } #ifdef __SIZEOF_INT128__ /** * @brief Stream insertion operator for __int128_t. * * @param __os Output Stream * @param __x 128-bit integer * @return Reference to __os. */ template ostream_ref<_Os> operator<<(_Os &__os, __int128_t __x) { if (!__x) return __os << '0'; if (__x < 0) __os << '-'; char __s[40], *__p = __s; while (__x) { auto __d = __x % 10; *__p++ = '0' + (__x < 0 ? -__d : __d); __x /= 10; } *__p = 0; for (char *__t = __s; __t < --__p; ++__t) *__t ^= *__p ^= *__t ^= *__p; return __os << __s; } /** * @brief Stream insertion operator for __uint128_t. * * @param __os Output Stream * @param __x 128-bit unsigned integer * @return Reference to __os. */ template ostream_ref<_Os> operator<<(_Os &__os, __uint128_t __x) { if (!__x) return __os << '0'; char __s[40], *__p = __s; while (__x) *__p++ = '0' + __x % 10, __x /= 10; *__p = 0; for (char *__t = __s; __t < --__p; ++__t) *__t ^= *__p ^= *__t ^= *__p; return __os << __s; } #endif } // namespace workspace #line 8 "Library\\lib\\utils" // #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" #line 11 "Library\\src\\utils\\grid\\motion.hpp" namespace workspace { /** * @brief Transpose. * @param __grid */ template >()[0].resize(0))> constexpr decltype(auto) transpose(_Grid &&__grid) noexcept { #if __cplusplus < 201703L auto __h = __grid.size(), __w = __grid[0].size(); #else auto __h = std::size(__grid), __w = std::size(__grid[0]); #endif 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 _CXX17_CONSTEXPR (std::is_rvalue_reference::value) __t[__j][__i] = std::move(__grid[__i][__j]); else __t[__j][__i] = __grid[__i][__j]; return __t; } /** * @brief Transpose. * @param __grid */ template constexpr decltype(auto) transpose(const _Tp (&__grid)[_Rows][_Cols]) noexcept { std::array, _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 constexpr decltype(auto) transpose(_Tp(&&__grid)[_Rows][_Cols]) noexcept { std::array, _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 constexpr decltype(auto) transpose( const std::array, _Rows> &__grid) noexcept { std::array, _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 constexpr decltype(auto) transpose( std::array, _Rows> &&__grid) noexcept { std::array, _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 */ template decltype(auto) roll_ccw(_Grid &&__grid) noexcept { if _CXX17_CONSTEXPR (std::is_rvalue_reference::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 */ template decltype(auto) roll_cw(_Grid &&__grid) noexcept { if _CXX17_CONSTEXPR (std::is_rvalue_reference::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_check atexit([] { char bufc; if (std::cin >> bufc) std::cerr << "\n\033[43m\033[30mwarning: buffer not empty.\033[0m\n\n"; }); #endif } } // namespace workspace #line 11 "Library\\lib\\utils" // #include "src/utils/iterator/category.hpp" // #include "src/utils/iterator/reverse.hpp" // #include "src/utils/make_vector.hpp" #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 2 "Library\\src\\utils\\py-like\\reversed.hpp" /** * @file reversed.hpp * @brief Reversed */ #line 9 "Library\\src\\utils\\py-like\\reversed.hpp" #line 11 "Library\\src\\utils\\py-like\\reversed.hpp" namespace workspace { // Reversed container. template class reversed { _Container __c; public: template constexpr reversed(_Tp &&__x) noexcept : __c(std::forward<_Container>(__x)) {} template constexpr reversed(std::initializer_list<_Tp> __x) noexcept : __c(__x) {} constexpr decltype(auto) begin() noexcept { return std::rbegin(__c); } constexpr decltype(auto) begin() const noexcept { return std::rbegin(__c); } constexpr decltype(auto) end() noexcept { return std::rend(__c); } constexpr decltype(auto) end() const noexcept { return std::rend(__c); } constexpr bool empty() const noexcept { return std::empty(__c); } constexpr decltype(auto) size() const noexcept { return std::size(__c); } using iterator = decltype(std::rbegin(__c)); using const_iterator = decltype(std::crbegin(__c)); using size_type = decltype(std::size(__c)); using difference_type = typename std::iterator_traits::difference_type; using value_type = typename std::iterator_traits::value_type; using reference = typename std::iterator_traits::reference; using const_reference = typename std::iterator_traits::reference; }; #if __cpp_deduction_guides >= 201606L template reversed(_Tp &&) -> reversed<_Tp>; template reversed(std::initializer_list<_Tp>) -> reversed>; #endif } // namespace workspace #line 9 "Library\\src\\utils\\py-like\\range.hpp" namespace workspace { template class range { _Index __first, __last; public: class iterator { _Index __i; public: using difference_type = std::ptrdiff_t; using value_type = _Index; using pointer = void; using reference = value_type; using iterator_category = std::random_access_iterator_tag; constexpr iterator() = default; constexpr iterator(const _Index &__x) noexcept : __i(__x) {} constexpr bool operator==(const iterator &__x) const noexcept { return __i == __x.__i; } constexpr bool operator!=(const iterator &__x) const noexcept { return __i != __x.__i; } constexpr bool operator<(const iterator &__x) const noexcept { return __i < __x.__i; } constexpr bool operator<=(const iterator &__x) const noexcept { return __i <= __x.__i; } constexpr bool operator>(const iterator &__x) const noexcept { return __i > __x.__i; } constexpr bool operator>=(const iterator &__x) const noexcept { return __i >= __x.__i; } constexpr iterator &operator++() noexcept { ++__i; return *this; } constexpr iterator operator++(int) noexcept { auto __tmp = *this; ++__i; return __tmp; } constexpr iterator &operator--() noexcept { --__i; return *this; } constexpr iterator operator--(int) noexcept { auto __tmp = *this; --__i; return __tmp; } constexpr difference_type operator-(const iterator &__x) const noexcept { return __i - __x.__i; } constexpr iterator &operator+=(difference_type __x) noexcept { __i += __x; return *this; } constexpr iterator operator+(difference_type __x) const noexcept { return iterator(*this) += __x; } constexpr iterator &operator-=(difference_type __x) noexcept { __i -= __x; return *this; } constexpr iterator operator-(difference_type __x) const noexcept { return iterator(*this) -= __x; } constexpr reference operator*() const noexcept { return __i; } }; using value_type = _Index; using reference = value_type; using difference_type = std::ptrdiff_t; using size_type = std::size_t; using const_iterator = iterator; using reverse_iterator = std::reverse_iterator; using const_reverse_iterator = reverse_iterator; template constexpr range(const _Tp1 &__first, const _Tp2 &__last) noexcept : __first(__first), __last(__last) {} template constexpr range(const _Tp &__last) noexcept : __first(), __last(__last) {} constexpr iterator begin() const noexcept { return {__first}; } constexpr const_iterator cbegin() const noexcept { return begin(); } constexpr iterator end() const noexcept { return {__last}; } constexpr const_iterator cend() const noexcept { return end(); } constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); } constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } constexpr const_reverse_iterator crend() const noexcept { return rend(); } constexpr size_type size() const noexcept { return __last - __first; } }; #if __cpp_deduction_guides >= 201606L template range(const _Tp1 &, const _Tp2 &) -> range())>>; template range(const _Tp &) -> range())>>; template constexpr decltype(auto) rrange(_Args &&...__args) noexcept { return reversed(range(std::forward<_Args>(__args)...)); } #endif } // namespace workspace #line 2 "Library\\src\\utils\\py-like\\zip.hpp" /** * @file zip.hpp * @brief Zip */ #line 11 "Library\\src\\utils\\py-like\\zip.hpp" #line 2 "Library\\src\\utils\\iterator\\category.hpp" /* * @file category.hpp * @brief Iterator Category */ #line 10 "Library\\src\\utils\\iterator\\category.hpp" namespace workspace { /* * @tparam Tuple Tuple of iterator types */ template ::value - 1> struct common_iterator_category { using type = typename std::common_type< typename common_iterator_category::type, typename std::iterator_traits::type>::iterator_category>::type; }; template struct common_iterator_category { using type = typename std::iterator_traits< typename std::tuple_element<0, Tuple>::type>::iterator_category; }; } // namespace workspace #line 2 "Library\\src\\utils\\iterator\\reverse.hpp" /* * @file reverse_iterator.hpp * @brief Reverse Iterator */ #if __cplusplus >= 201703L #include #include namespace workspace { /* * @class reverse_iterator * @brief Wrapper class for `std::reverse_iterator`. * @see http://gcc.gnu.org/PR51823 */ template class reverse_iterator : public std::reverse_iterator { using base_std = std::reverse_iterator; std::optional deref; public: using base_std::reverse_iterator; constexpr typename base_std::reference operator*() noexcept { if (!deref) { Iterator tmp = base_std::current; deref = *--tmp; } return deref.value(); } constexpr reverse_iterator &operator++() noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator &operator--() noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator operator++(int) noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator operator--(int) noexcept { base_std::operator++(); deref.reset(); return *this; } }; } // namespace workspace #endif #line 15 "Library\\src\\utils\\py-like\\zip.hpp" namespace workspace { template class zipped : protected _Tuple { public: zipped(const _Tuple &__x) : _Tuple(__x) {} template constexpr decltype(auto) get() const &noexcept { return *std::get<_Nm>(*this); } template constexpr decltype(auto) get() &&noexcept { auto __tmp = *std::get<_Nm>(*this); return __tmp; } }; template class zip { std::tuple<_Containers...> __c; template constexpr decltype(auto) begin_cat() const noexcept { if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers)) { return std::tuple_cat(std::tuple(std::begin(std::get<_Nm>(__c))), begin_cat<_Nm + 1>()); } else return std::tuple<>(); } template constexpr decltype(auto) end_cat() const noexcept { if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers)) { return std::tuple_cat(std::tuple(std::end(std::get<_Nm>(__c))), end_cat<_Nm + 1>()); } else return std::tuple<>(); } using _Iterator_tuple = std::tuple()))...>; public: using size_type = std::size_t; class iterator : public zipped<_Iterator_tuple> { using _Base = zipped<_Iterator_tuple>; public: using difference_type = std::ptrdiff_t; using value_type = _Base; using pointer = void; using reference = value_type &; using iterator_category = typename common_iterator_category<_Iterator_tuple>::type; protected: template constexpr bool equal(const iterator &__x) const noexcept { if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers)) { return std::get<_Nm>(*this) == std::get<_Nm>(__x) || equal<_Nm + 1>(__x); } else return false; } template constexpr void increment() noexcept { if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers)) ++std::get<_Nm>(*this), increment<_Nm + 1>(); } template constexpr void decrement() noexcept { if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers)) --std::get<_Nm>(*this), decrement<_Nm + 1>(); } template constexpr void advance(difference_type __d) noexcept { if _CXX17_CONSTEXPR (_Nm != sizeof...(_Containers)) std::get<_Nm>(*this) += __d, advance<_Nm + 1>(__d); } public: iterator(const _Iterator_tuple &__x) : _Base(__x) {} constexpr bool operator==(const iterator &__x) const noexcept { return equal(__x); } constexpr bool operator!=(const iterator &__x) const noexcept { return !equal(__x); } constexpr iterator &operator++() noexcept { increment(); return *this; } constexpr iterator operator++(int) noexcept { auto __tmp = *this; increment(); return __tmp; } constexpr iterator &operator--() noexcept { decrement(); return *this; } constexpr iterator operator--(int) noexcept { auto __tmp = *this; decrement(); return __tmp; } constexpr bool operator<(const iterator &__x) const noexcept { return std::get<0>(*this) < std::get<0>(__x); } constexpr bool operator<=(const iterator &__x) const noexcept { return std::get<0>(*this) <= std::get<0>(__x); } constexpr bool operator>(const iterator &__x) const noexcept { return !operator<=(__x); } constexpr bool operator>=(const iterator &__x) const noexcept { return !operator>(__x); } 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 &__x) const noexcept { return std::get<0>(*this) - std::get<0>(__x); } constexpr reference operator*() noexcept { return {*this}; } }; using const_iterator = iterator; template constexpr zip(_Args &&...__args) noexcept : __c(std::forward<_Args>(__args)...) {} template constexpr zip(std::initializer_list<_Args>... __args) noexcept : __c(std::forward<_Args>(__args)...) {} constexpr iterator begin() const noexcept { return {begin_cat()}; } constexpr iterator end() const noexcept { return {end_cat()}; } constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } #if __cplusplus >= 201703L constexpr size_type size() const noexcept { size_type __n = -1; std::apply( [&__n](auto &&__x) { if (__n < __x.size()) __n = __x.size(); }, __c); return __n; } #endif }; #if __cpp_deduction_guides >= 201606L template zip(_Args &&...) -> zip<_Args...>; // For gcc version < 10 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80438 template zip(_Tp &&, _Args &&...) -> zip<_Tp, _Args...>; template zip(std::initializer_list<_Args>...) -> zip...>; #endif } // namespace workspace namespace std { template struct tuple_element<_Nm, workspace::zipped<_Tuple>> { using type = remove_reference_t< typename iterator_traits>::reference>; }; template struct tuple_size> : tuple_size<_Tuple> {}; } // namespace std #line 10 "Library\\src\\utils\\py-like\\enumerate.hpp" #if __cplusplus >= 201703L namespace workspace { namespace _enumerate_impl { constexpr size_t min_size() noexcept { return SIZE_MAX; } template constexpr size_t min_size(_Container const &__cont, _Args &&... __args) noexcept { return std::min(std::size(__cont), min_size(std::forward<_Args>(__args)...)); } } // namespace _enumerate_impl template constexpr decltype(auto) enumerate(_Args &&... __args) noexcept { return zip(range(_enumerate_impl::min_size(__args...)), std::forward<_Args>(__args)...); } template constexpr decltype(auto) enumerate( std::initializer_list<_Args> const &... __args) noexcept { return zip(range(_enumerate_impl::min_size(__args...)), std::vector(__args)...); } } // namespace workspace #endif #line 17 "Library\\lib\\utils" // #include "src/utils/py-like/zip.hpp" // #include "src/utils/rand/rng.hpp" #line 2 "Library\\src\\utils\\rand\\shuffle.hpp" /** * @file shuffle.hpp * @brief Shuffle */ #line 10 "Library\\src\\utils\\rand\\shuffle.hpp" namespace workspace { template void shuffle(_RAIter __first, _RAIter __last) { static _Engine __engine(std::random_device{}()); std::shuffle(__first, __last, __engine); } } // namespace workspace #line 2 "Library\\src\\utils\\round_div.hpp" /* * @file round_div.hpp * @brief Round Integer Division */ #line 9 "Library\\src\\utils\\round_div.hpp" #line 11 "Library\\src\\utils\\round_div.hpp" namespace workspace { /* * @fn floor_div * @brief floor of fraction. * @param x the numerator * @param y the denominator * @return maximum integer z s.t. z <= x / y * @note y must be nonzero. */ template constexpr typename std::enable_if<(is_integral_ext::value && is_integral_ext::value), typename std::common_type::type>::type floor_div(T1 x, T2 y) { assert(y != 0); if (y < 0) x = -x, y = -y; return x < 0 ? (x - y + 1) / y : x / y; } /* * @fn ceil_div * @brief ceil of fraction. * @param x the numerator * @param y the denominator * @return minimum integer z s.t. z >= x / y * @note y must be nonzero. */ template constexpr typename std::enable_if<(is_integral_ext::value && is_integral_ext::value), typename std::common_type::type>::type ceil_div(T1 x, T2 y) { assert(y != 0); if (y < 0) x = -x, y = -y; return x < 0 ? x / y : (x + y - 1) / y; } } // namespace workspace #line 21 "Library\\lib\\utils" // #include "src\utils\rand\tree.hpp" // #include "src\utils\reference_list.hpp" #line 2 "Library\\src\\utils\\io\\input.hpp" /** * @file input.hpp * @brief Input */ #line 10 "Library\\src\\utils\\io\\input.hpp" namespace workspace { template ::value> class input { _Tp __value; template struct is_convertible : std::false_type {}; template struct is_convertible<_Arg> : std::is_convertible<_Arg, _Tp> {}; public: operator _Tp &() noexcept { return __value; } operator const _Tp &() const noexcept { return __value; } template input(_Args &&...__args) noexcept : __value(std::forward<_Args>(__args)...) { if _CXX17_CONSTEXPR (not is_convertible<_Args...>::value) cin >> __value; } }; template class input<_Tp, true> : public _Tp { template struct is_convertible : std::false_type {}; template struct is_convertible<_Arg> : std::is_convertible<_Arg, _Tp> {}; public: operator _Tp &() noexcept { return *this; } operator const _Tp &() const noexcept { return *this; } template input(_Args &&...__args) noexcept : _Tp(std::forward<_Args>(__args)...) { if _CXX17_CONSTEXPR (not is_convertible<_Args...>::value) cin >> *this; } template input(std::initializer_list<_E> __l) noexcept : _Tp(__l) {} }; // Integrality. template struct is_integral_ext> : is_integral_ext<_Tp> {}; } // namespace workspace #line 2 "Library\\src\\utils\\io\\print.hpp" /** * @file print.hpp * @brief Print */ #line 9 "Library\\src\\utils\\io\\print.hpp" namespace workspace { /** * @brief Print * @tparam _Sep * @tparam _End */ template void print(_Tp &&__x, _Args &&...__args) noexcept { if _CXX17_CONSTEXPR (sizeof...(_Args)) cout << __x << _Sep, print(std::forward<_Args>(__args)...); else cout << __x << _End; } void flush() noexcept { cout << std::flush; } } // namespace workspace #line 13 "other-workspace\\tmp.cpp" signed main() { using namespace workspace; io_setup(15); /* given case_info.read(); //*/ /* unspecified case_info.total = -1; //*/ return case_info.iterate(); } namespace workspace { void main() { // start here! input N, M; input> V(N); vector zeta(1 << M); for (auto &&v : V) { auto contained = 0; for (auto i : range(M)) { if (input() == 'o') { contained ^= 1 << i; } } zeta[contained] += v; } for (auto i : range(M)) { for (auto s : range(1 << M)) { if (s >> i & 1) { zeta[s] += zeta[s ^ 1 << i]; } } } vector dp(1 << M, -10000000000000); dp.back() = 0; for (auto s : rrange(dp.size())) { for (auto i : range(M)) { if (s >> i & 1) { auto a = zeta[s] - zeta[s ^ 1 << i]; chgr(dp[s ^ 1 << i], dp[s] + a * a); } } } print(dp.front()); } } // namespace workspace /** * @note */