backup

src/bin/cf-1834e.cc

@@ -0,0 +1,423 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+#if LONG_LONG_MAX != INT64_MAX
+using ll = int64_t;
+using ull = uint64_t;
+#else
+using ll = long long;
+using ull = unsigned long long;
+using ld = long double;
+#endif
+using int128 = __int128_t;
+using uint128 = __uint128_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+constexpr int128 INT128_MAX = numeric_limits<int128>::max();
+constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
+constexpr int128 INT128_MIN = numeric_limits<int128>::min();
+constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+uniform_int_distribution<mt19937::result_type> dist(PRIME);
+const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
+struct array_hash {
+    template <typename Sequence>
+    size_t operator()(const Sequence& arr) const {
+        size_t pw1 = 1, pw2 = 1;
+        size_t res1 = 0, res2 = 0;
+        for (auto&& x : arr) {
+            res1 = (res1 + x * pw1) % __array_hash_mdl1;
+            res2 = (res2 + x * pw2) % __array_hash_mdl2;
+            pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
+            pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
+        }
+        return res1 + res2;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
+#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+std::ostream& operator<<(std::ostream& dest, const int128& value) {
+    // https://stackoverflow.com/a/25115163/23881100
+    std::ostream::sentry s( dest );
+    if ( s ) {
+        uint128 tmp = value < 0 ? -value : value;
+        char buffer[ 128 ];
+        char* d = std::end( buffer );
+        do {
+            -- d;
+            *d = "0123456789"[ tmp % 10 ];
+            tmp /= 10;
+        } while ( tmp != 0 );
+        if ( value < 0 ) {
+            -- d;
+            *d = '-';
+        }
+        int len = std::end( buffer ) - d;
+        if ( dest.rdbuf()->sputn( d, len ) != len ) {
+            dest.setstate( std::ios_base::badbit );
+        }
+    }
+    return dest;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+
+/* modular arithmetic */
+template <ll mdl> struct MLL {
+    ll val;
+    MLL(ll v = 0) : val(mod(v, mdl)) {}
+    MLL(const MLL<mdl>& other) : val(other.val) {}
+    friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
+    friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
+    friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
+    friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
+    friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
+    friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
+    friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
+    void operator+=(const MLL& rhs) { val = (*this + rhs).val; }
+    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+};
+
+template <ll mdl>
+ostream& operator<<(ostream& out, const MLL<mdl>& num) {
+    return out << num.val;
+}
+
+template <ll mdl>
+istream& operator>>(istream& in, MLL<mdl>& num) {
+    return in >> num.val;
+}
+/////////////////////////////////////////////////////////
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {}
+
+void solve() {
+    read(int, n);
+    readvec(int, b, n);
+    vector<int> a;
+    bool has_1 = 0;
+    for (int i = 0; i < n; ++i) {
+        if (b[i] == 1) {
+            has_1 = 1;
+        } else {
+            a.emplace_back(b[i]);
+        }
+    }
+    int m = a.size();
+    vector<int> next(m);
+    vector<int> st;
+    for (int i = m - 1; ~i; --i) {
+        while (st.size() and gcd(a[i], a[st.back()]) == a[st.back()]) {
+            st.pop_back();
+        }
+        if (not st.size()) {
+            next[i] = m;
+        } else {
+            next[i] = st.back();
+        }
+        st.emplace_back(i);
+    }
+    int ub = 20 * m + 200;
+    vector<vector<ll>> ss_lcm(m);
+    vector<bool> has(ub);
+    if (has_1) has[1] = 1;
+    for (int i = m - 1; ~i; --i) {
+        if (a[i] >= ub) continue;
+        has[a[i]] = 1;
+        ss_lcm[i].emplace_back(a[i]);
+        if (next[i] == m) continue;
+        int prev = 0;
+        for (auto&& u : ss_lcm[next[i]]) {
+            ll curr = lcm(a[i], u);
+            if (curr >= ub) break;
+            if (curr != prev) {
+                has[curr] = 1;
+                ss_lcm[i].emplace_back(curr);
+                prev = curr;
+            }
+        }
+    }
+    for (int i = 1; i < ub; ++i) {
+        if (not has[i]) {
+            cout << i << '\n';
+            return;
+        }
+    }
+    assert(false);
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t < (DUMP_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1861e.cc

@@ -0,0 +1,392 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+#if LONG_LONG_MAX != INT64_MAX
+using ll = int64_t;
+using ull = uint64_t;
+#else
+using ll = long long;
+using ull = unsigned long long;
+using ld = long double;
+#endif
+using int128 = __int128_t;
+using uint128 = __uint128_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+constexpr int128 INT128_MAX = numeric_limits<int128>::max();
+constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
+constexpr int128 INT128_MIN = numeric_limits<int128>::min();
+constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+uniform_int_distribution<mt19937::result_type> dist(PRIME);
+const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
+struct array_hash {
+    template <typename Sequence>
+    size_t operator()(const Sequence& arr) const {
+        size_t pw1 = 1, pw2 = 1;
+        size_t res1 = 0, res2 = 0;
+        for (auto&& x : arr) {
+            res1 = (res1 + x * pw1) % __array_hash_mdl1;
+            res2 = (res2 + x * pw2) % __array_hash_mdl2;
+            pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
+            pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
+        }
+        return res1 + res2;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
+#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+std::ostream& operator<<(std::ostream& dest, const int128& value) {
+    // https://stackoverflow.com/a/25115163/23881100
+    std::ostream::sentry s( dest );
+    if ( s ) {
+        uint128 tmp = value < 0 ? -value : value;
+        char buffer[ 128 ];
+        char* d = std::end( buffer );
+        do {
+            -- d;
+            *d = "0123456789"[ tmp % 10 ];
+            tmp /= 10;
+        } while ( tmp != 0 );
+        if ( value < 0 ) {
+            -- d;
+            *d = '-';
+        }
+        int len = std::end( buffer ) - d;
+        if ( dest.rdbuf()->sputn( d, len ) != len ) {
+            dest.setstate( std::ios_base::badbit );
+        }
+    }
+    return dest;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+
+/* modular arithmetic */
+template <ll mdl> struct MLL {
+    ll val;
+    MLL(ll v = 0) : val(mod(v, mdl)) {}
+    MLL(const MLL<mdl>& other) : val(other.val) {}
+    friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
+    friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
+    friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
+    friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
+    friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
+    friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
+    friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
+    void operator+=(const MLL& rhs) { val = (*this + rhs).val; }
+    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+};
+
+template <ll mdl>
+ostream& operator<<(ostream& out, const MLL<mdl>& num) {
+    return out << num.val;
+}
+
+template <ll mdl>
+istream& operator>>(istream& in, MLL<mdl>& num) {
+    return in >> num.val;
+}
+/////////////////////////////////////////////////////////
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+
+void dump() {}
+
+void dump_ignore() {}
+
+constexpr int MAXN = 4090;
+using mll = MLL<PRIME>;
+mll fact[MAXN];
+void prep() {
+    fact[0] = 1;
+    for (int i = 1; i < MAXN; ++i) {
+        fact[i] = fact[i - 1] * i;
+    }
+}
+
+mll comb(int n, int k) {
+    if (n < 0 or k < 0 or n < k) return 0;
+    return fact[n] / fact[k] / fact[n - k];
+}
+
+void solve() {
+    read(int, n, k);
+    vector<mll> cstr(n + 1);
+    for (int i = 1; i <= n; ++i) {
+        mll curr = 0;
+        for (int j = 1; j <= n / k; ++j) {
+            
+        }
+    }
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t < (DUMP_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1870e.cc

@@ -0,0 +1,446 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+#if LONG_LONG_MAX != INT64_MAX
+using ll = int64_t;
+using ull = uint64_t;
+#else
+using ll = long long;
+using ull = unsigned long long;
+using ld = long double;
+#endif
+using int128 = __int128_t;
+using uint128 = __uint128_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+constexpr int128 INT128_MAX = numeric_limits<int128>::max();
+constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
+constexpr int128 INT128_MIN = numeric_limits<int128>::min();
+constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+uniform_int_distribution<mt19937::result_type> dist(PRIME);
+const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
+struct array_hash {
+    template <typename Sequence>
+    size_t operator()(const Sequence& arr) const {
+        size_t pw1 = 1, pw2 = 1;
+        size_t res1 = 0, res2 = 0;
+        for (auto&& x : arr) {
+            res1 = (res1 + x * pw1) % __array_hash_mdl1;
+            res2 = (res2 + x * pw2) % __array_hash_mdl2;
+            pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
+            pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
+        }
+        return res1 + res2;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
+#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+std::ostream& operator<<(std::ostream& dest, const int128& value) {
+    // https://stackoverflow.com/a/25115163/23881100
+    std::ostream::sentry s( dest );
+    if ( s ) {
+        uint128 tmp = value < 0 ? -value : value;
+        char buffer[ 128 ];
+        char* d = std::end( buffer );
+        do {
+            -- d;
+            *d = "0123456789"[ tmp % 10 ];
+            tmp /= 10;
+        } while ( tmp != 0 );
+        if ( value < 0 ) {
+            -- d;
+            *d = '-';
+        }
+        int len = std::end( buffer ) - d;
+        if ( dest.rdbuf()->sputn( d, len ) != len ) {
+            dest.setstate( std::ios_base::badbit );
+        }
+    }
+    return dest;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+
+/* modular arithmetic */
+template <ll mdl> struct MLL {
+    ll val;
+    MLL(ll v = 0) : val(mod(v, mdl)) {}
+    MLL(const MLL<mdl>& other) : val(other.val) {}
+    friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
+    friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
+    friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
+    friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
+    friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
+    friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
+    friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
+    void operator+=(const MLL& rhs) { val = (*this + rhs).val; }
+    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+};
+
+template <ll mdl>
+ostream& operator<<(ostream& out, const MLL<mdl>& num) {
+    return out << num.val;
+}
+
+template <ll mdl>
+istream& operator>>(istream& in, MLL<mdl>& num) {
+    return in >> num.val;
+}
+/////////////////////////////////////////////////////////
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {}
+
+constexpr int MAXN = 10000;
+int trace[63], trace_n;
+int l[MAXN], trie[MAXN][2], trie_n;
+
+void insert(int x, int left) {
+    int curr = 0;
+    trace_n = 0;
+    trace[trace_n++] = 0;
+    for (int i = 13; ~i; --i) {
+        int bit = (x >> i) & 1;
+        if (not trie[curr][bit]) {
+            trie[curr][bit] = trie_n;
+            trie[trie_n][0] = 0, trie[trie_n][1] = 0, ++trie_n;
+        }
+        curr = trie[curr][bit];
+        trace[trace_n++] = curr;
+    }
+    for (int i = 0; i < trace_n; ++i) {
+        l[trace[i]] = max(l[trace[i]], left);
+    }
+}
+
+int range_max_xor(int x, int min_left) {
+    int curr = 0;
+    int res = 0;
+    for (int i = 13; ~i; --i) {
+        int o = 1 ^ ((x >> i) & 1);
+        int better = trie[curr][o], common = trie[curr][1 ^ o];
+        if (better and l[better] >= min_left) {
+            curr = better;
+            res |= o << i;
+        } else if (common and l[common] >= min_left){
+            curr = common;
+            res |= (1 ^ o) << i;
+        } else {
+            // no solution
+            return x;
+        }
+    }
+    return res;
+}
+
+int has[MAXN], mexs[MAXN];
+
+void solve() {
+    read(int, n);
+    readvec(int, a, n);
+    int high = lg2(n) + 1;
+    int m = 1 << high;
+    vector<int> first_oc(m, -1);
+    first_oc[0] = -2;
+    int res = 0;
+    for (int i = 0; i < n; ++i) {
+        memset(has, 0, (n + 2) * sizeof(int));
+        memset(mexs, 0, (n + 2) * sizeof(int));
+        int ptr = 0;
+        for (int j = 0; j < trie_n; ++j) l[j] = 0;
+        trie_n = 1;
+        trie[0][0] = 0, trie[0][1] = 0;
+        for (int j = i; ~j; --j) {
+            has[a[j]] = 1;
+            while (has[ptr]) ++ptr;  // tot: O(n)
+            int curr_mex = ptr;
+            insert(curr_mex, j);  // PERF: O(logn)
+            mexs[curr_mex] = 1;
+        }
+        for (int j = 0; j < m; ++j) {
+            if (first_oc[j] == -1) continue;
+            int pos = first_oc[j];
+            int q = range_max_xor(j, pos + 1);  // PERF: O(logn)
+            res = max(res, j ^ q);
+        }
+        for (int j = 0; j < m; ++j) {
+        }
+    }
+    cout << res << '\n';
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t < (DUMP_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1874c.cc

@@ -0,0 +1,402 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+#if LONG_LONG_MAX != INT64_MAX
+using ll = int64_t;
+using ull = uint64_t;
+#else
+using ll = long long;
+using ull = unsigned long long;
+#endif
+using ld = long double;
+using int128 = __int128_t;
+using uint128 = __uint128_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+constexpr int128 INT128_MAX = numeric_limits<int128>::max();
+constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
+constexpr int128 INT128_MIN = numeric_limits<int128>::min();
+constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+uniform_int_distribution<mt19937::result_type> dist(PRIME);
+const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
+struct array_hash {
+    template <typename Sequence>
+    size_t operator()(const Sequence& arr) const {
+        size_t pw1 = 1, pw2 = 1;
+        size_t res1 = 0, res2 = 0;
+        for (auto&& x : arr) {
+            res1 = (res1 + x * pw1) % __array_hash_mdl1;
+            res2 = (res2 + x * pw2) % __array_hash_mdl2;
+            pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
+            pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
+        }
+        return res1 + res2;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
+#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+std::ostream& operator<<(std::ostream& dest, const int128& value) {
+    // https://stackoverflow.com/a/25115163/23881100
+    std::ostream::sentry s( dest );
+    if ( s ) {
+        uint128 tmp = value < 0 ? -value : value;
+        char buffer[ 128 ];
+        char* d = std::end( buffer );
+        do {
+            -- d;
+            *d = "0123456789"[ tmp % 10 ];
+            tmp /= 10;
+        } while ( tmp != 0 );
+        if ( value < 0 ) {
+            -- d;
+            *d = '-';
+        }
+        int len = std::end( buffer ) - d;
+        if ( dest.rdbuf()->sputn( d, len ) != len ) {
+            dest.setstate( std::ios_base::badbit );
+        }
+    }
+    return dest;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+
+/* modular arithmetic */
+template <ll mdl> struct MLL {
+    ll val;
+    MLL(ll v = 0) : val(mod(v, mdl)) {}
+    MLL(const MLL<mdl>& other) : val(other.val) {}
+    friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
+    friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
+    friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
+    friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
+    friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
+    friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
+    friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
+    void operator+=(const MLL& rhs) { val = (*this + rhs).val; }
+    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+};
+
+template <ll mdl>
+ostream& operator<<(ostream& out, const MLL<mdl>& num) {
+    return out << num.val;
+}
+
+template <ll mdl>
+istream& operator>>(istream& in, MLL<mdl>& num) {
+    return in >> num.val;
+}
+/////////////////////////////////////////////////////////
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {}
+
+void solve() {
+    read(int, n, m);
+    adj(ch, n);
+    vector<int> ind(n + 1);
+    while (m--) {
+        read(int, u, v);
+        Edge(ch, v, u);
+        ind[u] += 1;
+    }
+    vector<ld> dp(n + 1);
+    vector<vector<ld>> son(n + 1);
+    deque<int> q;
+    for (int i = 1; i <= n; ++i) {
+        if (ind[i] == 0) {
+            q.emplace_back(i);
+        }
+    }
+    while (q.size()) {
+        int v = q.front(); q.pop_front();
+        if (v == n) {
+            dp[v] = 1;
+        } else {
+            sort(son[v].begin(), son[v].end(), greater<>());
+            // greedily choose the greatest element
+            int l = son[v].size();
+            for (int i = 0; i < l; ++i) {
+                for (int j = 0; j <= l; ++j) {
+                    
+                }
+            }
+        }
+    }
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t < (DUMP_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1878f.cc

@@ -0,0 +1,437 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+#if LONG_LONG_MAX != INT64_MAX
+using ll = int64_t;
+using ull = uint64_t;
+#else
+using ll = long long;
+using ull = unsigned long long;
+using ld = long double;
+#endif
+using int128 = __int128_t;
+using uint128 = __uint128_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+constexpr int128 INT128_MAX = numeric_limits<int128>::max();
+constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
+constexpr int128 INT128_MIN = numeric_limits<int128>::min();
+constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+uniform_int_distribution<mt19937::result_type> dist(PRIME);
+const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
+struct array_hash {
+    template <typename Sequence>
+    size_t operator()(const Sequence& arr) const {
+        size_t pw1 = 1, pw2 = 1;
+        size_t res1 = 0, res2 = 0;
+        for (auto&& x : arr) {
+            res1 = (res1 + x * pw1) % __array_hash_mdl1;
+            res2 = (res2 + x * pw2) % __array_hash_mdl2;
+            pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
+            pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
+        }
+        return res1 + res2;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
+#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+std::ostream& operator<<(std::ostream& dest, const int128& value) {
+    // https://stackoverflow.com/a/25115163/23881100
+    std::ostream::sentry s( dest );
+    if ( s ) {
+        uint128 tmp = value < 0 ? -value : value;
+        char buffer[ 128 ];
+        char* d = std::end( buffer );
+        do {
+            -- d;
+            *d = "0123456789"[ tmp % 10 ];
+            tmp /= 10;
+        } while ( tmp != 0 );
+        if ( value < 0 ) {
+            -- d;
+            *d = '-';
+        }
+        int len = std::end( buffer ) - d;
+        if ( dest.rdbuf()->sputn( d, len ) != len ) {
+            dest.setstate( std::ios_base::badbit );
+        }
+    }
+    return dest;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+
+/* modular arithmetic */
+template <ll mdl> struct MLL {
+    ll val;
+    MLL(ll v = 0) : val(mod(v, mdl)) {}
+    MLL(const MLL<mdl>& other) : val(other.val) {}
+    friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
+    friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
+    friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
+    friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
+    friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
+    friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
+    friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
+    void operator+=(const MLL& rhs) { val = (*this + rhs).val; }
+    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+};
+
+template <ll mdl>
+ostream& operator<<(ostream& out, const MLL<mdl>& num) {
+    return out << num.val;
+}
+
+template <ll mdl>
+istream& operator>>(istream& in, MLL<mdl>& num) {
+    return in >> num.val;
+}
+/////////////////////////////////////////////////////////
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+vector<pii> decompose_prime(int N) {
+    // return (factor, count)
+    vector<pii> result;
+    for (int i = 2; i * i <= N; i++) {
+        if (N % i == 0) {
+            int cnt = 0;
+            while (N % i == 0) N /= i, ++cnt;
+            result.emplace_back(i, cnt);
+        }
+    }
+    if (N != 1) {
+        result.emplace_back(N, 1);
+    }
+    return result;
+}
+
+void solve() {
+    unordered_map<int, int, safe_hash> bk, raw_bk, set_tm;
+    read(int, n, q);
+    ll prod = 1;
+    // debugvec(decompose_prime(n));
+    for (auto&& [x, i] : decompose_prime(n)) {
+        prod *= i + 1;
+        raw_bk[x] = i;
+        bk[x] = i;
+    }
+    ll raw_prod = prod;
+    int last_tm = 0, tm = 0;
+    while (q--) {
+        tm += 1;
+        read(int, op);
+        if (op == 1) {
+            read(int, x);
+            for (auto&& [y, i] : decompose_prime(x)) {
+                if (set_tm[y] < last_tm) {
+                    bk[y] = raw_bk[y];
+                }
+                prod /= (bk[y] + 1);
+                bk[y] += i;
+                set_tm[y] = tm;
+                prod *= (bk[y] + 1);
+            }
+            int f = 1;
+            for (auto&& [y, i] : decompose_prime(prod)) {
+                if (set_tm[y] < last_tm) {
+                    bk[y] = raw_bk[y];
+                    set_tm[y] = tm;
+                }
+                if (i < bk[y]) {
+                    // f = 1;
+                } else if (i > bk[y]) {
+                    f = 0;
+                    break;
+                }
+            }
+            if (f) {
+                cout << "YES\n";
+            } else {
+                cout << "NO\n";
+            }
+        } else {
+            last_tm = tm;
+            prod = raw_prod;
+        }
+    }
+    cout << endl;
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t < (DUMP_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1879d.cc

@@ -1,31 +1,69 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
 #include<bits/stdc++.h>
-#include <initializer_list>
 using namespace std;
 
+/* macro helpers */
 #define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
-#define __decompose_s(a, x) auto x = a;
+#define __DECOMPOSE_S(a, x) auto x = a;
-#define __decompose_n(a, ...) auto [__VA_ARGS__] = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
 
+/* type aliases */
+#if LONG_LONG_MAX != INT64_MAX
 using ll = int64_t;
 using ull = uint64_t;
+#else
+using ll = long long;
+using ull = unsigned long long;
+using ld = long double;
+#endif
+using int128 = __int128_t;
+using uint128 = __uint128_t;
 using pii = pair<int, int>;
 using pil = pair<int, ll>;
 using pli = pair<ll, int>;
 using pll = pair<ll, ll>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
 
-constexpr ull MDL = 1e9 + 7;
+/* constants */
-constexpr ull PRIME = 998244353;
+constexpr int INF = 0x3f3f3f3f;
-constexpr ull MDL1 = 825;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
-constexpr ull MDL2 = 87825;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+constexpr int128 INT128_MAX = numeric_limits<int128>::max();
+constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
+constexpr int128 INT128_MIN = numeric_limits<int128>::min();
+constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
 
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
 #define lowbit(x) ((x) & -(x))
 #define popcount(x) (__builtin_popcountll(ll(x)))
 #define parity(x) (__builtin_parityll(ll(x)))
 #define msp(x) (63LL - __builtin_clzll(ll(x)))
 #define lsp(x) (__builtin_ctzll(ll(x)))
 
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
 #define upair ull
-#define umake(x, y) (ull(x) << 32 | ull(y))
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
 #define u1(p) ((p) >> 32)
 #define u2(p) ((p) & ((1ULL << 32) - 1))
 #define ult std::less<upair>
@@ -33,8 +71,8 @@ constexpr ull MDL2 = 87825;
 
 #define ipair ull
 #define imake(x, y) (umake(x, y))
-#define i1(p) (int(u1(p)))
+#define i1(p) (int(u1(ll(p))))
-#define i2(p) (int(u2(p)))
+#define i2(p) (ll(u2(p) << 32) >> 32)
 struct ilt {
     bool operator()(const ipair& a, const ipair& b) const {
         if (i1(a) == i1(b)) return i2(a) < i2(b);
@@ -48,63 +86,302 @@ struct igt {
     }
 };
 
-#define untie ios_base::sync_with_stdio(0), cin.tie(NULL)
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+uniform_int_distribution<mt19937::result_type> dist(PRIME);
+const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
+struct array_hash {
+    template <typename Sequence>
+    size_t operator()(const Sequence& arr) const {
+        size_t pw1 = 1, pw2 = 1;
+        size_t res1 = 0, res2 = 0;
+        for (auto&& x : arr) {
+            res1 = (res1 + x * pw1) % __array_hash_mdl1;
+            res2 = (res2 + x * pw2) % __array_hash_mdl2;
+            pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
+            pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
+        }
+        return res1 + res2;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
+#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
 template<typename T> void __read(T& x) { cin >> x; }
 template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
-#define read(type, ...) type __VA_ARGS__; __read(__VA_ARGS__);
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
-#define readvec(type, a, n) vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
-#define putvec(a) for (auto&& x : a) cout << x << ' '; cout << endl;
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
-#define debug(x) cerr << #x" = " << x << endl;
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
-#define debugvec(a) cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+std::ostream& operator<<(std::ostream& dest, const int128& value) {
+    // https://stackoverflow.com/a/25115163/23881100
+    std::ostream::sentry s( dest );
+    if ( s ) {
+        uint128 tmp = value < 0 ? -value : value;
+        char buffer[ 128 ];
+        char* d = std::end( buffer );
+        do {
+            -- d;
+            *d = "0123456789"[ tmp % 10 ];
+            tmp /= 10;
+        } while ( tmp != 0 );
+        if ( value < 0 ) {
+            -- d;
+            *d = '-';
+        }
+        int len = std::end( buffer ) - d;
+        if ( dest.rdbuf()->sputn( d, len ) != len ) {
+            dest.setstate( std::ios_base::badbit );
+        }
+    }
+    return dest;
+}
 
-#define pa(a) __typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);
+/* pops */
-#define sa(a) __typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
 
-#define poptop(q, ...) auto [__VA_ARGS__] = q.top(); q.pop();
+/* math */
-#define popback(q, ...) auto [__VA_ARGS__] = q.back(); q.pop_back();
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
-#define popfront(q, ...) auto [__VA_ARGS__] = q.front();q.pop_front();
 
-#define adj(ch, n) vector<vector<int>> ch((n) + 1);
+void __exgcd(ll a, ll b, ll& x, ll& y) {
-#define edge(ch, u, v) ch[u].push_back(v), ch[v].push_back(u);
+  if (b == 0) {
-#define Edge(ch, u, v) ch[u].push_back(v);
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
 
-vector<int> kmp(string s, string t) {  // find all t in s
+ll inverse(ll a, ll b) {
-    int n = s.length(), m = t.length();
+    ll x, y;
-    vector<int> next; next.push_back(-1);
+    __exgcd(a, b, x, y);
-    int j = -1, i = 0;
+    return mod(x, b);
-    while (i < m)
+}
-        if (j == -1 || t[i] == t[j]) {
+
-            ++i, ++j;
+vector<tuple<int, int, ll>> decompose(ll x) {
-            if (i != m && t[i] == t[j]) next.push_back(next[j]);
+    vector<tuple<int, int, ll>> res;
-            else next.push_back(j);
+    for (int i = 2; i * i <= x; i++) {
-        } else j = next[j];
+        if (x % i == 0) {
-    vector<int> res;
+            int cnt = 0;
-    i = 0, j = 0;
+            ll pw = 1;
-    while (i < n && j < m)
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
-        if (j == -1 || s[i] == t[j]) {
+            res.emplace_back(i, cnt, pw);
-            ++i, ++j;
+        }
-            if (j == m) res.push_back(i - j), j = next[j];
+    }
-        } else j = next[j];
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
     return res;
 }
 
-int main() {
+/* string algorithms */
-    read(int, n);
+vector<int> calc_next(string t) {  // pi function of t
-    readvec(ull, a, n);
+  int n = (int)t.length();
-    ull s1, s2, s3, s4, pa;
+  vector<int> pi(n);
-
+  for (int i = 1; i < n; i++) {
-    s1 = s2 = 0, pa = 0;
+    int j = pi[i - 1];
-    for (int i = 0; i < n; ++i) {
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
-        pa ^= a[i];
+    if (t[i] == t[j]) j++;
-        s1 = (s1 + (i + 1) * pa) % PRIME;
+    pi[i] = j;
-        s2 = (s2 + pa) % PRIME;
+  }
-    }
+  return pi;
-    s3 = s4 = 0, pa = 0;
+}
-    for (int i = 0; i < n; ++i) {
+vector<int> calc_z(string t) {  // z function of t
-        s3 = (s3 + i * pa) % PRIME;
+    int m = t.length();
-        s4 = (s4 + pa) % PRIME;
+    vector<int> z;
-        pa ^= a[i];
+    z.push_back(m);
-    }
+    pair<int, int> prev = {1, -1};
-    ull res = n * s1 - n * (n - 1) / 2 * s2 + n * s3 - n * (n + 1) / 2 * s4;
+    for (int i = 1; i < m; ++i) {
-    cout << (res % PRIME);
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+
+/* modular arithmetic */
+template <ll mdl> struct MLL {
+    ll val;
+    MLL(ll v = 0) : val(mod(v, mdl)) {}
+    MLL(const MLL<mdl>& other) : val(other.val) {}
+    friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
+    friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
+    friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
+    friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
+    friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
+    friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
+    friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
+    void operator+=(const MLL& rhs) { val = (*this + rhs).val; }
+    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+};
+
+template <ll mdl>
+ostream& operator<<(ostream& out, const MLL<mdl>& num) {
+    return out << num.val;
+}
+
+template <ll mdl>
+istream& operator>>(istream& in, MLL<mdl>& num) {
+    return in >> num.val;
+}
+/////////////////////////////////////////////////////////
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {}
+
+void solve() {
+    using mll = MLL<PRIME>;
+    read(int, n);
+    readvec(int, a, n);
+    mll res = 0;
+    for (int b = 0; b < 31; ++b) {
+        array<int, 2> cnt {1, 0};
+        array<mll, 2> sum {0, 0};
+        int curr = 0;
+        for (int i = 1; i <= n; ++i) {
+            curr ^= (a[i - 1] >> b) & 1;
+            res += mll(1) * (1 << b) * (mll(1) * cnt[1 ^ curr] * i - sum[1 ^ curr]);
+            cnt[curr] += 1;
+            sum[curr] += i;
+        }
+    }
+    cout << res << '\n';
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t < (DUMP_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
 }

src/bin/cf-1882d.cc

@@ -0,0 +1,426 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+#if LONG_LONG_MAX != INT64_MAX
+using ll = int64_t;
+using ull = uint64_t;
+#else
+using ll = long long;
+using ull = unsigned long long;
+using ld = long double;
+#endif
+using int128 = __int128_t;
+using uint128 = __uint128_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+constexpr int128 INT128_MAX = numeric_limits<int128>::max();
+constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
+constexpr int128 INT128_MIN = numeric_limits<int128>::min();
+constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+uniform_int_distribution<mt19937::result_type> dist(PRIME);
+const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
+struct array_hash {
+    template <typename Sequence>
+    size_t operator()(const Sequence& arr) const {
+        size_t pw1 = 1, pw2 = 1;
+        size_t res1 = 0, res2 = 0;
+        for (auto&& x : arr) {
+            res1 = (res1 + x * pw1) % __array_hash_mdl1;
+            res2 = (res2 + x * pw2) % __array_hash_mdl2;
+            pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
+            pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
+        }
+        return res1 + res2;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
+#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+std::ostream& operator<<(std::ostream& dest, const int128& value) {
+    // https://stackoverflow.com/a/25115163/23881100
+    std::ostream::sentry s( dest );
+    if ( s ) {
+        uint128 tmp = value < 0 ? -value : value;
+        char buffer[ 128 ];
+        char* d = std::end( buffer );
+        do {
+            -- d;
+            *d = "0123456789"[ tmp % 10 ];
+            tmp /= 10;
+        } while ( tmp != 0 );
+        if ( value < 0 ) {
+            -- d;
+            *d = '-';
+        }
+        int len = std::end( buffer ) - d;
+        if ( dest.rdbuf()->sputn( d, len ) != len ) {
+            dest.setstate( std::ios_base::badbit );
+        }
+    }
+    return dest;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+
+/* modular arithmetic */
+template <ll mdl> struct MLL {
+    ll val;
+    MLL(ll v = 0) : val(mod(v, mdl)) {}
+    MLL(const MLL<mdl>& other) : val(other.val) {}
+    friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
+    friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
+    friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
+    friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
+    friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
+    friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
+    friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
+    void operator+=(const MLL& rhs) { val = (*this + rhs).val; }
+    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+};
+
+template <ll mdl>
+ostream& operator<<(ostream& out, const MLL<mdl>& num) {
+    return out << num.val;
+}
+
+template <ll mdl>
+istream& operator>>(istream& in, MLL<mdl>& num) {
+    return in >> num.val;
+}
+/////////////////////////////////////////////////////////
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {}
+
+void solve() {
+    read(int, n);
+    vector<int> a(n + 1);
+    for (int i = 1; i <= n; ++i) cin >> a[i];
+    vector<int> sz(n + 1);
+    adj(ch, n);
+    for (int i = 0; i < n - 1; ++i) {
+        read(int, u, v);
+        edge(ch, u, v);
+    }
+    auto get = [&] (auto get, int v, int pa) -> void {
+        sz[v] = 1;
+        for (auto&& u : ch[v]) {
+            if (u == pa) continue;
+            get(get, u, v);
+            sz[v] += sz[u];
+        }
+    };
+    get(get, 1, 0);
+    vector<ll> in(n + 1), out(n + 1);
+    auto dfs = [&] (auto dfs, int v, int pa) -> void {
+        out[v] += ll(1) * sz[v] * (a[v] ^ a[pa]);
+        for (auto&& u : ch[v]) {
+            if (u == pa) continue;
+            dfs(dfs, u, v);
+            in[u] += ll(1) * (n - sz[u]) * (a[v] ^ a[u]);
+        }
+    };
+    dfs(dfs, 1, 0);
+    // debug(in), debug(out);
+    vector<ll> res(n + 1);
+    vector<ll> subtree_out(n + 1);
+    auto dfs3 = [&] (auto dfs3, int v, int pa) -> ll {
+        subtree_out[v] = out[v];
+        for (auto&& u : ch[v]) {
+            if (u == pa) continue;
+            subtree_out[v] += dfs3(dfs3, u, v);
+        }
+        return subtree_out[v];
+    };
+    dfs3(dfs3, 1, 0);
+    auto dfs2 = [&] (auto dfs2, int v, int pa, ll prev) -> void {
+        prev += in[v];
+        ll tot_out = 0;
+        for (auto&& u : ch[v]) {
+            if (u == pa) continue;
+            tot_out += subtree_out[u];
+        }
+        res[v] = prev + tot_out;
+        for (auto&& u : ch[v]) {
+            if (u == pa) continue;
+            dfs2(dfs2, u, v, prev + tot_out - subtree_out[u]);
+        }
+    };
+    dfs2(dfs2, 1, 0, 0);
+    for (int i = 1; i <= n; ++i) cout << res[i] << " \n"[i == n];
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t < (DUMP_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-938d.cc

@@ -0,0 +1,402 @@
+#pragma GCC optimize("Ofast")
+/////////////////////////////////////////////////////////
+/**
+ * Useful Macros
+ *   by subcrip
+ * (requires C++17)
+ */
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* macro helpers */
+#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
+#define __DECOMPOSE_S(a, x) auto x = a;
+#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
+constexpr void __() {}
+#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
+#define __as_typeof(container) decltype(container)::value_type
+
+/* type aliases */
+#if LONG_LONG_MAX != INT64_MAX
+using ll = int64_t;
+using ull = uint64_t;
+#else
+using ll = long long;
+using ull = unsigned long long;
+using ld = long double;
+#endif
+using int128 = __int128_t;
+using uint128 = __uint128_t;
+using pii = pair<int, int>;
+using pil = pair<int, ll>;
+using pli = pair<ll, int>;
+using pll = pair<ll, ll>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+
+/* constants */
+constexpr int INF = 0x3f3f3f3f;
+constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
+constexpr ll MDL = 1e9 + 7;
+constexpr ll PRIME = 998'244'353;
+constexpr ll MDL1 = 8784491;
+constexpr ll MDL2 = PRIME;
+constexpr int128 INT128_MAX = numeric_limits<int128>::max();
+constexpr uint128 UINT128_MAX = numeric_limits<uint128>::max();
+constexpr int128 INT128_MIN = numeric_limits<int128>::min();
+constexpr uint128 UINT128_MIN = numeric_limits<uint128>::min();
+
+/* random */
+
+mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
+
+/* bit-wise operations */
+#define lowbit(x) ((x) & -(x))
+#define popcount(x) (__builtin_popcountll(ll(x)))
+#define parity(x) (__builtin_parityll(ll(x)))
+#define msp(x) (63LL - __builtin_clzll(ll(x)))
+#define lsp(x) (__builtin_ctzll(ll(x)))
+
+/* arithmetic operations */
+#define mod(x, y) ((((x) % (y)) + (y)) % (y))
+
+/* fast pairs */
+#define upair ull
+#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
+#define u1(p) ((p) >> 32)
+#define u2(p) ((p) & ((1ULL << 32) - 1))
+#define ult std::less<upair>
+#define ugt std::greater<upair>
+
+#define ipair ull
+#define imake(x, y) (umake(x, y))
+#define i1(p) (int(u1(ll(p))))
+#define i2(p) (ll(u2(p) << 32) >> 32)
+struct ilt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) < i2(b);
+        else return i1(a) < i1(b);
+    }
+};
+struct igt {
+    bool operator()(const ipair& a, const ipair& b) const {
+        if (i1(a) == i1(b)) return i2(a) > i2(b);
+        else return i1(a) > i1(b);
+    }
+};
+
+/* conditions */
+#define loop while (1)
+#define if_or(var, val) if (!(var == val)) var = val; else
+#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
+#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
+
+/* hash */
+struct safe_hash {
+    // https://codeforces.com/blog/entry/62393
+    static uint64_t splitmix64(uint64_t x) {
+        // http://xorshift.di.unimi.it/splitmix64.c
+        x += 0x9e3779b97f4a7c15;
+        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+        return x ^ (x >> 31);
+    }
+
+    size_t operator()(uint64_t x) const {
+        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
+        return splitmix64(x + FIXED_RANDOM);
+    }
+};
+
+struct pair_hash {
+    template <typename T, typename U>
+    size_t operator()(const pair<T, U>& a) const {
+        auto hash1 = safe_hash()(a.first);
+        auto hash2 = safe_hash()(a.second);
+        if (hash1 != hash2) {
+            return hash1 ^ hash2;
+        }
+        return hash1;
+    }
+};
+
+uniform_int_distribution<mt19937::result_type> dist(PRIME);
+const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd);
+struct array_hash {
+    template <typename Sequence>
+    size_t operator()(const Sequence& arr) const {
+        size_t pw1 = 1, pw2 = 1;
+        size_t res1 = 0, res2 = 0;
+        for (auto&& x : arr) {
+            res1 = (res1 + x * pw1) % __array_hash_mdl1;
+            res2 = (res2 + x * pw2) % __array_hash_mdl2;
+            pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1;
+            pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2;
+        }
+        return res1 + res2;
+    }
+};
+
+/* build data structures */
+#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
+#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
+#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
+#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
+#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
+#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    map<T, size_t> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
+    set<T> st(__first, __last);
+    size_t N = 0;
+    unordered_map<T, size_t, safe_hash> mp;
+    for (auto&& x : st) mp[x] = ++N;
+    return {N, mp};
+}
+
+/* io */
+#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+template<typename T> void __read(T& x) { cin >> x; }
+template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
+#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
+#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
+    out << "{" << p.first << ", " << p.second << "}";
+    return out;
+}
+template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
+void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
+    using swallow = int[]; // guaranties left to right order
+    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
+}
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
+    os << "{";
+    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
+    return os << "}";
+}
+template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
+    for (auto&& i : vec) out << i << ' ';
+    return out;
+}
+std::ostream& operator<<(std::ostream& dest, const int128& value) {
+    // https://stackoverflow.com/a/25115163/23881100
+    std::ostream::sentry s( dest );
+    if ( s ) {
+        uint128 tmp = value < 0 ? -value : value;
+        char buffer[ 128 ];
+        char* d = std::end( buffer );
+        do {
+            -- d;
+            *d = "0123456789"[ tmp % 10 ];
+            tmp /= 10;
+        } while ( tmp != 0 );
+        if ( value < 0 ) {
+            -- d;
+            *d = '-';
+        }
+        int len = std::end( buffer ) - d;
+        if ( dest.rdbuf()->sputn( d, len ) != len ) {
+            dest.setstate( std::ios_base::badbit );
+        }
+    }
+    return dest;
+}
+
+/* pops */
+#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+
+/* math */
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+void __exgcd(ll a, ll b, ll& x, ll& y) {
+  if (b == 0) {
+    x = 1, y = 0;
+    return;
+  }
+  __exgcd(b, a % b, y, x);
+  y -= a / b * x;
+}
+
+ll inverse(ll a, ll b) {
+    ll x, y;
+    __exgcd(a, b, x, y);
+    return mod(x, b);
+}
+
+vector<tuple<int, int, ll>> decompose(ll x) {
+    vector<tuple<int, int, ll>> res;
+    for (int i = 2; i * i <= x; i++) {
+        if (x % i == 0) {
+            int cnt = 0;
+            ll pw = 1;
+            while (x % i == 0) ++cnt, x /= i, pw *= i;
+            res.emplace_back(i, cnt, pw);
+        }
+    }
+    if (x != 1) {
+        res.emplace_back(x, 1, x);
+    }
+    return res;
+}
+
+/* string algorithms */
+vector<int> calc_next(string t) {  // pi function of t
+  int n = (int)t.length();
+  vector<int> pi(n);
+  for (int i = 1; i < n; i++) {
+    int j = pi[i - 1];
+    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
+    if (t[i] == t[j]) j++;
+    pi[i] = j;
+  }
+  return pi;
+}
+vector<int> calc_z(string t) {  // z function of t
+    int m = t.length();
+    vector<int> z;
+    z.push_back(m);
+    pair<int, int> prev = {1, -1};
+    for (int i = 1; i < m; ++i) {
+        if (z[i - prev.first] + i <= prev.second) {
+            z.push_back(z[i - prev.first]);
+        } else {
+            int j = max(i, prev.second + 1);
+            while (j < m && t[j] == t[j - i]) ++j;
+            z.push_back(j - i);
+            prev = {i, j - 1};
+        }
+    }
+    return z;
+}
+vector<int> kmp(string s, string t) {  // find all t in s
+  string cur = t + '#' + s;
+  int sz1 = s.size(), sz2 = t.size();
+  vector<int> v;
+  vector<int> lps = calc_next(cur);
+  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
+    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
+  }
+  return v;
+}
+int period(string s) {  // find the length of shortest recurring period
+    int n = s.length();
+    auto z = calc_z(s);
+    for (int i = 1; i <= n / 2; ++i) {
+        if (n % i == 0 && z[i] == n - i) {
+            return i;
+        }
+    }
+    return n;
+}
+
+/* modular arithmetic */
+template <ll mdl> struct MLL {
+    ll val;
+    MLL(ll v = 0) : val(mod(v, mdl)) {}
+    MLL(const MLL<mdl>& other) : val(other.val) {}
+    friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); }
+    friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); }
+    friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
+    friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
+    friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
+    friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
+    friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
+    void operator+=(const MLL& rhs) { val = (*this + rhs).val; }
+    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+};
+
+template <ll mdl>
+ostream& operator<<(ostream& out, const MLL<mdl>& num) {
+    return out << num.val;
+}
+
+template <ll mdl>
+istream& operator>>(istream& in, MLL<mdl>& num) {
+    return in >> num.val;
+}
+/////////////////////////////////////////////////////////
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {}
+
+void solve() {
+    read(int, n, m);
+    vector<vector<pil>> e(n + 1);
+    while (m--) {
+        read(int, u, v);
+        read(ll, w);
+        e[u].emplace_back(v, w * 2);
+        e[v].emplace_back(u, w * 2);
+    }
+    for (int i = 1; i <= n; ++i) {
+        read(ll, x);
+        e[0].emplace_back(i, x);
+        e[i].emplace_back(0, x);
+    }
+    min_heap<pli> pq;
+    pq.emplace(0, 0);
+    vector<bool> vis(n + 1);
+    vector<ll> dis(n + 1, INFLL);
+    while (pq.size()) {
+        poptop(pq, d, v);
+        continue_or(vis[v], 1);
+        dis[v] = d;
+        for (auto&& [u, w] : e[v]) {
+            if (d + w < dis[u]) {
+                dis[u] = d + w;
+                pq.emplace(dis[u], u);
+            }
+        }
+    }
+    for (int i = 1; i <= n; ++i) {
+        cout << dis[i] << " \n"[i == n];
+    }
+}
+
+int main() {
+#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie, cout.tie(NULL);
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t < (DUMP_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/ctext_out.cc

@@ -24,6 +24,7 @@ using ull = uint64_t;
 #else
 using ll = long long;
 using ull = unsigned long long;
+using ld = long double;
 #endif
 using int128 = __int128_t;
 using uint128 = __uint128_t;
@@ -331,7 +332,7 @@ istream& operator>>(istream& in, MLL<mdl>& num) {
 }
 /////////////////////////////////////////////////////////
 
-// #define SINGLE_TEST_CASE
+#define SINGLE_TEST_CASE
 // #define DUMP_TEST_CASE 7219
 
 void dump() {}
@@ -340,36 +341,38 @@ void dump_ignore() {}
 
 void prep() {}
 
-pll intersect(ll l1, ll r1, ll l2, ll r2) {
-    ll l = max(l1, l2), r = min(r1, r2);
-    if (l > r) {
-        return {-1, -1};
-    }
-    return {l, r};
-}
-
 void solve() {
-    using mll = MLL<MDL>;
+    read(int, n, m);
-    read(ll, a, b);
+    vector<vector<pil>> e(n + 1);
-    // enumerate y
+    while (m--) {
-    mll res = 0;
+        read(int, u, v);
-    for (int y = 2; y < 61; ++y) {
+        read(ll, w);
-        ll yz = 1;
+        e[u].emplace_back(v, w * 2);
-        auto [l, r] = intersect(ll(1) << y, (ll(1) << y + 1) - 1, a, b);
+        e[v].emplace_back(u, w * 2);
-        if (l == -1) {
+    }
-            continue;
+    for (int i = 1; i <= n; ++i) {
-        }
+        read(ll, x);
-        for (int z = 0; ; z += 1, yz *= y) {
+        e[0].emplace_back(i, x);
-            auto [p, q] = intersect(l, r, yz, yz > 4e18 / y ? LLONG_MAX : yz * y - 1);
+        e[i].emplace_back(0, x);
-            if (p != -1) {
+    }
-                res += mll(1) * (q - p + 1) * z;
+    min_heap<pli> pq;
-            }
+    pq.emplace(0, 0);
-            if (yz > 4e18 / y) {
+    vector<bool> vis(n + 1);
-                break;
+    vector<ll> dis(n + 1, INFLL);
+    while (pq.size()) {
+        poptop(pq, d, v);
+        continue_or(vis[v], 1);
+        dis[v] = d;
+        for (auto&& [u, w] : e[v]) {
+            if (d + w < dis[u]) {
+                dis[u] = d + w;
+                pq.emplace(dis[u], u);
             }
         }
     }
-    cout << res << '\n';
+    for (int i = 1; i <= n; ++i) {
+        cout << dis[i] << " \n"[i == n];
+    }
 }
 
 int main() {

src/bin/std.in

@@ -1,14 +1,6 @@
-12
+3 3
-4 6
+1 2 1
-4 7
+2 3 1
-4 8
+1 3 1
-4 100000
+30 10 20
-179 1000000000000000000
-57 179
-4 201018959
-7 201018960
-729 50624
-728 50624
-728 50625
-729 50625
 

src/bin/template.cc

@@ -24,6 +24,7 @@ using ull = uint64_t;
 #else
 using ll = long long;
 using ull = unsigned long long;
+using ld = long double;
 #endif
 using int128 = __int128_t;
 using uint128 = __uint128_t;
@@ -236,6 +237,7 @@ ll inverse(ll a, ll b) {
 }
 
 vector<tuple<int, int, ll>> decompose(ll x) {
+    // return (factor, count, factor ** count)
     vector<tuple<int, int, ll>> res;
     for (int i = 2; i * i <= x; i++) {
         if (x % i == 0) {
@@ -251,6 +253,22 @@ vector<tuple<int, int, ll>> decompose(ll x) {
     return res;
 }
 
+vector<pii> decompose_prime(int N) {
+    // return (factor, count)
+    vector<pii> result;
+    for (int i = 2; i * i <= N; i++) {
+        if (N % i == 0) {
+            int cnt = 0;
+            while (N % i == 0) N /= i, ++cnt;
+            result.emplace_back(i, cnt);
+        }
+    }
+    if (N != 1) {
+        result.emplace_back(N, 1);
+    }
+    return result;
+}
+
 /* string algorithms */
 vector<int> calc_next(string t) {  // pi function of t
   int n = (int)t.length();

src/bin/test.cc

@@ -1,43 +1,15 @@
 #include <bits/stdc++.h>
-
 using namespace std;
 
-typedef long long ll;
+vector<int> effect() {
-
+    cerr << "called.\n";
-const int MAXN = 5e5 + 10;
+    vector<int> res(5);
-
+    iota(res.begin(), res.end(), 0);
-int t, n; ll a[MAXN], dp[MAXN], ans;
+    return res;
-
-vector<int> g[MAXN];
-
-void dfs(int u, int fa) {
-	ll x; vector<ll> d; dp[u] = a[u], ans = max(ans, dp[u]);
-	for (int v : g[u]) {
-		if (v == fa) continue; dfs(v, u), d.push_back(dp[v]);
-		ans = max(ans, a[u] + dp[v]), dp[u] = max(dp[u], dp[v]);
-	}
-	sort(d.begin(), d.end(), greater<ll>());
-	if (d.size() >= 2) {
-		x = d[0] + d[1], ans = max(ans, x);
-		for (int i = 2; i < d.size() && d[i] > 0; i++) x += d[i];
-		dp[u] = max(dp[u], a[u] + x);
-	}
-	if (d.size() >= 3) {
-		x = d[0] + d[1] + d[2];
-		for (int i = 3; i < d.size() && d[i] > 0; i++) x += d[i];
-		ans = max(ans, a[u] + x);
-	}
 }
 
 int main() {
-	for (scanf("%d", &t); t--;) {
+    for (auto&& i : effect()) {
-		scanf("%d", &n), ans = 0;
+        cout << i << '\n';
-		for (int i = 1; i <= n; i++) g[i].clear();
+    }
-		for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
-		for (int i = 1, u, v; i < n; i++) {
-			scanf("%d%d", &u, &v);
-			g[u].push_back(v), g[v].push_back(u);
-		}
-		dfs(1, 0), printf("%lld\n", ans);
-	}
 }

src/bin/test.py

@@ -1,3 +1,4 @@
+from itertools import pairwise
 from random import shuffle, randint
 from os import system
 
@@ -8,22 +9,23 @@ def gen_tree(n):
         tree += f'{fa} {i}\n'
     return tree
 
+N = 10_000_000
+prime = []
+is_prime = [False] * N
+
+def Eratosthenes(n):
+    is_prime[0] = is_prime[1] = False
+    for i in range(2, n + 1):
+        is_prime[i] = True
+    for i in range(2, n + 1):
+        if is_prime[i]:
+            prime.append(i)
+            if i * i > n:
+                continue
+            for j in range(i * i, n + 1, i):
+                is_prime[j] = False
+
 if __name__ == '__main__':
-    while 1:
+    print(1)
-        n = randint(2, 10)
+    print(1000000)
-        tr = gen_tree(n)
+    print('8 6 ' * 500000)
-        val = ' '.join([str(randint(-10, 10)) for _ in range(n)])
-        content = '\n'.join((str(n), val, tr))
-        with open('std.in', 'w') as f:
-            f.write('1\n' + content)
-        system('./my.out < std.in > std.out')
-        with open('std.out') as f:
-            my_ans = f.read().strip()
-        system('./ans.out < std.in > std.out')
-        with open('std.out') as f:
-            his_ans = f.read().strip()
-        if my_ans != his_ans:
-            print(content)
-            print(my_ans)
-            print(his_ans)
-            break