#ifdef __LOCAL #include <mytemplate.hpp> // プリコンパイル済みヘッダ ~/local/include/mytemplate.hpp.gch #else #include <algorithm> #include <array> #include <bitset> #include <cassert> #include <climits> #include <cmath> #include <deque> #include <functional> #include <iomanip> #include <iostream> #include <iterator> #include <list> #include <map> #include <memory> #include <numeric> #include <optional> #include <queue> #include <random> #include <set> #include <stack> #include <string> #include <unordered_map> #include <unordered_set> #include <utility> #include <vector> #endif using namespace std; // #pragma GCC target "no-avx" // gcc12.2のバグ回避用。boost使用時はコメントアウトの事 #include <boost/multiprecision/cpp_int.hpp> using bint = boost::multiprecision::cpp_int; using ll = long long; using vl = vector<ll>; using vvl = vector<vl>; using vb = vector<bool>; using vvb = vector<vb>; using vd = vector<double>; using vvd = vector<vd>; using vc = vector<char>; using vvc = vector<vc>; using pll = pair<ll, ll>; template <class T> using min_priority_queue = priority_queue<T, vector<T>, greater<T>>; #define REP1(i, n) REP3(i, 0, n, 1) #define REP2(i, s, n) REP3(i, s, n, 1) #define REP3(i, s, n, d) for (ll i = (ll)(s); i < (ll)(n); i += (d)) #define REP_OVERLOAD(e1, e2, e3, e4, NAME, ...) NAME #define rep(...) REP_OVERLOAD(__VA_ARGS__, REP3, REP2, REP1)(__VA_ARGS__) #define DEP1(i, n) DEP3(i, n, -1, 1) #define DEP2(i, n, s) DEP3(i, n, s, 1) #define DEP3(i, n, s, d) for (ll i = (ll)(n); (ll)(s) < i; i -= (d)) #define DEP_OVERLOAD(e1, e2, e3, e4, NAME, ...) NAME #define dep(...) DEP_OVERLOAD(__VA_ARGS__, DEP3, DEP2, DEP1)(__VA_ARGS__) #define fore(e, a) for (auto&& e : (a)) #define len(a) (ll)(a).size() #define all(a) (a).begin(), (a).end() #define rall(a) (a).rbegin(), (a).rend() #define pb push_back #define eb emplace_back #define fi first #define se second #define th third #define fo fourth /********* C O N S T A N T **********/ constexpr ll INF = LONG_LONG_MAX / 2 - 10000LL; // 4,611,686,018,427,377,903 ~= 4.6e+18, 19桁 const double PI = acos(-1); /********* 1 2 8 b i t 整 数 **********/ using int128 = __int128_t; istream& operator>>(istream& stream, int128& val); ostream& operator<<(ostream& stream, const int128& val_); /********* P A I R **********/ // 単項演算子(+ -) template <class T, class U> pair<T, U> operator+(pair<T, U> a); template <class T, class U> pair<T, U> operator-(pair<T, U> a); // 複合代入演算子 template <class T, class U> pair<T, U>& operator+=(pair<T, U>& a, const pair<T, U> b); template <class T, class U> pair<T, U>& operator-=(pair<T, U>& a, const pair<T, U> b); template <class T, class U> pair<T, U>& operator*=(pair<T, U>& a, const pair<T, U> b); template <class T, class U> pair<T, U>& operator/=(pair<T, U>& a, const pair<T, U> b); template <class T, class U> pair<T, U>& operator%=(pair<T, U>& a, const pair<T, U> b); template <class T, class U, class V> pair<T, U>& operator+=(pair<T, U>& a, const V b); template <class T, class U, class V> pair<T, U>& operator-=(pair<T, U>& a, const V b); template <class T, class U, class V> pair<T, U>& operator*=(pair<T, U>& a, const V b); template <class T, class U, class V> pair<T, U>& operator/=(pair<T, U>& a, const V b); template <class T, class U, class V> pair<T, U>& operator%=(pair<T, U>& a, const V b); // 算術演算子 template <class T, class U, class V> pair<T, U> operator+(pair<T, U> a, const V& b); template <class T, class U, class V> pair<T, U> operator-(pair<T, U> a, const V& b); template <class T, class U, class V> pair<T, U> operator*(pair<T, U> a, const V& b); template <class T, class U, class V> pair<T, U> operator/(pair<T, U> a, const V& b); template <class T, class U, class V> pair<T, U> operator%(pair<T, U> a, const V& b); // 入出力 template <class T, class U> istream& operator>>(istream& stream, pair<T, U>& a); template <class T, class U> ostream& operator<<(ostream& stream, const pair<T, U>& a); /********* V E C T O R **********/ // 単項演算子(+ -) template <class T> vector<T> operator+(vector<T> a); template <class T> vector<T> operator-(vector<T> a); // 複合代入演算子 template <class T> vector<T>& operator+=(vector<T>& a, const vector<T> b); template <class T> vector<T>& operator-=(vector<T>& a, const vector<T> b); template <class T> vector<T>& operator*=(vector<T>& a, const vector<T> b); template <class T> vector<T>& operator/=(vector<T>& a, const vector<T> b); template <class T> vector<T>& operator%=(vector<T>& a, const vector<T> b); template <class T, class U> vector<T>& operator+=(vector<T>& a, const U b); template <class T, class U> vector<T>& operator-=(vector<T>& a, const U b); template <class T, class U> vector<T>& operator*=(vector<T>& a, const U b); template <class T, class U> vector<T>& operator/=(vector<T>& a, const U b); template <class T, class U> vector<T>& operator%=(vector<T>& a, const U b); // 算術演算子 template <class T, class U> vector<T> operator+(vector<T> a, const U& b); template <class T, class U> vector<T> operator-(vector<T> a, const U& b); template <class T, class U> vector<T> operator*(vector<T> a, const U& b); template <class T, class U> vector<T> operator/(vector<T> a, const U& b); template <class T, class U> vector<T> operator%(vector<T> a, const U& b); // 入出力 template <class T> istream& operator>>(istream& stream, vector<T>& a); template <class T> ostream& operator<<(ostream& stream, const vector<T>& v); template <class T> ostream& operator<<(ostream& stream, const vector<vector<T>>& vv); // 計算 template <class T> T Sum(const vector<T>& v); template <class T> T Max(const vector<T>& v); template <class T> T Min(const vector<T>& v); template <class T> ll Argmax(const vector<T>& v); template <class T> ll Argmin(const vector<T>& v); template <class T, class U> bool Contains(const vector<T>& v, const U& a); template <class T> void Unique(vector<T>& v); // 生成 template <class T, class U> vector<T> make_vector(int n, U v); template <class T, class... Args> auto make_vector(int n, Args... args) { auto val = make_vector<T>(args...); return make_vector<decltype(val)>(n, move(val)); } /********* S E T **********/ template <class T> istream& operator>>(istream& stream, set<T>& st); template <class T> ostream& operator<<(ostream& stream, const set<T>& st); template <class T> T Max(const set<T>& st); template <class T> T Min(const set<T>& st); /********* M U L T I S E T **********/ template <class T> istream& operator>>(istream& stream, multiset<T>& st); template <class T> ostream& operator<<(ostream& stream, const multiset<T>& st); template <class T> T Max(const multiset<T>& st); template <class T> T Min(const multiset<T>& st); template <class T> bool EraseOne(multiset<T>& st, const T& x); /********* C H A R **********/ bool IsUpper(const char& c); bool IsLower(const char& c); char ToUpper(const char& c); char ToLower(const char& c); /********* S T R I N G **********/ string ToUpper(const string& s); string ToLower(const string& s); bool IsPalindrome(const string& S); /********* T R I O **********/ template <class T1, class T2, class T3> struct trio { T1 first; T2 second; T3 third; // コンストラクタ・代入演算子 trio(); trio(const T1& x); trio(const T1& x, const T2& y, const T3& z); trio(const trio& t); trio& operator=(const trio& t); // 比較演算子 bool operator<(const trio& t) const; bool operator==(const trio& t) const; bool operator!=(const trio& t) const; bool operator>(const trio& t) const; bool operator<=(const trio& t) const; bool operator>=(const trio& t) const; // 単項演算子(+ -) trio operator+() const; trio operator-() const; // 入出力 template <class U1, class U2, class U3> friend istream& operator>>(istream&, trio<U1, U2, U3>&); template <class U1, class U2, class U3> friend ostream& operator<<(ostream&, const trio<U1, U2, U3>&); // `tie(a, b, c) = tll{3, 5, 7}`をするのに必要(コンパイラが警告?を出すのでここで定義) operator tuple<T1&, T2&, T3&>() { return tie(first, second, third); } }; // 複合代入演算子 template <class T1, class T2, class T3> trio<T1, T2, T3>& operator+=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b); template <class T1, class T2, class T3> trio<T1, T2, T3>& operator-=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b); template <class T1, class T2, class T3> trio<T1, T2, T3>& operator*=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b); template <class T1, class T2, class T3> trio<T1, T2, T3>& operator/=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b); template <class T1, class T2, class T3> trio<T1, T2, T3>& operator%=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b); template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator+=(trio<T1, T2, T3>& a, const U b); template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator-=(trio<T1, T2, T3>& a, const U b); template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator*=(trio<T1, T2, T3>& a, const U b); template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator/=(trio<T1, T2, T3>& a, const U b); template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator%=(trio<T1, T2, T3>& a, const U b); // 算術演算子 template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator+(trio<T1, T2, T3> a, const U& b); template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator-(trio<T1, T2, T3> a, const U& b); template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator*(trio<T1, T2, T3> a, const U& b); template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator/(trio<T1, T2, T3> a, const U& b); template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator%(trio<T1, T2, T3> a, const U& b); using tll = trio<ll, ll, ll>; /********* Q U A R T E T **********/ template <class T1, class T2, class T3, class T4> struct quartet { T1 first; T2 second; T3 third; T4 fourth; // コンストラクタ・代入演算子 quartet(); quartet(const T1& x); quartet(const T1& x, const T2& y, const T3& z, const T4& w); quartet(const quartet& t); quartet& operator=(const quartet& t); // 比較演算子 bool operator<(const quartet& t) const; bool operator==(const quartet& t) const; bool operator!=(const quartet& other) const; bool operator>(const quartet& other) const; bool operator<=(const quartet& other) const; bool operator>=(const quartet& other) const; // 単項演算子(+ -) quartet operator+() const; quartet operator-() const; // 入出力 template <class U1, class U2, class U3, class U4> friend istream& operator>>(istream&, quartet<U1, U2, U3, U4>&); template <class U1, class U2, class U3, class U4> friend ostream& operator<<(ostream&, const quartet<U1, U2, U3, U4>&); // `tie(a, b, c, d) = qll{3, 5, 7, 9}`をするのに必要(コンパイラが警告?を出すのでここで定義) operator tuple<T1&, T2&, T3&, T4&>() { return tie(first, second, third, fourth); } }; // 複合代入演算子 template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>& operator+=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b); template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>& operator-=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b); template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>& operator*=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b); template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>& operator/=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b); template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>& operator%=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b); template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4>& operator+=(quartet<T1, T2, T3, T4>& a, const U b); template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4>& operator-=(quartet<T1, T2, T3, T4>& a, const U b); template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4>& operator*=(quartet<T1, T2, T3, T4>& a, const U b); template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4>& operator/=(quartet<T1, T2, T3, T4>& a, const U b); template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4>& operator%=(quartet<T1, T2, T3, T4>& a, const U b); // 算術演算子 template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4> operator+(quartet<T1, T2, T3, T4> a, const U& b); template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4> operator-(quartet<T1, T2, T3, T4> a, const U& b); template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4> operator*(quartet<T1, T2, T3, T4> a, const U& b); template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4> operator/(quartet<T1, T2, T3, T4> a, const U& b); template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4> operator%(quartet<T1, T2, T3, T4> a, const U& b); using qll = quartet<ll, ll, ll, ll>; /********* R A N D O M **********/ struct Random { mt19937_64 rnd; Random(); Random(ll seed); ll randint(ll a, ll b); double randreal(double a, double b); char randchar(char a, char b); template <class T> void shuffle(vector<T>& vec); }; /********* T I M E R **********/ struct Timer { int time_limit; int start_time; Timer(double time_limit_sec); bool is_time_up() const; double get_elapsed_ratio() const; }; /********* P R I N T **********/ template <class T> void print(const T& e); template <class H, class... T> void print(const H& h, const T&... t); template <class... T> void End(const T&... t); /********* D E B U G **********/ #ifdef __LOCAL #define debug(...) \ if (DEBUG) do { \ cout << '[' << #__VA_ARGS__ << "] "; \ debug_(__VA_ARGS__); \ } while (0) #else #define debug(...) #endif void dbg_(const long long& e); template <class T> void dbg_(const T& e); template <class T, class U> void dbg_(const pair<T, U>& p); template <class T1, class T2, class T3> void dbg_(const trio<T1, T2, T3>& t); template <class T1, class T2, class T3, class T4> void dbg_(const quartet<T1, T2, T3, T4>& t); template <class T> void debug_(const T& e); template <class T> void debug_(const vector<T>& v); template <class T> void debug_(const vector<vector<T>>& vv); template <class T, class U> void debug_(const map<T, U>& mp); template <class T, class U> void debug_(const vector<map<T, U>>& vm); template <class T> void debug_(const set<T>& st); template <class T> void debug_(const multiset<T>& st); template <class T> void debug_(const vector<set<T>>& vs); template <class T> void debug_(const vector<multiset<T>>& vs); template <class H, class... T> void debug_(const H& h, const T&... t); /********* O T H E R S **********/ template <class T, class U> bool chmin(T& a, U b); template <class T, class U> bool chmax(T& a, U b); template <class T, class U> T Mod(const T& a, const U& m); template <class T, class U> T Ceil(const T& x, const U& y); template <class T, class U> T Floor(const T& x, const U& y); template <class T> ll Sign(const T& x); ll Isqrt(ll n); ll Comb(ll n, ll r); template <class T> T Pow(T x, ll n); template <class T> T Aseries(T a, T d, ll n); template <class T> T Gseries(T a, T r, ll n); bool Bit(ll b, int i); ll Popcount(ll b); ll Mask(ll n); ll Mask(ll n, ll m); pll GetOverlap(ll l1, ll r1, ll l2, ll r2); bool IsOverlap(ll l1, ll r1, ll l2, ll r2); void PrintYesNo(bool b); /********* M O D **********/ // #include <atcoder/modint> // https://atcoder.github.io/ac-library/production/document_ja/ // using namespace atcoder; // using mint = modint998244353; // modint1000000007; // istream& operator >>(istream& stream, mint& e) {ll n; stream >> n; e = n; return stream; } // ostream& operator <<(ostream& stream, const mint& e) { stream << e.val(); return stream; } // using vm = vector<mint>; // using vvm = vector<vm>; /***************************************/ constexpr bool DEBUG = true; // 分数構造体 // 利用可能演算子:+ - * / == != < > <= >= // 利用可能関数:sq(), inv(), abs(), val() // 特殊な値: 0: 0/1, +inf: 1/0, -inf: -1/0 // Examples: // Rational<ll> r(-6, 20); // -6/20 = -3/10 // Rational<ll> s(4, 30); // 4/30 = 2/15 // cout << ((r + s) * 2 / 3) << endl; // (-3/10 + 2/15) * 2 / 3 = -1/9 // cout << s.val() << endl; // 2/15 = 0.1333333333 template<class T> struct Rational { private: T num, den; // 分子, 分母 public: T get_num() { return num; } T get_den() { return den; } // コンストラクタ Rational() { num = 0; den = 1; } Rational(const T& num_) { num = num_; den = 1; } Rational(const Rational& r) {num = r.num; den = r.den; } // コピーコンストラクタ Rational(const T& num_, const T& den_) { assert(num_ != 0 || den_ != 0); if (num_ == 0) { num = 0; den = 1; } else { // 分母 >= 0にする & 約分する. // 等号での比較のため約分(値を一意にする)は必要. T sign = den_ < 0 ? -1 : 1; T g = gcd(num_, den_); num = sign * num_ / g; den = sign * den_ / g; } } // 代入演算子 Rational& operator =(const Rational& other) { num = other.num; den = other.den; return *this; } // 比較演算子(== != < > <= >=) bool operator <(const Rational& other) const { if (*this == other) { // 両辺が(+/-infも含めて)同一のとき return false; } else if ((num == -1 && den == 0) || (other.num == 1 && other.den == 0)) { // 左辺が-inf か、右辺が+inf return true; } else if ((num == 1 && den == 0) || (other.num == -1 && other.den == 0)) { // 左辺が+infか、右辺が-inf return false; } else { return num * other.den < other.num * den; } } bool operator ==(const Rational& other) const { return (num == other.num) && (den == other.den); } bool operator !=(const Rational& other) const { return !(*this == other); } bool operator >(const Rational& other) const { return other < *this; } bool operator <=(const Rational& other) const { return !(*this > other); } bool operator >=(const Rational& other) const { return !(*this < other); } // 単項演算子(+ -) Rational operator +() const { return *this; } Rational operator -() const { return Rational(-num, den); } // 複合代入演算子(+ - * /) Rational& operator +=(const Rational& other) { // inf + inf = inf, -inf + (-inf) = -inf // inf + (-inf) と (-inf) + inf は未定義 if (den == 0) { // そのまま返す } else if (other.den == 0) { num = other.num; den = other.den; } else { *this = Rational(num * other.den + other.num * den, den * other.den); } return *this; } Rational& operator *=(const Rational& other) { *this = Rational(num * other.num, den * other.den); return *this; } Rational& operator -=(const Rational& other) {*this += -other; return *this;} Rational& operator /=(const Rational& other) {*this *= other.inv(); return *this;} // 算術演算子(+ - * /) Rational operator +(const Rational& other) const {return Rational(*this) += other;} Rational operator -(const Rational& other) const {return Rational(*this) -= other;} Rational operator *(const Rational& other) const {return Rational(*this) *= other;} Rational operator /(const Rational& other) const {return Rational(*this) /= other;} // 二乗、絶対値、逆数 Rational sq() const { return Rational(num * num, den * den); } Rational abs() const { if (num < 0) return Rational(-num, den); else return *this; } Rational inv() const { return Rational(den, num); } // double型に変換 double val() const { return (double)num / (double)den; } // 整数型との演算 // Rational<bint> + intのような整数型が異なる場合に呼び出される template<class U> Rational& operator +=(const U& x) { *this += Rational<T>((T)x); return *this; } template<class U> Rational& operator -=(const U& x) { *this -= Rational<T>((T)x); return *this; } template<class U> Rational& operator *=(const U& x) { *this *= Rational<T>((T)x); return *this; } template<class U> Rational& operator /=(const U& x) { *this /= Rational<T>((T)x); return *this; } template<class U> Rational operator +(const U& x) const { return Rational(*this) += x; } template<class U> Rational operator -(const U& x) const { return Rational(*this) -= x; } template<class U> Rational operator *(const U& x) const { return Rational(*this) *= x; } template<class U> Rational operator /(const U& x) const { return Rational(*this) /= x; } // 入出力。参考:https://stackoverflow.com/questions/4039817/friend-declaration-declares-a-non-template-function // 入力時はインスタンスを生成 & 変更するのでconstをつけない. 出力時は変更しないのでconstをつける. friend istream& operator >>(istream &stream, Rational<T>& r) { return stream >> r.num; } friend ostream& operator <<(ostream &stream, const Rational<T>& r) { stream << r.num << '/' << r.den; return stream; } }; // 整数と分数の演算 template<class T, class U> Rational<T> operator +(const U& x, const Rational<T>& r) { return Rational<T>((T)x) + r; } template<class T, class U> Rational<T> operator -(const U& x, const Rational<T>& r) { return Rational<T>((T)x) - r; } template<class T, class U> Rational<T> operator *(const U& x, const Rational<T>& r) { return Rational<T>((T)x) * r; } template<class T, class U> Rational<T> operator /(const U& x, const Rational<T>& r) { return Rational<T>((T)x) / r; } int main() { cin.tie(nullptr); cout << fixed << setprecision(10); ll K, N; cin >> K >> N; using R = Rational<ll>; vl P(K + 1, 1); rep(i, 2, K + 1) { P[i] = P[i - 1] * i; } debug(P); vector<R> rest(K + 1); rep(k, 1, K + 1) { rest[k] = R(1) - R(k, N); } ll cnt = 0; ll ans = 0; auto f = [&](auto&& f, ll p, ll last, ll sum, R val) -> void { cnt++; if (p == K) { if (val == R(1)) ans += sum; return; } rep(n, last + 1, N + 1) { rep(k, 1, K - p + 1) { R val2 = val + R(k, n); if (val2 > R(1)) break; f(f, p + k, n, sum / P[k], val2); } } }; f(f, 0, 0, P[K], R(0)); debug(cnt); print(ans); } /********* 1 2 8 b i t 整 数 *********/ // 128bit整数を入力. LONG_LONG_MAX超過/LONG_LONG_MIN未満もOK. istream& operator>>(istream& stream, int128& val) { string s; stream >> s; assert(s.size() > 0); val = 0; bool is_minus = false; for (int i = 0; i < (int)s.size(); i++) { if (i == 0 && s[i] == '-') { assert(s.size() > 1); is_minus = true; } else { assert('0' <= s[i] && s[i] <= '9'); val *= 10; val += s[i] - '0'; } } if (is_minus) val *= -1; return stream; } // 128bit整数を出力. ostream& operator<<(ostream& stream, const int128& val_) { auto val(val_); if (val == 0) return stream << 0; if (val < 0) { stream << '-'; val *= -1; } string s; while (val > 0) { s += (val % 10) + '0'; val /= 10; } reverse(all(s)); return stream << s; } /********* P A I R **********/ /* 単項演算子(+ -) */ template <class T, class U> pair<T, U> operator+(pair<T, U> a) { return a; } template <class T, class U> pair<T, U> operator-(pair<T, U> a) { return a * (-1); } /* 複合代入演算子 (pair) */ template <class T, class U> pair<T, U>& operator+=(pair<T, U>& a, const pair<T, U> b) { a.fi += b.fi; a.se += b.se; return a; } template <class T, class U> pair<T, U>& operator-=(pair<T, U>& a, const pair<T, U> b) { a.fi -= b.fi; a.se -= b.se; return a; } template <class T, class U> pair<T, U>& operator*=(pair<T, U>& a, const pair<T, U> b) { a.fi *= b.fi; a.se *= b.se; return a; } template <class T, class U> pair<T, U>& operator/=(pair<T, U>& a, const pair<T, U> b) { a.fi /= b.fi; a.se /= b.se; return a; } template <class T, class U> pair<T, U>& operator%=(pair<T, U>& a, const pair<T, U> b) { a.fi %= b.fi; a.se %= b.se; return a; } template <class T, class U, class V> pair<T, U>& operator+=(pair<T, U>& a, const V b) { a.fi += b; a.se += b; return a; } template <class T, class U, class V> pair<T, U>& operator-=(pair<T, U>& a, const V b) { a.fi -= b; a.se -= b; return a; } template <class T, class U, class V> pair<T, U>& operator*=(pair<T, U>& a, const V b) { a.fi *= b; a.se *= b; return a; } template <class T, class U, class V> pair<T, U>& operator/=(pair<T, U>& a, const V b) { a.fi /= b; a.se /= b; return a; } template <class T, class U, class V> pair<T, U>& operator%=(pair<T, U>& a, const V b) { a.fi %= b; a.se %= b; return a; } /* 算術演算子 (pair) */ template <class T, class U, class V> pair<T, U> operator+(pair<T, U> a, const V& b) { return a += b; } template <class T, class U, class V> pair<T, U> operator-(pair<T, U> a, const V& b) { return a -= b; } template <class T, class U, class V> pair<T, U> operator*(pair<T, U> a, const V& b) { return a *= b; } template <class T, class U, class V> pair<T, U> operator/(pair<T, U> a, const V& b) { return a /= b; } template <class T, class U, class V> pair<T, U> operator%(pair<T, U> a, const V& b) { return a %= b; } // 入出力 template <class T, class U> istream& operator>>(istream& stream, pair<T, U>& a) { stream >> a.fi >> a.se; return stream; } template <class T, class U> ostream& operator<<(ostream& stream, const pair<T, U>& a) { stream << a.fi << " " << a.se; return stream; } /********* V E C T O R **********/ /* 単項演算子(+ -) */ template <class T> vector<T> operator+(vector<T> a) { return a; } template <class T> vector<T> operator-(vector<T> a) { return a * (-1); } /* 複合代入演算子 (vector) */ template <class T> vector<T>& operator+=(vector<T>& a, const vector<T> b) { assert(a.size() == b.size()); rep(i, 0, a.size()) a[i] += b[i]; return a; } template <class T> vector<T>& operator-=(vector<T>& a, const vector<T> b) { assert(a.size() == b.size()); rep(i, 0, a.size()) a[i] -= b[i]; return a; } template <class T> vector<T>& operator*=(vector<T>& a, const vector<T> b) { assert(a.size() == b.size()); rep(i, 0, a.size()) a[i] *= b[i]; return a; } template <class T> vector<T>& operator/=(vector<T>& a, const vector<T> b) { assert(a.size() == b.size()); rep(i, 0, a.size()) a[i] /= b[i]; return a; } template <class T> vector<T>& operator%=(vector<T>& a, const vector<T> b) { assert(a.size() == b.size()); rep(i, 0, a.size()) a[i] %= b[i]; return a; } template <class T, class U> vector<T>& operator+=(vector<T>& a, const U b) { fore(e, a) e += b; return a; } template <class T, class U> vector<T>& operator-=(vector<T>& a, const U b) { fore(e, a) e -= b; return a; } template <class T, class U> vector<T>& operator*=(vector<T>& a, const U b) { fore(e, a) e *= b; return a; } template <class T, class U> vector<T>& operator/=(vector<T>& a, const U b) { fore(e, a) e /= b; return a; } template <class T, class U> vector<T>& operator%=(vector<T>& a, const U b) { fore(e, a) e %= b; return a; } /* 算術演算子 (vector) */ template <class T, class U> vector<T> operator+(vector<T> a, const U& b) { return a += b; } template <class T, class U> vector<T> operator-(vector<T> a, const U& b) { return a -= b; } template <class T, class U> vector<T> operator*(vector<T> a, const U& b) { return a *= b; } template <class T, class U> vector<T> operator/(vector<T> a, const U& b) { return a /= b; } template <class T, class U> vector<T> operator%(vector<T> a, const U& b) { return a %= b; } /* 入出力 (vector) */ // ベクトルを入力 template <class T> istream& operator>>(istream& stream, vector<T>& a) { fore(e, a) stream >> e; return stream; } // ベクトルを空白区切りで出力 template <class T> ostream& operator<<(ostream& stream, const vector<T>& v) { if (v.size()) { stream << v[0]; rep(i, 1, v.size()) cout << " " << v[i]; } return stream; } // 2次元ベクトルを空白/改行区切りで出力 template <class T> ostream& operator<<(ostream& stream, const vector<vector<T>>& vv) { if (vv.size()) { stream << vv[0]; rep(i, 1, vv.size()) cout << '\n' << vv[i]; } return stream; } /* 計算 (vector) */ // 合計。v.size() == 0 のとき T() を返す template <class T> T Sum(const vector<T>& v) { return reduce(all(v)); } template <class T> T Max(const vector<T>& v) { assert(v.size()); return *max_element(all(v)); } template <class T> T Min(const vector<T>& v) { assert(v.size()); return *min_element(all(v)); } // 最大要素を指す最初の位置を返す(0-origin), O(N). template <class T> ll Argmax(const vector<T>& v) { assert(v.size()); return max_element(all(v)) - v.begin(); } // 最小要素を指す最初の位置を返す(0-origin), O(N). template <class T> ll Argmin(const vector<T>& v) { assert(v.size()); return min_element(all(v)) - v.begin(); } // 要素`a`がベクトル`v`に1つ以上含まれるかどうか template <class T, class U> bool Contains(const vector<T>& v, const U& a) { return find(all(v), a) != v.end(); } // ソートされたユニーク値のベクトルにinplaceで書き換える, O(NlogN). template <class T> void Unique(vector<T>& v) { sort(all(v)); v.erase(unique(all(v)), v.end()); } /* 生成 (vector) */ template <class T, class U> vector<T> make_vector(int n, U v) { return vector<T>(n, v); } /********* S E T **********/ // 一要素を入力 template <class T> istream& operator>>(istream& stream, set<T>& st) { T e; stream >> e; st.insert(e); return stream; } // 空白区切りで出力 template <class T> ostream& operator<<(ostream& stream, const set<T>& st) { if (st.size()) { auto it = st.begin(); stream << *it++; for (; it != st.end(); it++) cout << " " << *it; } return stream; } template <class T> T Max(const set<T>& st) { assert(st.size()); return *prev(st.end()); } template <class T> T Min(const set<T>& st) { assert(st.size()); return *st.begin(); } /********* M U L T I S E T **********/ // 一要素を入力 template <class T> istream& operator>>(istream& stream, multiset<T>& st) { T e; stream >> e; st.insert(e); return stream; } // 空白区切りで出力 template <class T> ostream& operator<<(ostream& stream, const multiset<T>& st) { if (st.size()) { auto it = st.begin(); stream << *it++; for (; it != st.end(); it++) cout << " " << *it; } return stream; } template <class T> T Max(const multiset<T>& st) { assert(st.size()); return *prev(st.end()); } template <class T> T Min(const multiset<T>& st) { assert(st.size()); return *st.begin(); } // 要素xを1つ削除. 消せたらtrueを返す. template <class T> bool EraseOne(multiset<T>& st, const T& x) { auto it = st.find(x); if (it != st.end()) { st.erase(it); return true; } else return false; } /********* C H A R **********/ // 大文字かどうか bool IsUpper(const char& c) { return isupper(c) > 0; } // 小文字かどうか bool IsLower(const char& c) { return islower(c) > 0; } // 大文字へ変換 char ToUpper(const char& c) { string s{c}, t; t.resize(s.size()); std::transform(all(s), t.begin(), ::toupper); return t[0]; } // 小文字へ変換 char ToLower(const char& c) { string s{c}, t; t.resize(s.size()); std::transform(all(s), t.begin(), ::tolower); return t[0]; } /********* S T R I N G **********/ // 大文字へ変換 string ToUpper(const string& s) { string t; t.resize(s.size()); std::transform(all(s), t.begin(), ::toupper); return t; } // 小文字へ変換 string ToLower(const string& s) { string t; t.resize(s.size()); std::transform(all(s), t.begin(), ::tolower); return t; } // 回文判定, O(N). 空文字の返り値はTrue. bool IsPalindrome(const string& S) { ll N = len(S); for (ll i = 0; 2 * i < N; i++) if (S[i] != S[N - i - 1]) return false; return true; } /********* T R I O **********/ // コンストラクタ・代入演算子 template <class T1, class T2, class T3> trio<T1, T2, T3>::trio() { first = T1(); second = T2(); third = T3(); } template <class T1, class T2, class T3> trio<T1, T2, T3>::trio(const T1& x) : first(x), second(x), third(x) {} template <class T1, class T2, class T3> trio<T1, T2, T3>::trio(const T1& x, const T2& y, const T3& z) : first(x), second(y), third(z) {} template <class T1, class T2, class T3> trio<T1, T2, T3>::trio(const trio& t) { first = t.first; second = t.second; third = t.third; } template <class T1, class T2, class T3> trio<T1, T2, T3>& trio<T1, T2, T3>::operator=(const trio& t) { first = t.first; second = t.second; third = t.third; return *this; } // 比較演算子 (trio) template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator<(const trio& t) const { return tie(first, second, third) < tie(t.first, t.second, t.third); } template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator==(const trio& t) const { return tie(first, second, third) == tie(t.first, t.second, t.third); } template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator!=(const trio& t) const { return !(*this == t); } template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator>(const trio& t) const { return t < *this; } template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator<=(const trio& t) const { return !(*this > t); } template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator>=(const trio& t) const { return !(*this < t); } // 単項演算子(+ -) (trio) template <class T1, class T2, class T3> trio<T1, T2, T3> trio<T1, T2, T3>::operator+() const { return *this; } template <class T1, class T2, class T3> trio<T1, T2, T3> trio<T1, T2, T3>::operator-() const { return (*this) * (-1); } // 入出力 (trio) template <class T1, class T2, class T3> istream& operator>>(istream& stream, trio<T1, T2, T3>& t) { return stream >> t.first >> t.second >> t.third; } template <class T1, class T2, class T3> ostream& operator<<(ostream& stream, const trio<T1, T2, T3>& t) { return stream << t.first << " " << t.second << " " << t.third; } /* 複合代入演算子 (trio) */ template <class T1, class T2, class T3> trio<T1, T2, T3>& operator+=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b) { a.fi += b.fi; a.se += b.se; a.th += b.th; return a; } template <class T1, class T2, class T3> trio<T1, T2, T3>& operator-=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b) { a.fi -= b.fi; a.se -= b.se; a.th -= b.th; return a; } template <class T1, class T2, class T3> trio<T1, T2, T3>& operator*=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b) { a.fi *= b.fi; a.se *= b.se; a.th *= b.th; return a; } template <class T1, class T2, class T3> trio<T1, T2, T3>& operator/=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b) { a.fi /= b.fi; a.se /= b.se; a.th /= b.th; return a; } template <class T1, class T2, class T3> trio<T1, T2, T3>& operator%=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b) { a.fi %= b.fi; a.se %= b.se; a.th %= b.th; return a; } template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator+=(trio<T1, T2, T3>& a, const U b) { a.fi += b; a.se += b; a.th += b; return a; } template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator-=(trio<T1, T2, T3>& a, const U b) { a.fi -= b; a.se -= b; a.th -= b; return a; } template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator*=(trio<T1, T2, T3>& a, const U b) { a.fi *= b; a.se *= b; a.th *= b; return a; } template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator/=(trio<T1, T2, T3>& a, const U b) { a.fi /= b; a.se /= b; a.th /= b; return a; } template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator%=(trio<T1, T2, T3>& a, const U b) { a.fi %= b; a.se %= b; a.th %= b; return a; } /* 算術演算子 (trio) */ template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator+(trio<T1, T2, T3> a, const U& b) { return a += b; } template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator-(trio<T1, T2, T3> a, const U& b) { return a -= b; } template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator*(trio<T1, T2, T3> a, const U& b) { return a *= b; } template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator/(trio<T1, T2, T3> a, const U& b) { return a /= b; } template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator%(trio<T1, T2, T3> a, const U& b) { return a %= b; } /********* Q U A R T E T **********/ // コンストラクタ・代入演算子 template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>::quartet() { first = T1(); second = T2(); third = T3(); fourth = T4(); } template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>::quartet(const T1& x) : first(x), second(x), third(x), fourth(x) {} template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>::quartet(const T1& x, const T2& y, const T3& z, const T4& w) : first(x), second(y), third(z), fourth(w) {} template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>::quartet(const quartet& t) { first = t.first; second = t.second; third = t.third; fourth = t.fourth; } template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>& quartet<T1, T2, T3, T4>::operator=(const quartet& t) { first = t.first; second = t.second; third = t.third; fourth = t.fourth; return *this; } // 比較演算子 (quartet) template <class T1, class T2, class T3, class T4> bool quartet<T1, T2, T3, T4>::operator<(const quartet& t) const { return tie(first, second, third, fourth) < tie(t.first, t.second, t.third, t.fourth); } template <class T1, class T2, class T3, class T4> bool quartet<T1, T2, T3, T4>::operator==(const quartet& t) const { return tie(first, second, third, fourth) == tie(t.first, t.second, t.third, t.fourth); } template <class T1, class T2, class T3, class T4> bool quartet<T1, T2, T3, T4>::operator!=(const quartet& t) const { return !(*this == t); } template <class T1, class T2, class T3, class T4> bool quartet<T1, T2, T3, T4>::operator>(const quartet& t) const { return t < *this; } template <class T1, class T2, class T3, class T4> bool quartet<T1, T2, T3, T4>::operator<=(const quartet& t) const { return !(*this > t); } template <class T1, class T2, class T3, class T4> bool quartet<T1, T2, T3, T4>::operator>=(const quartet& t) const { return !(*this < t); } // 単項演算子(+ -) (quartet) template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4> quartet<T1, T2, T3, T4>::operator+() const { return *this; } template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4> quartet<T1, T2, T3, T4>::operator-() const { return (*this) * (-1); } // 入出力 (quartet) template <class T1, class T2, class T3, class T4> istream& operator>>(istream& stream, quartet<T1, T2, T3, T4>& t) { return stream >> t.first >> t.second >> t.third >> t.fourth; } template <class T1, class T2, class T3, class T4> ostream& operator<<(ostream& stream, const quartet<T1, T2, T3, T4>& t) { return stream << t.first << " " << t.second << " " << t.third << " " << t.fourth; } /* 複合代入演算子 (quartet) */ template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>& operator+=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b) { a.fi += b.fi; a.se += b.se; a.th += b.th; a.fo += b.fo; return a; } template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>& operator-=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b) { a.fi -= b.fi; a.se -= b.se; a.th -= b.th; a.fo -= b.fo; return a; } template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>& operator*=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b) { a.fi *= b.fi; a.se *= b.se; a.th *= b.th; a.fo *= b.fo; return a; } template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>& operator/=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b) { a.fi /= b.fi; a.se /= b.se; a.th /= b.th; a.fo /= b.fo; return a; } template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>& operator%=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b) { a.fi %= b.fi; a.se %= b.se; a.th %= b.th; a.fo %= b.fo; return a; } template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4>& operator+=(quartet<T1, T2, T3, T4>& a, const U b) { a.fi += b; a.se += b; a.th += b; a.fo += b; return a; } template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4>& operator-=(quartet<T1, T2, T3, T4>& a, const U b) { a.fi -= b; a.se -= b; a.th -= b; a.fo -= b; return a; } template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4>& operator*=(quartet<T1, T2, T3, T4>& a, const U b) { a.fi *= b; a.se *= b; a.th *= b; a.fo *= b; return a; } template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4>& operator/=(quartet<T1, T2, T3, T4>& a, const U b) { a.fi /= b; a.se /= b; a.th /= b; a.fo /= b; return a; } template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4>& operator%=(quartet<T1, T2, T3, T4>& a, const U b) { a.fi %= b; a.se %= b; a.th %= b; a.fo %= b; return a; } /* 算術演算子 (quartet) */ template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4> operator+(quartet<T1, T2, T3, T4> a, const U& b) { return a += b; } template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4> operator-(quartet<T1, T2, T3, T4> a, const U& b) { return a -= b; } template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4> operator*(quartet<T1, T2, T3, T4> a, const U& b) { return a *= b; } template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4> operator/(quartet<T1, T2, T3, T4> a, const U& b) { return a /= b; } template <class T1, class T2, class T3, class T4, class U> quartet<T1, T2, T3, T4> operator%(quartet<T1, T2, T3, T4> a, const U& b) { return a %= b; } /********* R A N D O M **********/ // 引数なし: seedはランダム Random::Random() { random_device seed_gen; rnd.seed(seed_gen()); } // 引数: seed Random::Random(ll seed) { rnd.seed(seed); } // [a, b]からランダムに整数を返す ll Random::randint(ll a, ll b) { uniform_int_distribution<ll> dist(a, b); return dist(rnd); } // [a, b]からランダムに浮動小数点数を返す double Random::randreal(double a, double b) { uniform_real_distribution<double> dist(a, b); return dist(rnd); } // [a, b]からランダムに文字を返す char Random::randchar(char a, char b) { uniform_int_distribution<ll> dist(a, b); return dist(rnd); } // `vec`をinplaceで並び替える template <class T> void Random::shuffle(vector<T>& vec) { std::shuffle(all(vec), rnd); } /********* T I M E R **********/ // 引数: タイムリミット(秒) Timer::Timer(double time_limit_sec) { assert(time_limit_sec > 0); this->time_limit = time_limit_sec * CLOCKS_PER_SEC; this->start_time = clock(); } // タイムリミットに到達したかどうか bool Timer::is_time_up() const { return clock() - this->start_time >= this->time_limit; } // 経過時間の割合を[0.0, 1.0]で返す double Timer::get_elapsed_ratio() const { double ratio = 1.0 * (clock() - this->start_time) / (this->time_limit - this->start_time); return min(1.0, ratio); } /********* P R I N T **********/ template <class T> void print(const T& e) { cout << e << '\n'; } template <class H, class... T> void print(const H& h, const T&... t) { cout << h << ' '; print(t...); } template <class... T> void End(const T&... t) { print(t...); exit(0); } /********* D E B U G *********/ void dbg_(const long long& e) { if (e == INF) cout << "INF"; else if (e == -INF) cout << "-INF"; else cout << e; } template <class T> void dbg_(const T& e) { cout << e; } template <class T, class U> void dbg_(const pair<T, U>& p) { cout << '('; dbg_(p.first); cout << ' '; dbg_(p.second); cout << ')'; } template <class T1, class T2, class T3> void dbg_(const trio<T1, T2, T3>& t) { cout << '('; dbg_(t.first); cout << ' '; dbg_(t.second); cout << ' '; dbg_(t.third); cout << ')'; } template <class T1, class T2, class T3, class T4> void dbg_(const quartet<T1, T2, T3, T4>& t) { cout << '('; dbg_(t.first); cout << ' '; dbg_(t.second); cout << ' '; dbg_(t.third); cout << ' '; dbg_(t.fourth); cout << ')'; } template <class T> void debug_(const T& e) { dbg_(e); cout << '\n'; } template <class T> void debug_(const vector<T>& v) { if (v.size()) { auto it = v.begin(); dbg_(*it++); for (; it != v.end(); ++it) { cout << ' '; dbg_(*it); } } cout << '\n'; } template <class T> void debug_(const vector<vector<T>>& vv) { cout << '\n'; ll cnt = 0; for (auto&& v : vv) { cout << cnt++ << ": "; debug_(v); } } template <class T, class U> void debug_(const map<T, U>& mp) { if (mp.size()) { auto it = mp.begin(); dbg_(*it++); for (; it != mp.end(); ++it) { cout << ' '; dbg_(*it); } } cout << '\n'; } template <class T, class U> void debug_(const vector<map<T, U>>& vm) { cout << '\n'; ll cnt = 0; for (auto&& mp : vm) { cout << cnt++ << ": "; debug_(mp); } } template <class T> void debug_(const set<T>& st) { if (st.size()) { auto it = st.begin(); dbg_(*it++); for (; it != st.end(); ++it) { cout << ' '; dbg_(*it); } } cout << '\n'; } template <class T> void debug_(const multiset<T>& st) { if (st.size()) { auto it = st.begin(); dbg_(*it++); for (; it != st.end(); ++it) { cout << ' '; dbg_(*it); } } cout << '\n'; } template <class T> void debug_(const vector<set<T>>& vs) { cout << '\n'; ll cnt = 0; for (auto&& st : vs) { cout << cnt++ << ": "; debug_(st); } } template <class T> void debug_(const vector<multiset<T>>& vs) { cout << '\n'; ll cnt = 0; for (auto&& st : vs) { cout << cnt++ << ": "; debug_(st); } } template <class H, class... T> void debug_(const H& h, const T&... t) { dbg_(h); cout << ", "; debug_(t...); } /********* O T H E R S **********/ // a > b なら a に b を代入. template <class T, class U> bool chmin(T& a, U b) { if (a > b) { a = b; return true; } return false; } // a < b なら a に b を代入. template <class T, class U> bool chmax(T& a, U b) { if (a < b) { a = b; return true; } return false; } // a % mを返す. aは負もOK. template <class T, class U> T Mod(const T& a, const U& m) { assert(m > 0); return (a % m + m) % m; } // 天井関数. xは負もOK template <class T, class U> T Ceil(const T& x, const U& y) { assert(y > 0); return x < 0 ? x / y : (x + y - 1) / y; } // 床関数. xは負もOK template <class T, class U> T Floor(const T& x, const U& y) { assert(y > 0); return -(Ceil(-x, y)); } // 符号関数. 返り値: -1, 0, +1のいずれか template <class T> ll Sign(const T& x) { return (x > T(0)) - (x < T(0)); } // x * x <= nを満たす最大の整数`x`を返す ll Isqrt(ll n) { assert(n >= 0); ll x = round(sqrt(n)); while (x * x > n) --x; return x; } // nCr. n=60, r=30までOK. ll Comb(ll n, ll r) { if (r < 0 || n < r) return 0; r = min(r, n - r); ll ret = 1; rep(i, r) { ret *= n - i; ret /= i + 1; } return ret; } // べき乗. mintもOK. template <class T> T Pow(T x, ll n) { assert(n >= 0); T ret = 1; while (1) { if (n % 2) ret *= x; n /= 2; if (!n) return ret; x = x * x; } } // 等差級数. mintもOK. template <class T> T Aseries(T a, T d, ll n) { assert(n >= 0); return a * n + n * (n - 1) / 2 * d; } // 等比級数. mintもOK. template <class T> T Gseries(T a, T r, ll n) { assert(n >= 0); if (r == 1) return a * n; else return a * (1 - Pow(r, n)) / (1 - r); } // `b`の`i`番目(0 origin)のビットが1かどうか bool Bit(ll b, int i) { assert(0 <= i && i < 64); return (b >> i) & 1; } // `b`の立っているビット数 ll Popcount(ll b) { return __builtin_popcountll(b); } // [0, n)番目のビットが立った64bit整数を返す. ll Mask(ll n) { assert(0 <= n && n < 63); return (1LL << n) - 1LL; } // [m, n)番目のビットが立った64bit整数を返す. ll Mask(ll n, ll m) { assert(n >= m); return Mask(n) ^ Mask(m); } // [l1, r1)と[l2, r2)の積区間を返す. 例: [3, 6) x [5, 7) = [5, 6) pll GetOverlap(ll l1, ll r1, ll l2, ll r2) { return {max(l1, l2), min(r1, r2)}; } // [l1, r1)と[l2, r2)で重なりがあるかを返す. 引数が片方でも空区間ならfalse; bool IsOverlap(ll l1, ll r1, ll l2, ll r2) { return max(l1, l2) < min(r1, r2); } // b=trueなら"Yes\n", falseなら"No\n"を出力 void PrintYesNo(bool b) { b ? print("Yes") : print("No"); }