func_code_string: #include <bits/stdc++.h>   using namespace std;   using SI = set<int>;   using ULL = unsigned long long;   using LL = long long;   using VI = vector<int>;   using LD = long double;   using PULL = pair<ULL, ULL>;   using UI = unsigned int;   using PLL = pair<LL, LL>;   using PDD = pair<LD, LD>;   using MII = map<int, int>;   using TDD = pair<PDD, LD>;   using TLL = pair<PLL, LL>;   using PII = pair<int, int>;   using TII = pair<PII, int>;   using QDD = pair<PDD, PDD>;   using QII = pair<PII, PII>;   using QLL = pair<PLL, PLL>;   using STII = set<TII>;   using VTII = vector<TII>;   using MTII = map<TII, TII>;   using MITII = map<int, TII>;   using UMITII = unordered_map<int, TII>;   using SQII = set<QII>;   using VQII = vector<QII>;   using MQII = map<QII, QII>;   using MIQII = map<int, QII>;   using UMIQII = unordered_map<int, QII>;   using SLL = set<LL>;   using VLL = vector<LL>;   using MLL = map<LL, LL>;   using MILL = map<int, LL>;   using UMILL = unordered_map<int, LL>;   using SULL = set<ULL>;   using VULL = vector<ULL>;   using MULL = map<ULL, ULL>;   using MIULL = map<int, ULL>;   using UMIULL = unordered_map<int, ULL>;   using SPULL = set<PULL>;   using VPULL = vector<PULL>;   using MPULL = map<PULL, PULL>;   using MIPULL = map<int, PULL>;   using UMIPULL = unordered_map<int, PULL>;   using SQLL = set<QLL>;   using VQLL = vector<QLL>;   using MQLL = map<QLL, QLL>;   using MIQLL = map<int, QLL>;   using UMIQLL = unordered_map<int, QLL>;   using SLD = set<LD>;   using VLD = vector<LD>;   using MLD = map<LD, LD>;   using MILD = map<int, LD>;   using UMILD = unordered_map<int, LD>;   using SPDD = set<PDD>;   using VPDD = vector<PDD>;   using MPDD = map<PDD, PDD>;   using MIPDD = map<int, PDD>;   using UMIPDD = unordered_map<int, PDD>;   using SVI = set<VI>;   using VVI = vector<VI>;   using MVI = map<VI, VI>;   using MIVI = map<int, VI>;   using UMIVI = unordered_map<int, VI>;   using STLL = set<TLL>;   using VTLL = vector<TLL>;   using MTLL = map<TLL, TLL>;   using MITLL = map<int, TLL>;   using UMITLL = unordered_map<int, TLL>;   using SUI = set<UI>;   using VUI = vector<UI>;   using MUI = map<UI, UI>;   using MIUI = map<int, UI>;   using UMIUI = unordered_map<int, UI>;   using SPII = set<PII>;   using VPII = vector<PII>;   using MPII = map<PII, PII>;   using MIPII = map<int, PII>;   using UMIPII = unordered_map<int, PII>;   using SPLL = set<PLL>;   using VPLL = vector<PLL>;   using MPLL = map<PLL, PLL>;   using MIPLL = map<int, PLL>;   using UMIPLL = unordered_map<int, PLL>;   using SSI = set<SI>;   using VSI = vector<SI>;   using MSI = map<SI, SI>;   using MISI = map<int, SI>;   using UMISI = unordered_map<int, SI>;   using SVVI = set<VVI>;   using VVVI = vector<VVI>;   using MVVI = map<VVI, VVI>;   using MIVVI = map<int, VVI>;   using UMIVVI = unordered_map<int, VVI>;   using UMII = unordered_map<int, int>;   ULL randULL() {     return ((ULL)rand()) ^ ((ULL)rand() << 15) ^ ((ULL)rand() << 30) ^            ((ULL)rand() << 45) ^ ((ULL)rand() << 60);   }   using STDD = set<TDD>;   using VTDD = vector<TDD>;   using MTDD = map<TDD, TDD>;   using MITDD = map<int, TDD>;   using UMITDD = unordered_map<int, TDD>;   using SQDD = set<QDD>;   using VQDD = vector<QDD>;   using MQDD = map<QDD, QDD>;   using MIQDD = map<int, QDD>;   using UMIQDD = unordered_map<int, QDD>;   int popc(int x) { return __builtin_popcount(x); }   int popc(UI x) { return __builtin_popcount(x); }   int popc(LL x) { return __builtin_popcountll(x); }   int popc(ULL x) { return __builtin_popcountll(x); }   int ctz(int x) { return __builtin_ctz(x); }   int ctz(UI x) { return __builtin_ctz(x); }   int ctz(LL x) { return __builtin_ctzll(x); }   int ctz(ULL x) { return __builtin_ctzll(x); }   int clz(int x) { return __builtin_clz(x); }   int clz(UI x) { return __builtin_clz(x); }   int clz(LL x) { return __builtin_clzll(x); }   int clz(ULL x) { return __builtin_clzll(x); }   int bit_parity(int x) { return __builtin_parity(x); }   int bit_parity(UI x) { return __builtin_parity(x); }   int bit_parity(LL x) { return __builtin_parityll(x); }   int bit_parity(ULL x) { return __builtin_parityll(x); }   template <class T, class U>   bool one_of(T x, U y) {     return x == y;   }   template <class T, class U, class... V>   bool one_of(T x, U y, V... z) {     return x == y || one_of(x, z...);   }   template <class T>   bool diff(T _) {     return true;   }   template <class T, class... U>   bool diff(T x, U... y) {     return !one_of(x, y...) && diff(y...);   }   template <class T, class U>   bool equal(T x, U y) {     return x == y;   }   template <class T, class U, class... V>   bool equal(T x, U y, V... z) {     return x == y && equal(x, z...);   }   template <class T, class U>   bool in_order(T x, U y) {     return x <= y;   }   template <class T, class U, class... V>   bool in_order(T x, U y, V... z) {     return x <= y && in_order(y, z...);   }   template <class T, class U>   bool in_strorder(T x, U y) {     return x < y;   }   template <class T, class U, class... V>   bool in_strorder(T x, U y, V... z) {     return x < y && in_strorder(y, z...);   }   template <class T>   void swap3(T &x, T &y, T &z) {     swap(x, y);     swap(x, z);   }   template <class T>   pair<T, T> dup(T x) {     return make_pair(x, x);   }   template <class T>   pair<pair<T, T>, T> thrice(T x) {     return make_pair(make_pair(x, x), x);   }   template <class T>   pair<pair<T, T>, pair<T, T>> fourfold(T x) {     return make_pair(make_pair(x, x), make_pair(x, x));   }   template <class T, class U, class V>   T safvec(const vector<T> &v, int i, U low, V high) {     if (i < 0) return low;     if (i >= ((int)(v).size())) return high;     return v[i];   }   template <class T, class U>   T safar(T *a, int i, U low) {     if (i < 0) return low;     return a[i];   }   template <class T, class U, class V>   auto med(const T &a, const U &b, const V &c) -> decltype(1 ? a : (1 ? b : c)) {     return my_min(my_max(a, b), my_max(my_min(a, b), c));   }   namespace std {   template <class T, class U>   struct hash<pair<T, U>> {     size_t operator()(const pair<T, U> &a) const {       return (hash<T>()(a.first) * 1420343LL ^ hash<U>()(a.second) * 923275LL) %              1463984161;     }   };   }  // namespace std   template <class T, class U>   auto my_min(const U &x, const T &y) -> decltype(1 ? x : y) {     return x < y ? x : y;   }   template <class T, class U>   bool mini(U &x, T y) {     if (y < x) {       x = y;       return true;     }     return false;   }   template <class T, class U, class V>   auto my_min(const T &a, const U &b, const V &c)       -> decltype(1 ? a : (1 ? b : c)) {     return my_min(a, my_min(b, c));   }   template <class T, class U, class V, class W>   auto my_min(const T &a, const U &b, const V &c, const W &d)       -> decltype(1 ? a : (1 ? b : (1 ? c : d))) {     return my_min(a, my_min(b, c, d));   }   template <class T, class U>   auto my_max(const U &x, const T &y) -> decltype(1 ? x : y) {     return x > y ? x : y;   }   template <class T, class U>   bool maxi(U &x, T y) {     if (y > x) {       x = y;       return true;     }     return false;   }   template <class T, class U, class V>   auto my_max(const T &a, const U &b, const V &c)       -> decltype(1 ? a : (1 ? b : c)) {     return my_max(a, my_max(b, c));   }   template <class T, class U, class V, class W>   auto my_max(const T &a, const U &b, const V &c, const W &d)       -> decltype(1 ? a : (1 ? b : (1 ? c : d))) {     return my_max(a, my_max(b, c, d));   }   template <class T>   T brange(int l, int r) {     return ~(~((T)0) << (r - l + 1)) << l;   }   template <class T>   T brange(int l, int r, int second) {     return (brange<T>(l, l + (r - l) / second * second - 1) /             brange<T>(0, second - 1)) |            ((T)1 << (l + (r - l) / second * second));   }   template <class T>   auto O2kQ(T x, int i, int j)       -> vector<typename remove_reference<decltype(*x.end())>::type> {     vector<typename remove_reference<decltype(*x.end())>::type> ans;     for (auto c : x)       if ((--i < 0) & (j-- >= 0)) ans.push_back(c);     return ans;   }   template <class T>   vector<T> O2kQ(const T *x, int i, int j) {     vector<T> ans;     for (int _ = i; _ <= (int)(j); _++) ans.push_back(x[_]);     return ans;   }   int CON_BOUND = 10;   string E0ms() { return   ; }   template <class T>   string E0ms(T x) {     stringstream os;     os << boolalpha << x;     return os.str();   }   template <class T, class... U>   string E0ms(T x, U... y) {     return E0ms(x) +  ,   + E0ms(y...);   }   string SqC6(bool x) { return x ?  true  :  false ; }   template <class T>   typename enable_if<is_integral<T>::value, string>::type SqC6(T r) {     string a;     for (int i = 8 * sizeof(T) - 1; i >= (int)(0); i--) {       if (i % 5 == 4) a +=  . ;       a +=  0  + !!(((T)1 << i) & r);     }     return a;   }   template <class T, class C>   string SqC6(pair<T, C>);   template <class T>   auto SqC6(T x) -> decltype(x.end(), string()) {     string a =   ;     for (auto c : x) {       if (((int)(a).size())) a +=  ,  ;       a += SqC6(c);     }     return  {  + a +  }_  + to_string(((int)(x).size()));   }   template <class T, class C>   string SqC6(pair<T, C> x) {     return  <  + SqC6(x.first) +  ,   + SqC6(x.second) +  > ;   }   template <class T, int N>   T &arrp(T a[][N], PII x) {     return a[x.first][x.second];   }   const int mod = 1e9 + 7;   LL mpow(LL b, int e) {     LL ans = 1;     while (e) {       if (e & 1) ans = ans * b % mod;       b = b * b % mod;       e /= 2;     }     return ans;   }   struct zet_p {     int v;     int get() { return v; }     zet_p(LL x = 0) { v = x % mod; }     zet_p operator+(zet_p x) { return (v + x.v) % mod; }     zet_p operator-(zet_p x) { return v - x.v; }     zet_p operator*(zet_p x) { return v * 1ll * x.v; }     zet_p operator/(zet_p a) { return v * mpow(a.v, mod - 2); }   };   const bool deb = false;   struct frac_mod {     int n, d;     frac_mod(int x = 0) {       n = x % mod;       d = 1;     }     frac_mod(int x, int y) {       n = x;       d = y;     }     frac_mod operator+(frac_mod x) {       return {(int)((x.d * 1ll * n + d * 1ll * x.n) % mod), x.d * d % mod};     }     frac_mod operator-(frac_mod x) {       return {(int)((n * 1ll * x.d - x.n * 1ll * d) % mod), x.d * d % mod};     }     frac_mod operator*(frac_mod x) {       return {(int)((n * (LL)x.n) % mod), (int)((d * (LL)x.d) % mod)};     }     frac_mod operator/(frac_mod x) {       return {(int)(n * (LL)x.d % mod), (int)(d * (LL)x.n % mod)};     }     int get() {       int ans = n * mpow(d, mod - 2) % mod;       if (ans < 0) ans += mod;       return ans;     }   };   template <class T>   typename enable_if<is_arithmetic<T>::value, frac_mod>::type operator+(       frac_mod x, T y) {     return x + frac_mod(y);   }   template <class T>   typename enable_if<is_arithmetic<T>::value, frac_mod>::type operator+(       T x, frac_mod y) {     return frac_mod(x) + y;   }   template <class T>   frac_mod &operator+=(frac_mod &x, T y) {     return x = x + y;   }   template <class T>   typename enable_if<is_arithmetic<T>::value, frac_mod>::type operator-(       frac_mod x, T y) {     return x - frac_mod(y);   }   template <class T>   typename enable_if<is_arithmetic<T>::value, frac_mod>::type operator-(       T x, frac_mod y) {     return frac_mod(x) - y;   }   template <class T>   frac_mod &operator-=(frac_mod &x, T y) {     return x = x - y;   }   template <class T>   typename enable_if<is_arithmetic<T>::value, frac_mod>::type operator*(       frac_mod x, T y) {     return x * frac_mod(y);   }   template <class T>   typename enable_if<is_arithmetic<T>::value, frac_mod>::type operator*(       T x, frac_mod y) {     return frac_mod(x) * y;   }   template <class T>   frac_mod &operator*=(frac_mod &x, T y) {     return x = x * y;   }   template <class T>   typename enable_if<is_arithmetic<T>::value, frac_mod>::type operator/(       frac_mod x, T y) {     return x / frac_mod(y);   }   template <class T>   typename enable_if<is_arithmetic<T>::value, frac_mod>::type operator/(       T x, frac_mod y) {     return frac_mod(x) / y;   }   template <class T>   frac_mod &operator/=(frac_mod &x, T y) {     return x = x / y;   }   template <class T, class C>   ostream &operator<<(ostream &ans, pair<T, C> x) {     return ans <<  <  << x.first <<  ,   << x.second <<  > ;   }   template <class T>   auto operator<<(ostream &o, T x) ->       typename enable_if<!is_same<T, string>::value, decltype(x.end(), o)>::type {     o <<  { ;     int i = 0;     for (auto c : x) {       if (i++ == ((int)(x).size()) - 1 || ((int)(x).size()) < CON_BOUND + 2 ||           i < CON_BOUND) {         if (i - 1 &&             (i != ((int)(x).size()) || ((int)(x).size()) < CON_BOUND + 2))           o <<  ,  ;         o << c;       }       if (i == CON_BOUND && ((int)(x).size()) > CON_BOUND + 1) o <<   ...  ;     }     return o <<  }_  << x.size();   }   string b7Pe(string x) {     int dep = 0;     for (char c : x) {       for (char d :  ([{ )         if (c == d) dep++;       for (char d :  }]) )         if (c == d) dep--;       for (char d :  +-*/%^<>=&|?, )         if (c == d && !dep) return  (  + x +  ) ;     }     return x;   }   template <class T, class U>   pair<U, T> pinv(pair<T, U> x) {     return make_pair(x.second, x.first);   }   template <class T>   struct Wt71 {     T c;     int l, r, L, R;   };   template <class T>   ostream &operator<<(ostream &o, Wt71<T> M) {     o <<   n ;     for (int i = M.l; i <= (int)(M.r); i++) {       o <<      << i <<  : |  ;       for (int j = M.L; j <= (int)(M.R); j++) {         o << M.c[i][j] << ((j - M.L + 1) % 5 ?     :  ;  );       }       o <<   n ;     }     return o;   }   template <class T>   Wt71<T> q9cX(T a, int i, int j, int k, int q) {     return {a, i, j, k, q};   }   int primes[] = {2,   3,   5,   7,   11,  13,  17,  19,  23,  29,  31,  37,  41,                   43,  47,  53,  59,  61,  67,  71,  73,  79,  83,  89,  97,  101,                   103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167,                   173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239,                   241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,                   317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397,                   401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467,                   479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569,                   571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643,                   647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733,                   739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823,                   827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,                   919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997},       big_primes[] = {1307533217, 1336158883, 1339172111, 1367797777, 1376837461,                       1399436671, 1426555723, 1440115249, 1444635091, 1489833511,                       1553111299, 1562150983, 1587763421, 1610362631, 1652547823,                       1666107349, 1700759471, 1782116627, 1797182767, 1810742293,                       1818275363, 1892099449, 1904152361, 1919218501, 1940311097,                       1944830939, 1968936763, 1977976447, 1985509517, 1990029359},       gens[] = {1,   2,   3,   5,   2,   11,  3,   14,  19,  11,  17,  32,  30,                 34,  29,  19,  34,  31,  63,  33,  5,   63,  53,  58,  40,  83,                 21,  18,  99,  33,  106, 40,  85,  109, 40,  77,  91,  120, 105,                 91,  79,  53,  182, 10,  184, 48,  48,  150, 168, 72,  65,  46,                 31,  216, 101, 134, 163, 147, 93,  42,  69,  7,   151, 308, 112,                 12,  227, 185, 214, 305, 163, 234, 154, 316, 3,   11,  233, 390,                 271, 173, 82,  407, 13,  135, 414, 391, 177, 293, 426, 432, 337,                 281, 385, 103, 95,  152, 12,  371, 390, 77,  532, 34,  287, 73,                 308, 493, 258, 549, 528, 411, 12,  283, 614, 596, 622, 309, 91,                 511, 287, 433, 585, 123, 2,   170, 183, 341, 459, 322, 333, 337,                 507, 718, 82,  517, 396, 315, 565, 48,  362, 617, 776, 425, 584,                 231, 578, 395, 127, 27,  506, 435, 727, 659, 697, 385, 290, 109,                 430, 422, 344, 849, 513, 453, 852, 920, 152, 482, 653, 271},       big_gens[] = {661761153,  1315209189, 235649158,  80905954,  861543922,                     677870461,  332266749,  1192707557, 820697698, 93737534,                     1395132003, 176849700,  1113502216, 860516128, 1543755630,                     328298286,  1219407972, 1407392293, 733053145, 400000570,                     1081174233, 847228024,  1516266762, 83276926,  500618997,                     44975430,   47827763,   1411328206, 151880843, 19696955};   LL vbig_primes[] = {       1223771071LL,         2557943639LL,         4625922079LL,       8465729693LL,         16196062793LL,        32628322457LL,       64355194333LL,        128143942897LL,       256728067087LL,       512368953949LL,       1024440714547LL,      2048302681847LL,       4096121499499LL,      8192933500519LL,      16384652744209LL,       32768255472209LL,     65536007832649LL,     131072225217863LL,       262144391360893LL,    524288060819213LL,    1048576249040491LL,       2097152266756471LL,   4194304028438527LL,   8388608209001387LL,       16777216572671047LL,  33554432072300339LL,  67108864903274897LL,       134217728402776373LL, 268435456069367221LL, 536870912016065747LL};   const int inf = 1e9, NONE = -1;   const LL llinf = 3e18;   const char *sc2 =  %d%d , *sc3 =  %d%d%d , *sc4 =  %d%d%d%d , *pr2 =  %d %d n ,              *pr3 =  %d %d %d n , *pr4 =  %d %d %d %d n ;   VI factor(int x) {     VI ans;     for (int p = 2; p * p <= x; ++p)       while (x % p == 0) {         ans.push_back(p);         x /= p;       }     if (x > 1) ans.push_back(x);     return ans;   }   template <class T, class B, class C, class D>   auto operator+(pair<T, B> x, pair<C, D> y)       -> pair<decltype(x.first + y.first), decltype(x.second + y.second)> {     return make_pair(x.first + y.first, x.second + y.second);   }   template <class T, class B, class C>   auto operator+(pair<T, B> x, C y)       -> pair<decltype(x.first + y), decltype(x.second + y)> {     return make_pair(x.first + y, x.second + y);   }   template <class T, class C, class D>   auto operator+(T x, pair<C, D> y)       -> pair<decltype(x + y.first), decltype(x + y.second)> {     return make_pair(x + y.first, x + y.second);   }   template <class T, class B, class C, class D>   auto operator-(pair<T, B> x, pair<C, D> y)       -> pair<decltype(x.first - y.first), decltype(x.second - y.second)> {     return make_pair(x.first - y.first, x.second - y.second);   }   template <class T, class B, class C>   auto operator-(pair<T, B> x, C y)       -> pair<decltype(x.first - y), decltype(x.second - y)> {     return make_pair(x.first - y, x.second - y);   }   template <class T, class C, class D>   auto operator-(T x, pair<C, D> y)       -> pair<decltype(x - y.first), decltype(x - y.second)> {     return make_pair(x - y.first, x - y.second);   }   template <class T, class B, class C, class D>   auto operator/(pair<T, B> x, pair<C, D> y)       -> pair<decltype(x.first / y.first), decltype(x.second / y.second)> {     return make_pair(x.first / y.first, x.second / y.second);   }   template <class T, class B, class C>   auto operator/(pair<T, B> x, C y)       -> pair<decltype(x.first / y), decltype(x.second / y)> {     return make_pair(x.first / y, x.second / y);   }   template <class T, class C, class D>   auto operator/(T x, pair<C, D> y)       -> pair<decltype(x / y.first), decltype(x / y.second)> {     return make_pair(x / y.first, x / y.second);   }   template <class T, class B, class C, class D>   auto operator*(pair<T, B> x, pair<C, D> y)       -> pair<decltype(x.first * y.first), decltype(x.second * y.second)> {     return make_pair(x.first * y.first, x.second * y.second);   }   template <class T, class B, class C>   auto operator*(pair<T, B> x, C y)       -> pair<decltype(x.first * y), decltype(x.second * y)> {     return make_pair(x.first * y, x.second * y);   }   template <class T, class C, class D>   auto operator*(T x, pair<C, D> y)       -> pair<decltype(x * y.first), decltype(x * y.second)> {     return make_pair(x * y.first, x * y.second);   }   template <class T, class B, class C, class D>   auto operator%(pair<T, B> x, pair<C, D> y)       -> pair<decltype(x.first % y.first), decltype(x.second % y.second)> {     return make_pair(x.first % y.first, x.second % y.second);   }   template <class T, class B, class C>   auto operator%(pair<T, B> x, C y)       -> pair<decltype(x.first % y), decltype(x.second % y)> {     return make_pair(x.first % y, x.second % y);   }   template <class T, class C, class D>   auto operator%(T x, pair<C, D> y)       -> pair<decltype(x % y.first), decltype(x % y.second)> {     return make_pair(x % y.first, x % y.second);   }   template <class T, class B, class C, class D>   auto operator&(pair<T, B> x, pair<C, D> y)       -> pair<decltype(x.first & y.first), decltype(x.second & y.second)> {     return make_pair(x.first & y.first, x.second & y.second);   }   template <class T, class B, class C>   auto operator&(pair<T, B> x, C y)       -> pair<decltype(x.first & y), decltype(x.second & y)> {     return make_pair(x.first & y, x.second & y);   }   template <class T, class C, class D>   auto operator&(T x, pair<C, D> y)       -> pair<decltype(x & y.first), decltype(x & y.second)> {     return make_pair(x & y.first, x & y.second);   }   template <class T, class B, class C, class D>   auto operator|(pair<T, B> x, pair<C, D> y)       -> pair<decltype(x.first | y.first), decltype(x.second | y.second)> {     return make_pair(x.first | y.first, x.second | y.second);   }   template <class T, class B, class C>   auto operator|(pair<T, B> x, C y)       -> pair<decltype(x.first | y), decltype(x.second | y)> {     return make_pair(x.first | y, x.second | y);   }   template <class T, class C, class D>   auto operator|(T x, pair<C, D> y)       -> pair<decltype(x | y.first), decltype(x | y.second)> {     return make_pair(x | y.first, x | y.second);   }   template <class T, class B, class C, class D>   auto operator^(pair<T, B> x, pair<C, D> y)       -> pair<decltype(x.first ^ y.first), decltype(x.second ^ y.second)> {     return make_pair(x.first ^ y.first, x.second ^ y.second);   }   template <class T, class B, class C>   auto operator^(pair<T, B> x, C y)       -> pair<decltype(x.first ^ y), decltype(x.second ^ y)> {     return make_pair(x.first ^ y, x.second ^ y);   }   template <class T, class C, class D>   auto operator^(T x, pair<C, D> y)       -> pair<decltype(x ^ y.first), decltype(x ^ y.second)> {     return make_pair(x ^ y.first, x ^ y.second);   }   template <class T, class B, class C, class D>   auto operator&&(pair<T, B> x, pair<C, D> y)       -> pair<decltype(x.first && y.first), decltype(x.second && y.second)> {     return make_pair(x.first && y.first, x.second && y.second);   }   template <class T, class B, class C>   auto operator&&(pair<T, B> x, C y)       -> pair<decltype(x.first && y), decltype(x.second && y)> {     return make_pair(x.first && y, x.second && y);   }   template <class T, class C, class D>   auto operator&&(T x, pair<C, D> y)       -> pair<decltype(x && y.first), decltype(x && y.second)> {     return make_pair(x && y.first, x && y.second);   }   template <class T, class B, class C, class D>   auto operator||(pair<T, B> x, pair<C, D> y)       -> pair<decltype(x.first || y.first), decltype(x.second || y.second)> {     return make_pair(x.first || y.first, x.second || y.second);   }   template <class T, class B, class C>   auto operator||(pair<T, B> x, C y)       -> pair<decltype(x.first || y), decltype(x.second || y)> {     return make_pair(x.first || y, x.second || y);   }   template <class T, class C, class D>   auto operator||(T x, pair<C, D> y)       -> pair<decltype(x || y.first), decltype(x || y.second)> {     return make_pair(x || y.first, x || y.second);   }   template <class T, class B>   pair<T, B> &operator++(pair<T, B> &x) {     ++x.first, ++x.second;     return x;   }   template <class T, class B>   pair<T, B> operator++(pair<T, B> &x, int _) {     return make_pair(x.first++, x.second++);   }   template <class T, class B>   pair<T, B> &operator--(pair<T, B> &x) {     --x.first, --x.second;     return x;   }   template <class T, class B>   pair<T, B> operator--(pair<T, B> &x, int _) {     return make_pair(x.first--, x.second--);   }   template <class T, class B, class C, class D>   pair<T, B> &operator+=(pair<T, B> &x, pair<C, D> y) {     x.first += y.first;     x.second += y.second;     return x;   }   template <class T, class B, class C>   pair<T, B> &operator+=(pair<T, B> &x, C y) {     x.first += y;     x.second += y;     return x;   }   template <class T, class B, class C, class D>   pair<T, B> &operator-=(pair<T, B> &x, pair<C, D> y) {     x.first -= y.first;     x.second -= y.second;     return x;   }   template <class T, class B, class C>   pair<T, B> &operator-=(pair<T, B> &x, C y) {     x.first -= y;     x.second -= y;     return x;   }   template <class T, class B, class C, class D>   pair<T, B> &operator*=(pair<T, B> &x, pair<C, D> y) {     x.first *= y.first;     x.second *= y.second;     return x;   }   template <class T, class B, class C>   pair<T, B> &operator*=(pair<T, B> &x, C y) {     x.first *= y;     x.second *= y;     return x;   }   template <class T, class B, class C, class D>   pair<T, B> &operator/=(pair<T, B> &x, pair<C, D> y) {     x.first /= y.first;     x.second /= y.second;     return x;   }   template <class T, class B, class C>   pair<T, B> &operator/=(pair<T, B> &x, C y) {     x.first /= y;     x.second /= y;     return x;   }   template <class T, class B, class C, class D>   pair<T, B> &operator%=(pair<T, B> &x, pair<C, D> y) {     x.first %= y.first;     x.second %= y.second;     return x;   }   template <class T, class B, class C>   pair<T, B> &operator%=(pair<T, B> &x, C y) {     x.first %= y;     x.second %= y;     return x;   }   template <class T, class B, class C, class D>   pair<T, B> &operator^=(pair<T, B> &x, pair<C, D> y) {     x.first ^= y.first;     x.second ^= y.second;     return x;   }   template <class T, class B, class C>   pair<T, B> &operator^=(pair<T, B> &x, C y) {     x.first ^= y;     x.second ^= y;     return x;   }   template <class T, class B, class C, class D>   pair<T, B> &operator&=(pair<T, B> &x, pair<C, D> y) {     x.first &= y.first;     x.second &= y.second;     return x;   }   template <class T, class B, class C>   pair<T, B> &operator&=(pair<T, B> &x, C y) {     x.first &= y;     x.second &= y;     return x;   }   template <class T, class B, class C, class D>   pair<T, B> &operator|=(pair<T, B> &x, pair<C, D> y) {     x.first |= y.first;     x.second |= y.second;     return x;   }   template <class T, class B, class C>   pair<T, B> &operator|=(pair<T, B> &x, C y) {     x.first |= y;     x.second |= y;     return x;   }   template <class T, class B>   auto operator*(pair<T, B> x)       -> pair<typename remove_reference<decltype(*x.first)>::type,               typename remove_reference<decltype(*x.second)>::type> {     return make_pair(*x.first, *x.second);   }   template <class T, class B>   auto operator~(pair<T, B> x)       -> pair<typename remove_reference<decltype(~x.first)>::type,               typename remove_reference<decltype(~x.second)>::type> {     return make_pair(~x.first, ~x.second);   }   template <class T, class B>   auto operator!(pair<T, B> x)       -> pair<typename remove_reference<decltype(!x.first)>::type,               typename remove_reference<decltype(!x.second)>::type> {     return make_pair(!x.first, !x.second);   }   template <class T, class B>   auto operator-(pair<T, B> x)       -> pair<typename remove_reference<decltype(-x.first)>::type,               typename remove_reference<decltype(-x.second)>::type> {     return make_pair(-x.first, -x.second);   }   template <class T>   typename enable_if<is_arithmetic<T>::value, zet_p>::type operator+(zet_p x,                                                                      T y) {     return x + zet_p(y);   }   template <class T>   typename enable_if<is_arithmetic<T>::value, zet_p>::type operator+(T x,                                                                      zet_p y) {     return zet_p(x) + y;   }   template <class T>   zet_p &operator+=(zet_p &x, T y) {     return x = x + y;   }   template <class T>   typename enable_if<is_arithmetic<T>::value, zet_p>::type operator-(zet_p x,                                                                      T y) {     return x - zet_p(y);   }   template <class T>   typename enable_if<is_arithmetic<T>::value, zet_p>::type operator-(T x,                                                                      zet_p y) {     return zet_p(x) - y;   }   template <class T>   zet_p &operator-=(zet_p &x, T y) {     return x = x - y;   }   template <class T>   typename enable_if<is_arithmetic<T>::value, zet_p>::type operator*(zet_p x,                                                                      T y) {     return x * zet_p(y);   }   template <class T>   typename enable_if<is_arithmetic<T>::value, zet_p>::type operator*(T x,                                                                      zet_p y) {     return zet_p(x) * y;   }   template <class T>   zet_p &operator*=(zet_p &x, T y) {     return x = x * y;   }   template <class T>   typename enable_if<is_arithmetic<T>::value, zet_p>::type operator/(zet_p x,                                                                      T y) {     return x / zet_p(y);   }   template <class T>   typename enable_if<is_arithmetic<T>::value, zet_p>::type operator/(T x,                                                                      zet_p y) {     return zet_p(x) / y;   }   template <class T>   zet_p &operator/=(zet_p &x, T y) {     return x = x / y;   }   void jGB4A();   const int MN = 1e5 + 44;   SPII best[MN];   void add(SPII &se, PII val) {     ;     auto pre = se.upper_bound(make_pair(val.first, inf));     pre--;     if (pre->second > val.second) {       ;       return;     }     while (pre != se.end() && pre->second <= val.second) {       if (pre->first >= val.first)         se.erase(pre++);       else         pre++;     }     se.insert(val);     ;   }   int main() {     SPII test;     for (int i = 0; i < (int)(10); i++) test.insert(make_pair(i * 3, i * 3));     add(test, make_pair(6, 6));     add(test, make_pair(6, 7));     add(test, make_pair(6, 6));     add(test, make_pair(0, 7));     ;     ;     ;     ;     cerr << setprecision(10);     int n, m;     scanf( %d%d , &n, &m);     for (int i = 1; i <= (int)(n); i++) {       best[i].insert(make_pair(-inf, 0));     }     for (int i = 0; i < (int)(m); i++) {       int a, b, x;       scanf( %d%d%d , &a, &b, &x);       auto it = best[a].upper_bound(make_pair(x, -inf));       ;       ;       it--;       ;       add(best[b], make_pair(x, it->second + 1));     }     int ans = 0;     for (int i = 1; i <= (int)(n); i++) {       auto l = best[i].end();       l--;       maxi(ans, l->second);     }     printf( %d n , ans);     jGB4A();   }   void jGB4A() {   #pragma GCC diagnostic ignored  -Woverflow      ;     ;     ;     ;     ;     ;     ;     ;     ;     ;     while (deb && getchar() != EOF)       ;     exit(0);   }   