結果
問題 | No.1627 三角形の成立 |
ユーザー | jell |
提出日時 | 2021-07-23 23:19:31 |
言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
結果 |
AC
|
実行時間 | 707 ms / 1,000 ms |
コード長 | 63,926 bytes |
コンパイル時間 | 5,805 ms |
コンパイル使用メモリ | 314,924 KB |
実行使用メモリ | 67,772 KB |
最終ジャッジ日時 | 2024-07-18 21:14:42 |
合計ジャッジ時間 | 12,276 ms |
ジャッジサーバーID (参考情報) |
judge4 / judge5 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 9 ms
7,680 KB |
testcase_01 | AC | 9 ms
7,680 KB |
testcase_02 | AC | 10 ms
7,680 KB |
testcase_03 | AC | 10 ms
7,808 KB |
testcase_04 | AC | 9 ms
7,808 KB |
testcase_05 | AC | 707 ms
67,772 KB |
testcase_06 | AC | 405 ms
44,920 KB |
testcase_07 | AC | 387 ms
43,328 KB |
testcase_08 | AC | 611 ms
59,328 KB |
testcase_09 | AC | 18 ms
9,456 KB |
testcase_10 | AC | 690 ms
65,340 KB |
testcase_11 | AC | 408 ms
44,016 KB |
testcase_12 | AC | 635 ms
60,220 KB |
testcase_13 | AC | 187 ms
25,588 KB |
testcase_14 | AC | 607 ms
59,584 KB |
testcase_15 | AC | 211 ms
30,468 KB |
testcase_16 | AC | 36 ms
12,004 KB |
testcase_17 | AC | 151 ms
24,692 KB |
testcase_18 | AC | 501 ms
54,320 KB |
testcase_19 | AC | 10 ms
7,680 KB |
testcase_20 | AC | 9 ms
7,680 KB |
testcase_21 | AC | 9 ms
7,808 KB |
testcase_22 | AC | 10 ms
7,680 KB |
testcase_23 | AC | 10 ms
7,808 KB |
ソースコード
#line 1 "other-workspace\\y.cc" #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 <bits/extc++.h> /** #include "lib/all" /*/ #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 <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. #endif template <class _T1, class _T2, typename = decltype(std::declval<const _T2 &>() < std::declval<const _T1 &>())> constexpr typename std::conditional<std::is_same<_T1, _T2>::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 <class _T1, class _T2, class _Compare, typename = decltype(std::declval<_Compare>()( std::declval<const _T2 &>(), std::declval<const _T1 &>()))> constexpr typename std::conditional<std::is_same<_T1, _T2>::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 <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 &>())> constexpr typename std::conditional<std::is_same<_T1, _T2>::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 <class _T1, class _T2, class _Compare, typename = decltype(std::declval<_Compare>()( std::declval<const _T1 &>(), std::declval<const _T2 &>()))> constexpr typename std::conditional<std::is_same<_T1, _T2>::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 <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); } #ifdef _GLIBCXX_BIT 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; } #endif } // namespace workspace #line 13 "other-workspace\\y.cc" // #include "lib/cxx20" #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" /** * @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<milliseconds>(end_time - internal::start_time).count(); } } // namespace workspace #line 2 "Library\\src\\sys\\ejection.hpp" /** * @file ejection.hpp * @brief Ejection */ #line 9 "Library\\src\\sys\\ejection.hpp" namespace workspace { namespace internal { struct ejection { bool exit = 0; }; } // namespace internal /** * @brief eject from a try block, throw nullptr * @param arg output */ template <class Tp> void eject(Tp const &arg) { std::cout << arg << "\n"; throw internal::ejection{}; } void exit() { throw internal::ejection{true}; } } // namespace workspace #line 2 "Library\\src\\sys\\iteration.hpp" /** * @file iteration.hpp * @brief Case Iteration */ #line 9 "Library\\src\\sys\\iteration.hpp" #line 11 "Library\\src\\sys\\iteration.hpp" namespace workspace { void main(); struct { // 1-indexed unsigned current{0}; unsigned total{1}; void read() { (std::cin >> total).ignore(); } int iterate() { static bool once = false; assert(!once); once = true; while (current++ < total) { try { main(); } catch (internal::ejection const& status) { if (status.exit) break; } } return 0; } } case_info; } // namespace workspace #line 2 "Library\\src\\utils\\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 { /** * @brief Fixed Point Combinator. */ template <class _F> class fixed_point { struct _wrapper { _F &__ref; template <class... _Args> decltype(auto) operator()(_Args &&...__args) noexcept( noexcept(__ref(*this, std::forward<_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 <class... _Args> 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\\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 #if __cplusplus < 201703L namespace std { /** * @brief Return the size of a container. * @param __cont Container. */ template <typename _Container> constexpr auto size(const _Container& __cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size()) { return __cont.size(); } /** * @brief Return the size of an array. */ template <typename _Tp, size_t _Nm> constexpr size_t size(const _Tp (&)[_Nm]) noexcept { return _Nm; } } // namespace std #endif #line 10 "Library\\src\\utils\\cached.hpp" namespace workspace { namespace _cached_impl { // Convert keys to tuple. template <class... _Args> struct as_tuple { using type = decltype(std::tuple_cat( std::declval<std::tuple<std::conditional_t< std::is_convertible<std::decay_t<_Args>, _Args>::value, std::decay_t<_Args>, _Args>>>()...)); }; // Associative array. template <class _Value, class... _Keys> struct assoc : std::integral_constant<int, !std::is_void<_Value>::value>, std::conditional_t<std::is_void<_Value>::value, std::set<typename as_tuple<_Keys...>::type>, std::map<typename as_tuple<_Keys...>::type, _Value>> { }; // Non-resursive lambda type. template <class _F, class = void> struct is_recursive : std::false_type {}; // Resursive lambda type. template <class _F> struct is_recursive< _F, std::__void_t<decltype(&_F::template operator()<fixed_point<_F> &>)>> : std::true_type {}; // Recursive ver. template <class _F> class _recursive { template <class...> struct _cache; template <class _G, class _R, class _H, class... _Args> struct _cache<_R (_G::*)(_H, _Args...)> : assoc<_R, _Args...> {}; template <class _G, class _R, class _H, class... _Args> struct _cache<_R (_G::*)(_H, _Args...) const> : assoc<_R, _Args...> {}; template <class _G, class _R, class _H, class... _Args> struct _cache<_R (_G::*)(_H, _Args...) noexcept> : assoc<_R, _Args...> {}; template <class _G, class _R, class _H, class... _Args> struct _cache<_R (_G::*)(_H, _Args...) const noexcept> : assoc<_R, _Args...> { }; public: using cache_type = _cache<decltype(&_F::template operator()<_recursive<_F> &>)>; private: _F __fn; cache_type __c; struct _wrapper { _F &__fn; cache_type &__c; template <class... _Args> 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 <class... _Args> 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 _F> class _non_recursive { template <class _T, class = void> struct _get_func { using type = _T; }; template <class _T> struct _get_func<_T, std::__void_t<decltype(&_T::operator())>> { using type = decltype(&_T::operator()); }; template <class...> struct _cache; template <class _R, class... _Args> struct _cache<_R(_Args...)> : assoc<_R, _Args...> {}; template <class _R, class... _Args> struct _cache<_R (*)(_Args...)> : assoc<_R, _Args...> {}; template <class _G, class _R, class... _Args> struct _cache<_R (_G::*)(_Args...)> : assoc<_R, _Args...> {}; template <class _G, class _R, class... _Args> struct _cache<_R (_G::*)(_Args...) const> : assoc<_R, _Args...> {}; template <class _R, class... _Args> struct _cache<_R(_Args...) noexcept> : assoc<_R, _Args...> {}; template <class _R, class... _Args> struct _cache<_R (*)(_Args...) noexcept> : assoc<_R, _Args...> {}; template <class _G, class _R, class... _Args> struct _cache<_R (_G::*)(_Args...) noexcept> : assoc<_R, _Args...> {}; template <class _G, class _R, class... _Args> struct _cache<_R (_G::*)(_Args...) const noexcept> : assoc<_R, _Args...> {}; public: using cache_type = _cache<typename _get_func<_F>::type>; private: _F __fn; cache_type __c; public: _non_recursive(_F &&__x) noexcept : __fn(__x) {} // Function call. template <class... _Args> 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 <class _F> using _cached = std::conditional_t<is_recursive<_F>::value, _recursive<_F>, _non_recursive<_F>>; } // namespace _cached_impl /** * @brief Cached caller of function */ template <class _F> 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\\src\\utils\\cat.hpp" /** * @file cat.hpp * @brief Cat */ #line 9 "Library\\src\\utils\\cat.hpp" #line 11 "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 _CXX17_CONSTEXPR (std::is_rvalue_reference<decltype(__c2)>::value) __c.insert(std::end(__c), std::make_move_iterator(std::begin(__c2)), std::make_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 #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 <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 = void> struct has_begin : std::false_type {}; template <class _Tp> struct has_begin< _Tp, std::__void_t<decltype(std::begin(std::declval<const _Tp&>()))>> : std::true_type { using type = decltype(std::begin(std::declval<const _Tp&>())); }; template <class _Tp, class = void> struct has_size : std::false_type {}; template <class _Tp> struct has_size<_Tp, std::__void_t<decltype(std::size(std::declval<_Tp>()))>> : std::true_type {}; template <class _Tp, class = void> struct has_resize : std::false_type {}; template <class _Tp> struct has_resize<_Tp, std::__void_t<decltype(std::declval<_Tp>().resize( std::declval<size_t>()))>> : 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 >= 201402 template <class _Tp> constexpr static bool is_integral_ext_v = is_integral_ext<_Tp>::value; #endif template <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; }; #endif template <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())> {}; template <class _Container, class = void> struct get_dimension { static constexpr size_t value = 0; }; template <class _Container> struct get_dimension<_Container, std::enable_if_t<has_begin<_Container>::value>> { static constexpr size_t value = 1 + get_dimension<typename std::iterator_traits< typename has_begin<_Container>::type>::value_type>::value; }; } // namespace workspace #line 7 "Library\\src\\utils\\compare.hpp" #if __cplusplus >= 201703L 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 #endif #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 >= 201703L template <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); } }; #endif template <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 7 "Library\\lib\\utils" // #include "src/utils/io/istream.hpp" // #include "src/utils/io/ostream.hpp" // #include "src/utils/io/read.hpp" // #include "src/utils/grid/motion.hpp" #line 2 "Library\\src\\utils\\io\\setup.hpp" /** * @file setup.hpp * @brief I/O Setup */ #line 10 "Library\\src\\utils\\io\\setup.hpp" namespace workspace { /** * @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 12 "Library\\lib\\utils" // #include "src/utils/iterator/category.hpp" // #include "src/utils/iterator/reverse.hpp" // #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\\iterator\\reverse.hpp" /* * @file reverse_iterator.hpp * @brief Reverse Iterator */ #if __cplusplus >= 201703L #include <iterator> #include <optional> namespace workspace { /* * @class reverse_iterator * @brief Wrapper class for `std::reverse_iterator`. * @see http://gcc.gnu.org/PR51823 */ template <class Iterator> class reverse_iterator : public std::reverse_iterator<Iterator> { using base_std = std::reverse_iterator<Iterator>; std::optional<typename base_std::value_type> deref; public: using base_std::reverse_iterator; constexpr typename base_std::reference operator*() noexcept { if (!deref) { Iterator tmp = base_std::current; deref = *--tmp; } return deref.value(); } constexpr reverse_iterator &operator++() noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator &operator--() noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator operator++(int) noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator operator--(int) noexcept { base_std::operator++(); deref.reset(); return *this; } }; } // namespace workspace #endif #line 2 "Library\\src\\utils\\py-like\\reversed.hpp" /** * @file reversed.hpp * @brief Reversed */ #include <initializer_list> #line 10 "Library\\src\\utils\\py-like\\reversed.hpp" namespace workspace { namespace _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 #if __cplusplus < 201703L __cont.size(); #else std::size(__cont); #endif } }; } // namespace _reversed_impl template <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 >= 201703L namespace workspace { template <class _Index> class range { _Index __first, __last; public: class iterator { _Index current; public: using difference_type = std::ptrdiff_t; using value_type = _Index; using reference = typename std::add_const<_Index>::type &; using pointer = iterator; using iterator_category = std::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; } }; template <class _Tp1, class _Tp2> constexpr range(const _Tp1 &__first, const _Tp2 &__last) noexcept : __first(__first), __last(__last) {} template <class _Tp> constexpr range(const _Tp &__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 _Tp1, class _Tp2> range(const _Tp1 &, const _Tp2 &) -> range<std::decay_t<decltype(++std::declval<_Tp1 &>())>>; template <class _Tp> range(const _Tp &) -> range<std::decay_t<decltype(++std::declval<_Tp &>())>>; 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 17 "Library\\lib\\utils" // #include "src/utils/py-like/reversed.hpp" #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 <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 15 "Library\\src\\utils\\py-like\\zip.hpp" #if __cplusplus >= 201703L namespace workspace { namespace internal { template <class> struct zipped_iterator; template <class...> struct zipped_iterator_tuple; template <class... Args> class zipped { using ref_tuple = std::tuple<Args...>; ref_tuple args; template <size_t N = 0> constexpr decltype(auto) begin_cat() const noexcept { if _CXX17_CONSTEXPR (N != std::tuple_size<ref_tuple>::value) { return std::tuple_cat(std::tuple(std::begin(std::get<N>(args))), begin_cat<N + 1>()); } else return std::tuple<>(); } template <size_t N = 0> constexpr decltype(auto) end_cat() const noexcept { if _CXX17_CONSTEXPR (N != std::tuple_size<ref_tuple>::value) { return std::tuple_cat(std::tuple(std::end(std::get<N>(args))), end_cat<N + 1>()); } else return std::tuple<>(); } public: constexpr zipped(Args &&...args) noexcept : args(args...) {} class iterator { using base_tuple = typename zipped_iterator_tuple<Args...>::type; public: using iterator_category = typename common_iterator_category<base_tuple>::type; using difference_type = std::ptrdiff_t; using value_type = zipped_iterator<base_tuple>; using reference = zipped_iterator<base_tuple> &; using pointer = iterator; protected: value_type current; template <size_t N = 0> constexpr bool equal(const iterator &rhs) const noexcept { if _CXX17_CONSTEXPR (N != std::tuple_size<base_tuple>::value) { return std::get<N>(current) == std::get<N>(rhs.current) || equal<N + 1>(rhs); } else return false; } template <size_t N = 0> constexpr void increment() noexcept { if _CXX17_CONSTEXPR (N != std::tuple_size<base_tuple>::value) { ++std::get<N>(current); increment<N + 1>(); } } template <size_t N = 0> constexpr void decrement() noexcept { if _CXX17_CONSTEXPR (N != std::tuple_size<base_tuple>::value) { --std::get<N>(current); decrement<N + 1>(); } } template <size_t N = 0> constexpr void advance(difference_type __d) noexcept { if _CXX17_CONSTEXPR (N != std::tuple_size<base_tuple>::value) { std::get<N>(current) += __d; advance<N + 1>(__d); } } public: constexpr iterator() noexcept = default; constexpr iterator(base_tuple const ¤t) noexcept : current(current) {} constexpr bool operator==(const iterator &rhs) const noexcept { return equal(rhs); } constexpr bool operator!=(const iterator &rhs) const noexcept { return !equal(rhs); } constexpr iterator &operator++() noexcept { increment(); return *this; } constexpr iterator &operator--() noexcept { decrement(); return *this; } constexpr bool operator<(const iterator &rhs) const noexcept { return std::get<0>(current) < std::get<0>(rhs.current); } constexpr bool operator<=(const iterator &rhs) const noexcept { return std::get<0>(current) <= std::get<0>(rhs.current); } constexpr iterator &operator+=(difference_type __d) noexcept { advance(__d); return *this; } constexpr iterator &operator-=(difference_type __d) noexcept { advance(-__d); return *this; } constexpr iterator operator+(difference_type __d) const noexcept { return iterator{*this} += __d; } constexpr iterator operator-(difference_type __d) const noexcept { return iterator{*this} -= __d; } constexpr difference_type operator-(const iterator &rhs) const noexcept { return std::get<0>(current) - std::get<0>(rhs.current); } constexpr reference operator*() noexcept { return current; } }; constexpr iterator begin() const noexcept { return iterator{begin_cat()}; } constexpr iterator end() const noexcept { return iterator{end_cat()}; } constexpr reverse_iterator<iterator> rbegin() const noexcept { return reverse_iterator<iterator>{end()}; } constexpr reverse_iterator<iterator> rend() const noexcept { return reverse_iterator<iterator>{begin()}; } }; template <class Tp, class... Args> struct zipped_iterator_tuple<Tp, Args...> { using type = decltype(std::tuple_cat( std::declval<std::tuple<decltype(std::begin(std::declval<Tp>()))>>(), std::declval<typename zipped_iterator_tuple<Args...>::type>())); }; template <> struct zipped_iterator_tuple<> { using type = std::tuple<>; }; template <class Iter_tuple> struct zipped_iterator : Iter_tuple { constexpr zipped_iterator(Iter_tuple const &__t) noexcept : Iter_tuple::tuple(__t) {} constexpr zipped_iterator(zipped_iterator const &__t) = default; constexpr zipped_iterator &operator=(zipped_iterator const &__t) = default; // Avoid move initialization. constexpr zipped_iterator(zipped_iterator &&__t) : zipped_iterator(static_cast<zipped_iterator const &>(__t)) {} // Avoid move assignment. zipped_iterator &operator=(zipped_iterator &&__t) { return operator=(static_cast<zipped_iterator const &>(__t)); } template <size_t N> friend constexpr decltype(auto) get( zipped_iterator<Iter_tuple> const &__z) noexcept { return *std::get<N>(__z); } template <size_t N> friend constexpr decltype(auto) get( zipped_iterator<Iter_tuple> &&__z) noexcept { return *std::get<N>(__z); } }; } // namespace internal } // namespace workspace namespace std { template <size_t N, class Iter_tuple> struct tuple_element<N, workspace::internal::zipped_iterator<Iter_tuple>> { using type = typename remove_reference<typename iterator_traits< typename tuple_element<N, Iter_tuple>::type>::reference>::type; }; template <class Iter_tuple> struct tuple_size<workspace::internal::zipped_iterator<Iter_tuple>> : tuple_size<Iter_tuple> {}; } // namespace std namespace workspace { template <class... Args> constexpr decltype(auto) zip(Args &&...args) noexcept { return internal::zipped<Args...>(std::forward<Args>(args)...); } template <class... Args> constexpr decltype(auto) zip( std::initializer_list<Args> const &...args) noexcept { return internal::zipped<const std::initializer_list<Args>...>(args...); } } // namespace workspace #endif #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\\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>::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 <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>::type ceil_div(T1 x, T2 y) { assert(y != 0); if (y < 0) x = -x, y = -y; return x < 0 ? x / y : (x + y - 1) / y; } } // namespace workspace #line 22 "Library\\lib\\utils" // #include "src\utils\rand\tree.hpp" // #include "src\utils\reference_list.hpp" #line 2 "Library\\src\\utils\\io\\input.hpp" /** * @file input.hpp * @brief Input */ #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 16 "Library\\src\\utils\\io\\istream.hpp" namespace workspace { namespace _istream_impl { template <class _Tp, typename = void> struct helper { helper(std::istream &__is, _Tp &__x) { if _CXX17_CONSTEXPR (has_begin<_Tp &>::value) for (auto &&__e : __x) helper<std::decay_t<decltype(__e)>>(__is, __e); else static_assert(has_begin<_Tp>::value, "istream unsupported type."); } }; template <class _Tp> struct helper<_Tp, std::__void_t<decltype(std::declval<std::istream &>() >> 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 <class _T1, class _T2> struct helper<std::pair<_T1, _T2>> { helper(std::istream &__is, std::pair<_T1, _T2> &__x) { helper<_T1>(__is, __x.first), helper<_T2>(__is, __x.second); } }; template <class... _Tp> struct helper<std::tuple<_Tp...>> { helper(std::istream &__is, std::tuple<_Tp...> &__x) { iterate(__is, __x); } private: template <class _Tuple, size_t _Nm = 0> void iterate(std::istream &__is, _Tuple &__x) { if _CXX17_CONSTEXPR (_Nm != std::tuple_size<_Tuple>::value) { helper<typename std::tuple_element<_Nm, _Tuple>::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 <typename _Tp> 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<istream &>(std::cin); } // namespace workspace #line 10 "Library\\src\\utils\\io\\input.hpp" namespace workspace { namespace _input_impl { template <class _Tp, bool _Is_class = false> class input { _Tp __value; template <class _Arg, class... _Args> struct is_same : std::false_type {}; template <class _Arg> struct is_same<_Arg, _Arg> : std::true_type {}; public: operator _Tp &() noexcept { return __value; } operator const _Tp &() const noexcept { return __value; } template <class... _Args> input(_Args &&...__args) noexcept : __value(std::forward<_Args>(__args)...) { if _CXX17_CONSTEXPR (!is_same<decltype(*this), _Args...>::value && !is_same<_Tp, _Args...>::value) cin >> __value; } input &operator=(const _Tp &__x) noexcept { return __value = __x, *this; } }; template <class _Tp> class input<_Tp, true> : public _Tp { template <class _Arg, class... _Args> struct is_same : std::false_type {}; template <class _Arg> struct is_same<_Arg, _Arg> : std::true_type {}; public: operator _Tp &() noexcept { return *this; } operator const _Tp &() const noexcept { return *this; } template <class... _Args> input(_Args &&...__args) noexcept : _Tp(std::forward<_Args>(__args)...) { if _CXX17_CONSTEXPR (!is_same<decltype(*this), _Args...>::value && !is_same<_Tp, _Args...>::value) cin >> *this; } input &operator=(const _Tp &__x) noexcept { _Tp::operator=(__x); return *this; } }; } // namespace _input_impl // Standard input. template <class _Tp = int_least64_t> class input : public _input_impl::input<_Tp, std::is_class<_Tp>::value> { public: using _input_impl::input<_Tp, std::is_class<_Tp>::value>::input; }; // Integrality. template <class _Tp> struct is_integral_ext<input<_Tp>> : is_integral_ext<_Tp> {}; } // namespace workspace #line 16 "other-workspace\\y.cc" //*/ signed main() { using namespace workspace; io_setup(15); /* given case_info.read(); //*/ /* unspecified case_info.total = -1; //*/ return case_info.iterate(); } #line 2 "Library\\src\\algebra\\modint.hpp" /** * @file modint.hpp * * @brief Modular Arithmetic */ #line 12 "Library\\src\\algebra\\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\\algebra\\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; // Modulus static mod_type mod; static unsigned storage; private: value_type value = 0; struct direct_ctor_t {}; constexpr static direct_ctor_t direct_ctor_tag{}; // Direct constructor template <class _Tp> constexpr modint(_Tp __n, direct_ctor_t) noexcept : value(__n) {} public: constexpr modint() noexcept = default; template <class _Tp, class = std::enable_if_t< std::is_convertible<_Tp, value_type>::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 __x) noexcept { __x %= mod, value += __x; if (value < 0) value += mod; else if (value >= mod) 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 { __x %= mod, value -= __x; if (value < 0) value += mod; else if (value >= mod) 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: static void reserve(unsigned __n) noexcept { if (storage < __n) storage = __n; } // 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{mod != 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{mod != 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}; } 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_impl template <auto _Mod, unsigned _Storage = 0, typename = std::enable_if_t<(_Mod > 0)>> using modint = _modint_impl::modint<_Mod, _Storage>; template <unsigned _Id = 0, unsigned _Storage = 0> using runtime_modint = _modint_impl::modint<-(signed)_Id, 0>; template <unsigned _Id = 0, unsigned _Storage = 0> using runtime_modint64 = _modint_impl::modint<-(int_least64_t)_Id, 0>; } // namespace workspace #line 2 "Library\\src\\number_theory\\least_factor.hpp" /** * @file least_factor.hpp * @brief Least Prime Factor */ #line 10 "Library\\src\\number_theory\\least_factor.hpp" #line 12 "Library\\src\\number_theory\\least_factor.hpp" namespace workspace { /** * @brief Calculate the least prime factor for positive integers. * * @tparam N Range of calculation, exclusive */ template <unsigned N> class least_factor { unsigned least[N], prime[N >> 1], n; public: least_factor() : least{}, prime{}, n{} { for (auto i = 2u; i < N; ++i) { if (!least[i]) prime[n++] = least[i] = i; for (auto *p = prime; *p && *p <= least[i] && *p * i < N; ++p) { least[*p * i] = *p; } } } /** * @param x An integer with 0 < |x| < N * @return Least prime factor of x */ template <typename int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, int_type>::type operator()(int_type x) const { assert(x); if (x < 0) x = -x; assert((unsigned)x < N); return least[x]; } /** * @brief Factorize * * @param x An integer with 0 < |x| < N * @return Prime factors in ascending order. */ template <typename int_type> constexpr typename std::enable_if<is_integral_ext<int_type>::value, std::vector<int_type>>::type factorize(int_type x) const { assert(x); if (x < 0) x = -x; assert((unsigned)x < N); std::vector<int_type> __p; while (x != 1) { __p.emplace_back(least[x]); x /= least[x]; } return __p; } /** * @return Sorted list of prime numbers less than N */ const std::vector<unsigned> &primes() const { static const std::vector<unsigned> prime_vector(prime, prime + n); return prime_vector; } }; } // namespace workspace #line 34 "other-workspace\\y.cc" namespace workspace { using mint = modint<1000000007>; constexpr int max_val = 200100; least_factor<max_val> lpf; void main() { // start here! array<i64, max_val> a, b; for (auto m : range(2, a.size())) { auto &d = a[m]; auto &e = b[m]; auto p = lpf(m); d = 1; while (m % p == 0) d *= p, m /= p; e = m; } unordered_map<u64, mint> memo_f; unordered_map<u64, mint> memo_g; fixed_point f = [&](auto f, i64 n, int m) -> mint { if (m == 1) return n; if (memo_f.count(n << 32 | m)) return memo_f[n << 32 | m]; auto p = lpf(m); auto s1 = f(n, m / p); auto s2 = f(n / a[m], b[m]); return memo_f[n << 32 | m] = s1 + s2 * (p - 1) * (a[m] / p); }; fixed_point g = [&](auto g, i64 n, int m) -> mint { if (m == 1) return n * (n + 1) / 2; if (memo_g.count(n << 32 | m)) return memo_g[n << 32 | m]; auto p = lpf(m); auto s1 = g(n, m / p); auto s2 = g(n / a[m], b[m]) * a[m]; return memo_g[n << 32 | m] = s1 + s2 * (p - 1) * (a[m] / p); }; #ifdef _LOCAL // debug f, g for (auto x : range(1, 10)) { for (auto y : range(1, 10)) { auto my = f(x, y); mint cor = 0; for (auto i : range(1, x + 1)) { cor += std::gcd(i, y); } assert(cor == my); my = g(x, y); cor = 0; for (auto i : range(1, x + 1)) { cor += std::gcd(i, y) * i; } assert(cor == my); } } #endif const input N, M; auto now = mint((int)N) * (N - 1) * (N - 2) / 6; mint answer = N * M; answer = answer * (answer - 1) * (answer - 2) / 6; answer -= now; for (auto m : range(1, M)) { now += N * 2 * f(N - 1, m); now -= 2 * g(N - 1, m); now -= N * N; now += N * m; answer -= now; } cout << answer << "\n"; } } // namespace workspace