結果
問題 | No.1550 nullくんの町清掃 / null's Town Cleaning |
ユーザー |
![]() |
提出日時 | 2021-06-18 21:26:51 |
言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
結果 |
AC
|
実行時間 | 3 ms / 2,000 ms |
コード長 | 28,568 bytes |
コンパイル時間 | 1,022 ms |
コンパイル使用メモリ | 128,684 KB |
最終ジャッジ日時 | 2025-01-22 08:58:07 |
ジャッジサーバーID (参考情報) |
judge4 / judge4 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 3 |
other | AC * 6 |
コンパイルメッセージ
main.cpp: In member function ‘constexpr lib::static_modint<modulo> lib::static_modint<modulo>::pow(Tp) const’: main.cpp:517:72: warning: expected ‘template’ keyword before dependent template name [-Wmissing-template-keyword] 517 | if (index < 0) return static_modint<modulo>(value, true).inv().pow<true>(-index); | ^~~ | template
ソースコード
#pragma region template// clang-format off#ifdef LOCAL_NDEBUG#include <headers.hpp>#endif// #define USE_EXTERNAL_CONTAINERS// #define NO_PRINT_INF#ifdef USE_EXTERNAL_CONTAINERS#define PROPER#include <boost/container/flat_map.hpp>#include <boost/container/flat_set.hpp>#include <ext/pb_ds/assoc_container.hpp>#include <ext/pb_ds/tree_policy.hpp>template <class T> using rb_tree = __gnu_pbds::tree<T, __gnu_pbds::null_type, std::less<T>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>;template <class S, class T> using hash_table = __gnu_pbds::gp_hash_table<S, T>;#endif#ifdef LOCAL_DEBUG#if (defined USE_EXTERNAL_CONTAINERS) || (defined NO_PRINT_INF) || (defined PROPER)#include <../src/debugger.hpp>#else#include <debugger.hpp>#endif#endif// #define PROPER#if (defined __INTELLISENSE__) && (!defined PROPER)#define NDEBUGnamespace std {#endif#include <cassert>#include <cctype>#include <cmath>#include <cstddef>#include <cstdint>#include <cstdio>#include <cstdlib>#include <algorithm>#include <array>#include <bitset>#include <complex>#include <deque>#include <functional>#include <iostream>#include <iomanip>#include <iterator>#include <limits>#include <list>#include <map>#include <numeric>#include <queue>#include <regex>#include <set>#include <sstream>#include <stack>#include <string>#include <string_view>#include <tuple>#include <typeinfo>#include <type_traits>#include <utility>#include <vector>#if (defined __INTELLISENSE__) && (!defined PROPER)using namespace std;}#endif#ifdef LOCAL_DEBUG#define STR(x) #x#define STRINGIFY(x) STR(x)#define FILE_LINE "[Debug] ./" __FILE__ ":" STRINGIFY(__LINE__)#define see(...) debugger::multi_print(#__VA_ARGS__, __VA_ARGS__)#define see2(arg) arg.debug_print(#arg)#define here(...) debugger::os << FILE_LINE << " in " << __func__ << ": \e[32mReached\e[39m\n"#define com(msg) debugger::os << FILE_LINE << " in " << __func__ << ":\n \e[36mComment:\e[39m " << msg << "\n"#define err(msg) debugger::os << FILE_LINE << " in " << __func__ << ":\n \e[31mError:\e[39m " << msg << "\n"#define local(...) do { __VA_ARGS__ } while (0)#define alter(x, y) x#else#define see(...) (static_cast<void>(0))#define see2(arg) (static_cast<void>(0))#define here(...) (static_cast<void>(0))#define com(msg) (static_cast<void>(0))#define err(msg) (static_cast<void>(0))#define local(...) (static_cast<void>(0))#define alter(x, y) y#endif#if (defined LOCAL_DEBUG) && (!defined NOWARN)#define warn(msg) debugger::os << FILE_LINE << " in " << __func__ << ":\n \e[33mWarning:\e[39m " << msg << "\n"#else#define warn(msg) (static_cast<void>(0))#endif#if (defined LOCAL_DEBUG) || (defined LOCAL_NDEBUG) || (defined __INTELLISENSE__)#define NOEXCEPT#define M_assert(expr) assert(expr)#define O_assert(expr) assert(expr)#else#define NOEXCEPT noexcept#define M_assert(expr) do {if(__builtin_expect(!(expr), 0)) {auto p = static_cast<std::int64_t*>(std::malloc(1 << 30)); for (int i = 0; i < (1 << 27); p[i] = 1, i += (1 << 9)); std::cerr << (*p);}} while (0)#define O_assert(expr) do {if(__builtin_expect(!(expr), 0)) {const auto X = std::string(1000, '-'); for(int i = 0; i < (1 << 18); i++) std::cout << X;}} while (0)#endif#define as(type, val) static_cast<std::decay_t<type>>(val)#define INDIRECT(...) __VA_ARGS__#define rep(loop_var, loop_end) \for ( \auto loop_var = as(std::make_signed_t<decltype(loop_end)>, 0); \loop_var < as(decltype(loop_var), loop_end); \++loop_var \)#define rng(loop_var, loop_start, loop_end, loop_increment) \for ( \auto loop_var = as(INDIRECT(std::make_signed_t<std::common_type_t<decltype(loop_start), decltype(loop_end)>>), loop_start); \((loop_increment) > 0) ? (loop_var < as(decltype(loop_var), loop_end)) : (loop_var > as(decltype(loop_var), loop_end)); \loop_var += (loop_increment) \)#define erng(loop_var, loop_start, loop_end, loop_increment) \for ( \auto loop_var = as(INDIRECT(std::make_signed_t<std::common_type_t<decltype(loop_start), decltype(loop_end)>>), loop_start); \((loop_increment) > 0) ? (loop_var <= as(decltype(loop_var), loop_end)) : (loop_var >= as(decltype(loop_var), loop_end)); \loop_var += (loop_increment) \)[[maybe_unused]] constexpr int INF = 1000000005;[[maybe_unused]] constexpr long long LINF = 1000000000000000005LL;[[maybe_unused]] constexpr double EPS = 1e-9;[[maybe_unused]] constexpr long double LEPS = 1e-14L;[[maybe_unused]] constexpr int dy[9] = {1, 0, -1, 0, 1, 1, -1, -1, 0};[[maybe_unused]] constexpr int dx[9] = {0, 1, 0, -1, -1, 1, 1, -1, 0};template <class... Ts> constexpr auto Min(const Ts... args) { return std::min({ as(std::common_type_t<Ts...>, args) ... }); }template <class... Ts> constexpr auto Max(const Ts... args) { return std::max({ as(std::common_type_t<Ts...>, args) ... }); }// clang-format on#pragma endregion#pragma region lib_static_modint#define lib_mint 1#define lib_static_modint 1namespace lib {template <std::int32_t modulo> class static_modint {std::int32_t value;template <class Tp> static constexpr std::int32_t calc_inverse(Tp n) noexcept {Tp b = modulo, u = 1, v = 0, t;while (b > 0) {t = n / b;// std::swap is not necessarily constexpr in C++17// std::swap(n -= t * b, b);Tp tmp = std::move(n -= t * b);n = std::move(b);b = std::move(tmp);// std::swap(u -= t * v, v);tmp = std::move(u -= t * v);u = std::move(v);v = std::move(tmp);}if (u < 0) u += modulo;return static_cast<std::int32_t>(u);}template <class Tp> static constexpr std::int32_t clamp_ll(Tp v) noexcept {if (modulo <= v || v < -modulo) v %= modulo;if (v < 0) v += modulo;return static_cast<std::int32_t>(v);}constexpr void clamp_self(void) noexcept {if (0 <= value) {if (value < modulo) return;if (value < modulo * 2)value -= modulo;elsevalue -= modulo * 2;} else {if (-modulo < value)value += modulo;else if (-modulo * 2 < value)value += modulo * 2;else {value += modulo;value += modulo * 2;}}}public:using type = std::int32_t;static constexpr type mod(void) noexcept {return modulo;}// constructorconstexpr static_modint(void) noexcept : value(0) {}template <class ValueType> constexpr static_modint(const ValueType v) noexcept {if constexpr (std::is_integral_v<ValueType> && (std::numeric_limits<ValueType>::digits <= 32)) {value = v;clamp_self();} else {value = clamp_ll(v);}}constexpr static_modint(const std::int32_t v, bool) noexcept : value(v) {}// operatorconstexpr static_modint<modulo> operator+(const static_modint<modulo> rhs) const noexcept {return static_modint<modulo>(value + rhs.value);}constexpr static_modint<modulo> operator-(const static_modint<modulo> rhs) const noexcept {return static_modint<modulo>(value - rhs.value);}constexpr static_modint<modulo> operator*(const static_modint<modulo> rhs) const noexcept {return static_modint<modulo>(static_cast<std::int64_t>(value) * rhs.value);}constexpr static_modint<modulo> operator/(const static_modint<modulo> rhs) const NOEXCEPT {// O_assert(rhs.value != 0);return static_modint<modulo>(static_cast<std::int64_t>(value) * calc_inverse(rhs.value));}constexpr static_modint<modulo> operator%(const static_modint<modulo> rhs) const NOEXCEPT {warn("operator% <static_modint, static_modint> : Are you sure you want to do this?");// O_assert(rhs.value != 0);return static_modint<modulo>(value % rhs.value, true);}constexpr static_modint<modulo> operator&(const static_modint<modulo> rhs) const noexcept {warn("operator& <static_modint, static_modint> : Are you sure you want to do this?");return static_modint<modulo>(value & rhs.value, true);}constexpr static_modint<modulo> operator|(const static_modint<modulo> rhs) const noexcept {warn("operator| <static_modint, static_modint> : Are you sure you want to do this?");return static_modint<modulo>(value | rhs.value);}constexpr static_modint<modulo> operator^(const static_modint<modulo> rhs) const noexcept {warn("operator^ <static_modint, static_modint> : Are you sure you want to do this?");return static_modint<modulo>(value ^ rhs.value);}constexpr static_modint<modulo> operator<<(const static_modint<modulo> rhs) const noexcept {warn("operator<< <static_modint, static_modint> : Are you sure you want to do this?");return static_modint<modulo>(static_cast<std::int64_t>(value) << rhs.value);}constexpr static_modint<modulo> operator>>(const static_modint<modulo> rhs) const noexcept {warn("operator>> <static_modint, static_modint> : Are you sure you want to do this?");return static_modint<modulo>(value >> rhs.value, true);}constexpr static_modint<modulo>& operator+=(const static_modint<modulo> rhs) noexcept {value += rhs.value;if (value >= modulo) value -= modulo;return *this;}constexpr static_modint<modulo>& operator-=(const static_modint<modulo> rhs) noexcept {value -= rhs.value;if (value < 0) value += modulo;return *this;}constexpr static_modint<modulo>& operator*=(const static_modint<modulo> rhs) noexcept {value = clamp_ll(static_cast<std::int64_t>(value) * rhs.value);return *this;}constexpr static_modint<modulo>& operator/=(const static_modint<modulo> rhs) NOEXCEPT {// O_assert(rhs != 0);value = clamp_ll(static_cast<std::int64_t>(value) * calc_inverse(rhs.value));return *this;}constexpr static_modint<modulo>& operator%=(const static_modint<modulo> rhs) NOEXCEPT {warn("operator%= <static_modint, static_modint> : Are you sure you want to do this?");// O_assert(rhs != 0);value %= rhs.value;if (value < 0) value += modulo;return *this;}constexpr static_modint<modulo>& operator&=(const static_modint<modulo> rhs) noexcept {warn("operator&= <static_modint, static_modint> : Are you sure you want to do this?");value &= rhs.value;return *this;}constexpr static_modint<modulo>& operator|=(const static_modint<modulo> rhs) noexcept {warn("operator|= <static_modint, static_modint> : Are you sure you want to do this?");value |= rhs.value;clamp_self();return *this;}constexpr static_modint<modulo>& operator^=(const static_modint<modulo> rhs) noexcept {warn("operator^= <static_modint, static_modint> : Are you sure you want to do this?");value ^= rhs.value;clamp_self();return *this;}constexpr static_modint<modulo>& operator<<=(const static_modint<modulo> rhs) noexcept {warn("operator<<= <static_modint, static_modint> : Are you sure you want to do this?");value = clamp_ll(static_cast<std::int64_t>(value) << rhs.value);return *this;}constexpr static_modint<modulo>& operator>>=(const static_modint<modulo> rhs) noexcept {warn("operator>>= <static_modint, static_modint> : Are you sure you want to do this?");value >>= rhs.value;return *this;}template <class RhsType> constexpr static_modint<modulo> operator+(const RhsType rhs) const noexcept {return static_modint<modulo>(static_cast<std::int64_t>(value) + rhs);}template <class RhsType> constexpr static_modint<modulo> operator-(const RhsType rhs) const noexcept {return static_modint<modulo>(static_cast<std::int64_t>(value) - rhs);}template <class RhsType> constexpr static_modint<modulo> operator*(const RhsType rhs) const noexcept {return static_modint<modulo>(static_cast<std::int64_t>(value) * rhs);}template <class RhsType> constexpr static_modint<modulo> operator/(const RhsType rhs) const NOEXCEPT {// O_assert(rhs != 0);std::int64_t mul = (rhs > 0) ? calc_inverse(rhs) : -calc_inverse(-rhs);return static_modint<modulo>(mul * value);}template <class RhsType> constexpr static_modint<modulo> operator%(const RhsType rhs) const NOEXCEPT {warn("operator% <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");// O_assert(rhs != 0);return static_modint<modulo>(value % rhs, true);}template <class RhsType> constexpr static_modint<modulo> operator&(const RhsType rhs) const noexcept {warn("operator& <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");return static_modint<modulo>(value & rhs, true);}template <class RhsType> constexpr static_modint<modulo> operator|(const RhsType rhs) const noexcept {warn("operator| <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");return static_modint<modulo>(value | rhs);}template <class RhsType> constexpr static_modint<modulo> operator^(const RhsType rhs) const noexcept {warn("operator^ <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");return static_modint<modulo>(value ^ rhs);}template <class RhsType> constexpr static_modint<modulo> operator<<(const RhsType rhs) const noexcept {warn("operator<< <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");return static_modint<modulo>(static_cast<std::int64_t>(value) << rhs);}template <class RhsType> constexpr static_modint<modulo> operator>>(const RhsType rhs) const noexcept {warn("operator>> <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");return static_modint<modulo>(value >> rhs, true);}template <class RhsType> constexpr static_modint<modulo>& operator+=(const RhsType rhs) noexcept {value = clamp_ll(static_cast<std::int64_t>(value) + rhs);return *this;}template <class RhsType> constexpr static_modint<modulo>& operator-=(const RhsType rhs) noexcept {value = clamp_ll(static_cast<std::int64_t>(value) - rhs);return *this;}template <class RhsType> constexpr static_modint<modulo>& operator*=(const RhsType rhs) noexcept {value = clamp_ll(static_cast<std::int64_t>(value) * rhs);return *this;}template <class RhsType> constexpr static_modint<modulo>& operator/=(const RhsType rhs) NOEXCEPT {// O_assert(rhs != 0);std::int64_t mul = (rhs > 0) ? calc_inverse(rhs) : -calc_inverse(-rhs);value = clamp_ll(mul * value);return *this;}template <class RhsType> constexpr static_modint<modulo>& operator%=(const RhsType rhs) NOEXCEPT {warn("operator%= <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");// O_assert(rhs != 0);value %= rhs;return *this;}template <class RhsType> constexpr static_modint<modulo>& operator&=(const RhsType rhs) noexcept {warn("operator&= <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");value &= rhs;return *this;}template <class RhsType> constexpr static_modint<modulo>& operator|=(const RhsType rhs) noexcept {warn("operator|= <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");value |= rhs;clamp_self();return *this;}template <class RhsType> constexpr static_modint<modulo>& operator^=(const RhsType rhs) noexcept {warn("operator^= <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");value ^= rhs;clamp_self();return *this;}template <class RhsType> constexpr static_modint<modulo>& operator<<=(const RhsType rhs) noexcept {warn("operator<<= <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");value = clamp_ll(static_cast<std::int64_t>(value) << rhs);return *this;}template <class RhsType> constexpr static_modint<modulo>& operator>>=(const RhsType rhs) noexcept {warn("operator>>= <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");value >>= rhs;return *this;}constexpr bool operator!(void) const noexcept {warn("operator! <static_modint> : Are you sure you want to do this?");return value == 0;}constexpr static_modint<modulo> operator~(void) const noexcept {warn("operator~ <static_modint> : Are you sure you want to do this?");return static_modint<modulo>(~value);}constexpr static_modint<modulo> operator-(void) const noexcept {return static_modint<modulo>(value == 0 ? 0 : modulo - value, true);}constexpr static_modint<modulo> operator+(void) const noexcept {return *this;}constexpr static_modint<modulo>& operator++(void) noexcept {value = ((value + 1 == modulo) ? 0 : value + 1);return *this;}constexpr static_modint<modulo>& operator--(void) noexcept {value = ((value == 0) ? modulo - 1 : value - 1);return *this;}constexpr static_modint<modulo> operator++(int) noexcept {std::int32_t ret = value;++(*this);return static_modint<modulo>(ret, true);}constexpr static_modint<modulo> operator--(int) noexcept {std::int32_t ret = value;--(*this);return static_modint<modulo>(ret, true);}constexpr bool operator==(const static_modint<modulo> rhs) const noexcept {return value == rhs.value;}constexpr bool operator!=(const static_modint<modulo> rhs) const noexcept {return value != rhs.value;}constexpr bool operator<(const static_modint<modulo> rhs) const noexcept {warn("operator< <static_modint, static_modint> : Are you sure you want to do this?");return value < rhs.value;}constexpr bool operator<=(const static_modint<modulo> rhs) const noexcept {warn("operator<= <static_modint, static_modint> : Are you sure you want to do this?");return value <= rhs.value;}constexpr bool operator>(const static_modint<modulo> rhs) const noexcept {warn("operator> <static_modint, static_modint> : Are you sure you want to do this?");return value > rhs.value;}constexpr bool operator>=(const static_modint<modulo> rhs) const noexcept {warn("operator>= <static_modint, static_modint> : Are you sure you want to do this?");return value >= rhs.value;}template <class RhsType> constexpr bool operator==(const RhsType rhs) const noexcept {return value == rhs;}template <class RhsType> constexpr bool operator!=(const RhsType rhs) const noexcept {return value != rhs;}template <class RhsType> constexpr bool operator<(const RhsType rhs) const noexcept {warn("operator< <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");return value < rhs;}template <class RhsType> constexpr bool operator<=(const RhsType rhs) const noexcept {warn("operator<= <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");return value <= rhs;}template <class RhsType> constexpr bool operator>(const RhsType rhs) const noexcept {warn("operator> <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");return value > rhs;}template <class RhsType> constexpr bool operator>=(const RhsType rhs) const noexcept {warn("operator>= <static_modint, " << debugger::type_name<RhsType> << "> : Are you sure you want to do this?");return value >= rhs;}constexpr operator std::int32_t() const noexcept {return value;}friend std::istream& operator>>(std::istream& is, static_modint<modulo>& rhs) {std::int64_t tmp;is >> tmp;if (tmp < -modulo || modulo <= tmp) tmp %= modulo;if (tmp < 0) tmp += modulo;rhs.value = static_cast<std::int32_t>(tmp);return is;}friend std::ostream& operator<<(std::ostream& os, static_modint<modulo>& rhs) {return os << rhs.value;}// functionsconstexpr static_modint<modulo> inv(void) const NOEXCEPT {// O_assert(value != 0);return static_modint<modulo>(calc_inverse(value), true);}template <bool index_positive_guaranteed = true, class Tp = std::int32_t>constexpr static_modint<modulo> pow(Tp index) const noexcept {if constexpr (!index_positive_guaranteed) {// O_assert(value != 0 || index > 0);if (value == 0) return static_modint<modulo>(0, true);if (index == 0) return static_modint<modulo>(1, true);if (index < 0) return static_modint<modulo>(value, true).inv().pow<true>(-index);}static_modint<modulo> ret(1, true), base(value, true);while (index > 0) {if (index & 1) ret *= base;base *= base;index >>= 1;}return ret;}constexpr std::pair<std::int32_t, std::int32_t> to_frac(void) const noexcept {std::int32_t x = modulo - value, y = value, u = 1, v = 1;std::pair<std::int32_t, std::int32_t> ret {value, 1};std::int32_t num = value, den = 1;std::int32_t cost = num + den;while (x > 0) {if (x <= num) {std::int32_t q = num / x;num = num % x;den += q * u;if (num == 0) break;if (num + den < cost) {cost = num + den;ret.first = num;ret.second = den;}}std::int32_t q = y / x;y = y % x;v += q * u;q = x / y;x = x % y;u += q * v;}return ret;}};template <class LhsType, std::int32_t modulo>constexpr static_modint<modulo> operator+(const LhsType lhs, const static_modint<modulo> rhs) noexcept {return rhs + lhs;}template <class LhsType, std::int32_t modulo>constexpr static_modint<modulo> operator-(const LhsType lhs, const static_modint<modulo> rhs) noexcept {return -rhs + lhs;}template <class LhsType, std::int32_t modulo>constexpr static_modint<modulo> operator*(const LhsType lhs, const static_modint<modulo> rhs) noexcept {return rhs * lhs;}template <class LhsType, std::int32_t modulo>constexpr static_modint<modulo> operator/(const LhsType lhs, const static_modint<modulo> rhs) noexcept {return rhs.inv() * lhs;}template <class LhsType, std::int32_t modulo>constexpr static_modint<modulo> operator%(const LhsType lhs, const static_modint<modulo> rhs) noexcept {warn("operator% <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return static_modint<modulo>(lhs % static_cast<std::int32_t>(rhs), true);}template <class LhsType, std::int32_t modulo, std::enable_if_t<std::is_integral_v<LhsType>, std::nullptr_t> = nullptr>constexpr static_modint<modulo> operator<<(const LhsType lhs, const static_modint<modulo> rhs) noexcept {warn("operator<< <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return static_modint<modulo>(static_cast<std::int64_t>(lhs) << static_cast<std::int32_t>(rhs));}template <class LhsType, std::int32_t modulo, std::enable_if_t<std::is_integral_v<LhsType>, std::nullptr_t> = nullptr>constexpr static_modint<modulo> operator>>(const LhsType lhs, const static_modint<modulo> rhs) noexcept {warn("operator>> <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return static_modint<modulo>(lhs >> static_cast<std::int32_t>(rhs));}template <class LhsType, std::int32_t modulo>constexpr LhsType& operator+=(LhsType& lhs, const static_modint<modulo> rhs) noexcept {return lhs += static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr LhsType& operator-=(LhsType& lhs, const static_modint<modulo> rhs) noexcept {return lhs -= static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr LhsType& operator*=(LhsType& lhs, const static_modint<modulo> rhs) noexcept {return lhs *= static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr LhsType& operator/=(LhsType& lhs, const static_modint<modulo> rhs) noexcept {return lhs /= static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr LhsType& operator%=(LhsType& lhs, const static_modint<modulo> rhs) noexcept {warn("operator%= <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return lhs %= static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr LhsType& operator&=(LhsType& lhs, const static_modint<modulo> rhs) noexcept {warn("operator&= <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return lhs &= static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr LhsType& operator|=(LhsType& lhs, const static_modint<modulo> rhs) noexcept {warn("operator|= <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return lhs |= static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr LhsType& operator^=(LhsType& lhs, const static_modint<modulo> rhs) noexcept {warn("operator^= <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return lhs ^= static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr LhsType& operator<<=(LhsType& lhs, const static_modint<modulo> rhs) noexcept {warn("operator<<= <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return lhs <<= static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr LhsType& operator>>=(LhsType& lhs, const static_modint<modulo> rhs) noexcept {warn("operator>>= <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return lhs >>= static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr bool operator<(const LhsType lhs, const static_modint<modulo> rhs) noexcept {warn("operator< <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return lhs < static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr bool operator<=(const LhsType lhs, const static_modint<modulo> rhs) noexcept {warn("operator<= <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return lhs < static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr bool operator>(const LhsType lhs, const static_modint<modulo> rhs) noexcept {warn("operator> <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return lhs < static_cast<std::int32_t>(rhs);}template <class LhsType, std::int32_t modulo>constexpr bool operator>=(const LhsType lhs, const static_modint<modulo> rhs) noexcept {warn("operator>= <" << debugger::type_name<LhsType> << ", static_modint> : Are you sure you want to do this?");return lhs < static_cast<std::int32_t>(rhs);}} // namespace lib#pragma endregionusing mint = lib::static_modint<1000000007>;void solve() {mint n;std::cin >> n;std::cout << n << "\n";}int main() {std::ios_base::sync_with_stdio(false);std::cin.tie(nullptr);solve();}