backup

src/bin/a.cc

@@ -472,13 +472,11 @@ void prep() {
 void solve() {
     read(int, n);
     readvec(int, a, n);
-    sort(a.begin(), a.end());
+    vector<int> cnt(n + 1);
-    int m = unique(a.begin(), a.end()) - a.begin();
+    for (int i = 0; i < n; ++i) {
-    if (m == 1 or m == 2 and a[1] - a[0] > 1) {
+        cnt[a[i]] += 1;
-        cout << "YES\n";
-    } else {
-        cout << "NO\n";
     }
+    cout << n - *max_element(cnt.begin(), cnt.end()) << '\n';
 }
 
 int main() {

src/bin/b.cc

@@ -470,25 +470,19 @@ void prep() {
 }
 
 void solve() {
-    read(int, l, r, L, R);
+    read(int, n);
-    if (l < L) {
+    if (n % 2 == 0) {
-        swap(l, L);
+        cout << -1 << '\n';
-        swap(r, R);
+    } else {
+        vector<int> res(n);
+        for (int i = 0; i <= n / 2; ++i) {
+            res[i] = 2 * i + 1;
         }
-    if (l >= R + 1) {
+        int x = 0;
-        cout << 1 << '\n';
+        for (int i = n - 1; i > n / 2; --i) {
-    } else if (l > L and r > R) {
+            res[i] = (x += 2);
-        cout << R - l + 2 << '\n';
+        }
-    } else if (l > L and r == R) {
+        putvec(res);
-        cout << R - l + 1 << '\n';
-    } else if (l > L and r < R) {
-        cout << r - l + 2 << '\n';
-    } else if (l == L and r > R) {
-        cout << R - L + 1 << '\n';
-    } else if (l == L and r == R) {
-        cout << R - L << '\n';
-    } else if (l == L and r < R) {
-        cout << r - l + 1 << '\n';
     }
 }
 

src/bin/c.cc

@@ -470,19 +470,30 @@ void prep() {
 }
 
 void solve() {
-    read(int, n, k);
+    read(int, n);
-    readvec(ll, a, n);
+    vector<bool> vis(n + 1);
-    sort(a.begin(), a.end(), greater());
+    vector<pii> edges;
-    for (int i = 1; i < n; i += 2) {
+    for (int i = 2; i <= n; ++i) {
-        int use = min<int>(k, a[i - 1] - a[i]);
+        if (not vis[i]) {
-        k -= use;
+            vis[i] = 1;
-        a[i] += use;
+            int j = 1;
+            while (1) {
+                cout << "? " << j << ' ' << i << endl;
+                read(int, k);
+                if (k == j) {
+                    edges.emplace_back(i, j);
+                    break;
+                } else {
+                    j = k;
                 }
-    ll res = 0;
-    for (int i = 0; i < n; ++i) {
-        res += (i % 2 == 0 ? 1 : -1) * a[i];
             }
-    cout << res << '\n';
+        }
+    }
+    cout << "! ";
+    for (auto&& [u, v] : edges) {
+        cout << u << ' ' << v << ' ';
+    }
+    cout << endl;
 }
 
 int main() {

src/bin/cf-1394b.cc

@@ -0,0 +1,562 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    constexpr int N = 2e5;
+
+    read(int, n, m, k);
+    vector<vector<pii>> e(n + 1);
+    for (int i = 0; i < m; ++i) {
+        read(int, u, v, w);
+        Edgew(e, u, v, w);
+    }
+    vector<bitset<N>> oc((k + 1) * (k + 1) + 1);
+    vector exclude(k + 1, vector<bool>(k + 1));
+    vector mutex((k + 1) * (k + 1) + 1, vector<bool>((k + 1) * (k + 1) + 1));
+    for (int i = 1; i <= n; ++i) {
+        sort_by_key(e[i].begin(), e[i].end(), expr(p.second, auto&& p));
+        int s = e[i].size();
+        for (int j = 0; j < s; ++j) {
+            if (oc[s * (k + 1) + j + 1][e[i][j].first]) {
+                exclude[s][j + 1] = true;
+            } else {
+                oc[s * (k + 1) + j + 1][e[i][j].first] = 1;
+            }
+        }
+    }
+    for (int i = 1; i <= k; ++i) {
+        for (int j = 1; j <= i; ++j) {
+            for (int l = 1; l < i; ++l) {
+                for (int p = 1; p <= l; ++p) {
+                    if ((oc[i * (k + 1) + j] & oc[l * (k + 1) + p]).any()) {
+                        mutex[i * (k + 1) + j][l * (k + 1) + p] = true;
+                        mutex[l * (k + 1) + p][i * (k + 1) + j] = true;
+                    }
+                }
+            }
+        }
+    }
+
+    int res = 0;
+    vector<int> st = { 0 };
+    auto dfs = [&] (auto dfs, int curr) -> void {
+        if (curr == k + 1) {
+            for (int i = 1; i <= k; ++i) {
+                if (exclude[i][st[i]]) {
+                    goto fi;
+                }
+            }
+            for (int i = 1; i <= k; ++i) {
+                for (int j = 1; j < i; ++j) {
+                    if (mutex[i * (k + 1) + st[i]][j * (k + 1) + st[j]]) {
+                        goto fi;
+                    }
+                }
+            }
+            res += 1;
+        fi:
+            return;
+        }
+        for (int j = 1; j <= curr; ++j) {
+            st.emplace_back(j);
+            dfs(dfs, curr + 1);
+            st.pop_back();
+        }
+    };
+    dfs(dfs, 1);
+    cout << res << '\n';
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1401e.cc

@@ -0,0 +1,581 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+template<typename T>
+struct BIT {
+    int n;
+    vector<T> c;
+    BIT(size_t n) : n(n), c(n + 1) {}
+    void add(size_t i, const T& k) {
+        while (i <= n) {
+            c[i] += k;
+            i += lowbit(i);
+        }
+    }
+    T getsum(size_t i) {
+        T res = {};
+        while (i) {
+            res += c[i];
+            i -= lowbit(i);
+        }
+        return res;
+    }
+};
+
+void solve() {
+    constexpr int N = 1e6;
+    read(int, n, m);
+    vector<pii> line(N + 1);
+    line[N] = { 0, N };
+    vector<vector<int>> open(N + 1), close(N + 1);
+    for (int i = 0; i < n; ++i) {
+        read(int, y, l, r);
+        open[l].emplace_back(y);
+        close[r].emplace_back(y);
+    }
+    for (int i = 0; i < m; ++i) {
+        read(int, x, l, r);
+        if (l == 0) {
+            line[x] = { 0, r };
+        } else {
+            line[x] = { 1, l };
+        }
+    }
+    BIT<int> tr(N + 1);
+    tr.add(1, 1);
+    tr.add(N + 1, 1);
+    ll res = 0;
+    int prev = 1;
+    int prev_l = 0, prev_r = N;
+    for (auto&& y : open[0]) {
+        tr.add(y + 1, 1);
+    }
+    for (auto&& y : close[0]) {
+        if (tr.getsum(y + 1) - tr.getsum(y)) {
+            tr.add(y + 1, -1);
+        }
+    }
+    for (int i = 1; i <= N; ++i) {
+        if (line[i] == pii { 0, 0 }) {
+            continue;
+        }
+        for (int j = prev; j < i; ++j) {
+            for (auto&& y : close[j]) {
+                if (tr.getsum(y + 1) - tr.getsum(y)) {
+                    tr.add(y + 1, -1);
+                }
+            }
+        }
+        if (line[i].first == 0) {
+            res += tr.getsum(line[i].second + 1) - tr.getsum(1);
+        } else {
+            res += tr.getsum(N) - tr.getsum(line[i].second);
+        }
+        for (int j = prev; j <= i; ++j) {
+            for (auto&& y : open[j]) {
+                tr.add(y + 1, 1);
+            }
+            for (auto&& y : close[j]) {
+                if (tr.getsum(y + 1) - tr.getsum(y)) {
+                    tr.add(y + 1, -1);
+                }
+            }
+        }
+        prev = i + 1;
+    }
+    cout << res << '\n';
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1411e.cc

@@ -0,0 +1,533 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    read(int, n);
+    read(ll, s);
+    vector<int> a;
+    for (int i = 0; i < n; ++i) {
+        read(char, c);
+        a.emplace_back(c - 'a');
+        s += ll(1) << a.back();
+    }
+
+    s -= ll(1) << a.back() + 1;
+    if (s < 0) {
+        cout << "No\n";
+        return;
+    }
+    debug(s);
+
+    vector<int> cnt(61);
+    for (int i = 1; i < n - 1; ++i) {
+        cnt[a[i] + 1] += 1;
+    }
+
+    for (int i = 0; i < 60; ++i) {
+        if (s & 1) {
+            if (not cnt[i]) {
+                cout << "No\n";
+                return;
+            }
+            cnt[i] -= 1;
+        }
+        s >>= 1;
+        cnt[i + 1] += cnt[i] / 2;
+    }
+
+    cout << "Yes\n";
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1443e.cc

@@ -0,0 +1,541 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    read(int, n, q);
+    int N = min(n, 14);
+    vector<ll> fact(N + 1);
+    fact[0] = 1;
+    for (int i = 1; i <= N; ++i) {
+        fact[i] = fact[i - 1] * i;
+    }
+
+    ll cnt = 0;
+    while (q--) {
+        read(int, op);
+        if (op == 1) {
+            read(int, l, r);
+            if (r <= n - N) {
+                cout << ll(l + r) * (r - l + 1) / 2 << '\n';
+            } else {
+                int r1 = n - N;
+                ll res = max<ll>(0, ll(l + r1) * (r1 - l + 1) / 2);
+                vector<bool> used(N + 1);
+                ll curr = cnt;
+                for (int j = 1; j <= N; ++j) {
+                    int k = curr / fact[N - j];
+                    int c = 0;
+                    for (int p = 1; p <= N; ++p) {
+                        if (used[p]) continue;
+                        if (c++ == k) {
+                            used[p] = 1;
+                            if (r1 + j <= r and r1 + j >= l) {
+                                res += r1 + p;
+                            }
+                            break;
+                        }
+                    }
+                    curr -= k * fact[N - j];
+                }
+                cout << res << '\n';
+            }
+        } else {
+            read(int, x);
+            cnt += x;
+        }
+    }
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1455e.cc

@@ -0,0 +1,532 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    readvec(pll, a, 4);
+    ll res = INFLL;
+    for (int i = 0; i < 2; ++i) {
+        sort(a.begin(), a.end());
+        ll x_min, x_max, y_min, y_max, base;
+        if (max(a[0].second, a[1].second) <= min(a[2].second, a[3].second)) {
+            x_min = a[2].first - a[1].first, x_max = a[3].first - a[0].first;
+            y_min = 0, y_max = max(a[2].second, a[3].second) - min(a[1].second, a[0].second);
+            base = a[1].first - a[0].first + a[3].first - a[2].first + a[2].second + a[3].second - a[0].second - a[1].second;
+        } else if (min(a[0].second, a[1].second) >= max(a[2].second, a[3].second)) {
+            x_min = a[2].first - a[1].first, x_max = a[3].first - a[0].first;
+            y_min = 0, y_max = max(a[1].second, a[0].second) - min(a[2].second, a[3].second);
+            base = a[1].first - a[0].first + a[3].first - a[2].first - a[2].second - a[3].second + a[0].second + a[1].second;
+        } else {
+            vector<ll> b(4);
+            transform(a.begin(), a.end(), b.begin(), expr(p.second, auto&& p));
+            sort(b.begin(), b.end());
+            x_min = a[2].first - a[1].first, x_max = a[3].first - a[0].first;
+            y_min = b[2] - b[1], y_max = b[3] - b[0];
+            base = a[1].first - a[0].first + a[3].first - a[2].first + b[1] - b[0] + b[3] - b[2];
+        }
+        if (x_min > y_max) {
+            chmin(res, base + 2 * (x_min - y_max));
+        } else if (y_min > x_max) {
+            chmin(res, base + 2 * (y_min - x_max));
+        } else {
+            chmin(res, base);
+        }
+        for (int j = 0; j < 4; ++j) {
+            swap(a[j].first, a[j].second);
+        }
+    }
+    cout << res << '\n';
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1463e.cc

@@ -0,0 +1,582 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    read(int, n, k);
+    readvec1(int, a, n);
+
+    vector<int> nxt(n + 1), ind(n + 1);
+    for (int i = 0; i < k; ++i) {
+        read(int, u, v);
+        nxt[u] = v;
+        ++ind[v];
+    }
+    vector<int> head(n + 1);
+    vector<vector<int>> link(n + 1);
+    vector<int> link_order(n + 1);
+    vector<int> vis(n + 1);
+    int m = 0;
+    for (int i = 1; i <= n; ++i) {
+        if (ind[i] == 0) {
+            int v = i;
+            int o = 0;
+            while (1) {
+                if (vis[v]) {
+                    cout << 0 << '\n';
+                    return;
+                }
+                vis[v] = 1;
+                link[m].emplace_back(v);
+                head[v] = m;
+                link_order[v] = o++;
+                if (nxt[v]) {
+                    v = nxt[v];
+                } else {
+                    break;
+                }
+            }
+            ++m;
+        }
+    }
+    if (count(vis.begin() + 1, vis.end(), 0)) {
+        cout << 0 << '\n';
+        return;
+    }
+    // debug(m);
+    // debug(head);
+    // debugvec(link);
+    adj(ch, m);
+    ind.assign(m, 0);
+    for (int i = 1; i <= n; ++i) {
+        if (a[i] == 0) continue;
+        if (head[a[i]] == head[i]) {
+            if (link_order[a[i]] > link_order[i]) {
+                cout << 0 << '\n';
+                return;
+            }
+        } else {
+            Edge(ch, head[a[i]], head[i]);
+            ++ind[head[i]];
+        }
+    }
+    // debug(ind);
+    deque<int> q;
+    for (int i = 0; i < m; ++i) {
+        if (ind[i] == 0) q.emplace_back(i);
+    }
+    vector<int> seq;
+    while (q.size()) {
+        int v = q.front(); q.pop_front();
+        seq.emplace_back(v);
+        for (auto&& u : ch[v]) {
+            if (--ind[u] == 0) {
+                q.emplace_back(u);
+            }
+        }
+    }
+    // debug(seq);
+    if (seq.size() != m) {
+        cout << 0 << '\n';
+    } else {
+        for (auto&& v : seq) {
+            for (auto&& u : link[v]) {
+                cout << u << ' ';
+            }
+        }
+        cout << '\n';
+    }
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1469e.cc

@@ -0,0 +1,556 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+using mll1 = MLL<MDL1>;
+using mll2 = MLL<MDL2>;
+constexpr int N = 1e6 + 10;
+mll1 pw1[N];
+mll2 pw2[N];
+
+void prep() {
+    pw1[0] = 1, pw2[0] = 1;
+    for (int i = 1; i < N; ++i) {
+        pw1[i] = pw1[i - 1] * 2;
+        pw2[i] = pw2[i - 1] * 2;
+    }
+}
+
+void solve() {
+    read(int, n, k);
+    vector<int> a;
+    for (int i = 0; i < n; ++i) {
+        read(char, c);
+        a.emplace_back(c == '1');
+    }
+
+    unordered_set<pll, pair_hash> oc;
+
+    mll1 h1 = 0;
+    mll2 h2 = 0;
+    for (int i = 0; i < n; ++i) {
+        h1 = h1 * 2 + (a[i] ^ 1);
+        h2 = h2 * 2 + (a[i] ^ 1);
+        if (i >= k) {
+            h1 -= pw1[k] * (a[i - k] ^ 1);
+            h2 -= pw2[k] * (a[i - k] ^ 1);
+        }
+        if (i + 1 >= k) {
+            oc.emplace(h1.val, h2.val);
+        }
+    }
+
+    int res = -1;
+    for (int i = 0; i < n + 2; ++i) {
+        if (i and lsp(i) >= k) {
+            break;
+        }
+        if (not oc.count({ i, i })) {
+            res = i;
+            break;
+        }
+    }
+
+    if (res == -1) {
+        cout << "NO\n";
+    } else {
+        cout << "YES\n";
+        string out;
+        for (int i = 0; i < k; ++i) {
+            out.push_back('0' + (res & 1));
+            res >>= 1;
+        }
+        reverse(out.begin(), out.end());
+        cout << out << '\n';
+    }
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1473e.cc

@@ -0,0 +1,532 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    read(int, n, m);
+    vector<vector<pii>> e(n + 1);
+    while (m--) {
+        read(int, u, v, w);
+        edgew(e, u, v, w);
+    }
+    vector<ll> dis(n + 1, INFLL);
+    vector<array<int, 2>> mm(n + 1, { -INF, INF });
+    vector<array<bool, 2>> vis(n + 1);
+    dis[1] = 0;
+    min_heap<tuple<ll, ll, int, int, int, bool>> q;
+    q.emplace(0, 0, INF, -INF, 1, 0);
+    while (q.size()) {
+        poptop(q, d, s, mn, mx, v, dir);
+        continue_or(vis[v][dir], 1);
+        for (auto&& [u, w] : e[v]) {
+            ll s1 = s + w;
+            int mn1 = min(mn, w);
+            int mx1 = max(mx, w);
+            ll d1 = s1 - mx1 + mn1;
+            if (d1 < dis[u] or d1 == dis[u] and mn1 > mm[u][0]) {
+                dis[u] = d1, mm[u][0] = mn1;
+                q.emplace(dis[u], s1, mn1, mx1, u, 0);
+            }
+            if (d1 < dis[u] or d1 == dis[u] and mx1 < mm[u][1]) {
+                dis[u] = d1, mm[u][1] = mx1;
+                q.emplace(dis[u], s1, mn1, mx1, u, 1);
+            }
+        }
+    }
+    for (int i = 2; i <= n; ++i) {
+        cout << dis[i] << " \n"[i == n];
+    }
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1491e.cc

@@ -0,0 +1,553 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    read(int, n);
+
+    vector<int> fib = { 1, 1 };
+    while (fib.back() < n) {
+        fib.emplace_back(fib.back() + fib[fib.size() - 2]);
+    }
+
+    adj(ch, n);
+    for (int i = 0; i < n - 1; ++i) {
+        read(int, u, v);
+        edge(ch, u, v);
+    }
+
+    unordered_set<pii, pair_hash> lock;
+
+    vector<int> sz(n + 1);
+
+    auto dfs = [&] (auto dfs, int root, int up, int m) -> bool {
+        int n = fib[m];
+        if (n == 1) return true;
+        auto dfs1 = [&] (auto dfs1, int v, int pa) -> void {
+            sz[v] = 1;
+            for (auto&& u : ch[v]) {
+                if (u == pa or lock.count(minmax(u, v))) continue;
+                dfs1(dfs1, u, v);
+                sz[v] += sz[u];
+            }
+        };
+        dfs1(dfs1, root, up);
+        int s = -1, t = -1, layer;
+        auto dfs2 = [&] (auto dfs2, int v, int pa) -> void {
+            for (auto&& u : ch[v]) {
+                if (u == pa or lock.count(minmax(u, v))) continue;
+                if (sz[u] == fib[m - 1] or sz[u] == fib[m - 2]) {
+                    s = v, t = u, layer = sz[u] == fib[m - 1] ? m - 1 : m - 2;
+                    return;
+                }
+                dfs2(dfs2, u, v);
+            }
+        };
+        dfs2(dfs2, root, up);
+        if (s == -1) {
+            return false;
+        } else {
+            lock.emplace(minmax(s, t));
+            return dfs(dfs, t, s, layer) and dfs(dfs, s, t, layer == m - 1 ? m - 2 : m - 1);
+        }
+    };
+
+    if (fib.back() == n and dfs(dfs, 1, 0, fib.size() - 1)) {
+        cout << "YES\n";
+    } else {
+        cout << "NO\n";
+    }
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1494e.cc

@@ -0,0 +1,535 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    read(int, n, m);
+    vector<unordered_map<int, char, safe_hash>> ch(n + 1);
+    int oc = 0, eq = 0;;
+    while (m--) {
+        read(char, op);
+        if (op == '+') {
+            read(int, u, v);
+            read(char, c);
+            ch[u][v] = c;
+            if (ch[v].count(u)) {
+                int d = ch[v][u];
+                if (c == d) {
+                    eq += 1;
+                }
+                oc += 1;
+            }
+        } else if (op == '-') {
+            read(int, u, v);
+            if (ch[v].count(u)) {
+                int c = ch[u][v];
+                int d = ch[v][u];
+                if (c == d) {
+                    eq -= 1;
+                }
+                oc -= 1;
+            }
+            ch[u].erase(v);
+        } else {
+            read(int, k);
+            if (k % 2 == 0 and eq or k % 2 == 1 and oc) {
+                cout << "YES\n";
+            } else {
+                cout << "NO\n";
+            }
+        }
+    }
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-1499e.cc

@@ -0,0 +1,536 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+#define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    using mll = MLL<PRIME>;
+
+    read(string, a, b);
+    int n = a.size(), m = b.size();
+    a.insert(a.begin(), 0);
+    b.insert(b.begin(), 1);
+
+    vector dp(n + 1, vector(m + 1, vector<mll>(2)));
+    dp[0][0][0] = dp[0][0][1] = 1;
+    mll res = 0;
+    for (int i = 0; i <= n; ++i) {
+        for (int j = 0; j <= m; ++j) {
+            if (i + j == 0) continue;
+            if (a[i] != b[j]) {
+                if (i != 0) dp[i][j][0] += dp[0][j][1];
+                if (j != 0) dp[i][j][1] += dp[i][0][0];
+            }
+            if (i > 1 and a[i] != b[j]) {
+                dp[i][j][0] += dp[i - 1][j][1];
+            }
+            if (i > 1 and a[i] != a[i - 1]) {
+                dp[i][j][0] += dp[i - 1][j][0];
+            }
+            if (j > 1 and a[i] != b[j]) {
+                dp[i][j][1] += dp[i][j - 1][0];
+            }
+            if (j > 1 and b[j] != b[j - 1]) {
+                dp[i][j][1] += dp[i][j - 1][1];
+            }
+            if (i and j) {
+                // deb(i, j, dp[i][j][0], dp[i][j][1]);
+                res += dp[i][j][0] + dp[i][j][1];
+            }
+        }
+    }
+
+    cout << res << '\n';
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-2001c.cc

@@ -0,0 +1,523 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    read(int, n);
+    vector<bool> vis(n + 1);
+    vector<pii> edges;
+    for (int i = 2; i <= n; ++i) {
+        if (not vis[i]) {
+            vis[i] = 1;
+            int j = 1;
+            while (1) {
+                cout << "? " << j << ' ' << i << endl;
+                read(int, k);
+                if (k == j) {
+                    edges.emplace_back(i, j);
+                    break;
+                } else {
+                    j = k;
+                }
+            }
+        }
+    }
+    cout << "! ";
+    for (auto&& [u, v] : edges) {
+        cout << u << ' ' << v << ' ';
+    }
+    cout << endl;
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-2001d.cc

@@ -0,0 +1,655 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+template<typename Addable_Info_t, typename Tag_t, typename Sequence = std::vector<Addable_Info_t>> class segtree {
+private:
+    using size_type = uint64_t;
+    using info_type = Addable_Info_t;
+    using tag_type = Tag_t;
+    size_type _max;
+    vector<info_type> d;
+    vector<tag_type> b;
+    void pull(size_type p) {
+        d[p] = d[p * 2] + d[p * 2 + 1];
+    }
+    void push(size_type p, size_type left_len, size_type right_len) {
+        d[p * 2].apply(b[p], left_len), d[p * 2 + 1].apply(b[p], right_len);
+        b[p * 2].apply(b[p]), b[p * 2 + 1].apply(b[p]);
+        b[p] = tag_type();
+    }
+    void set(size_type s, size_type t, size_type p, size_type x, const info_type& c) {
+        if (s == t) {
+            d[p] = c;
+            return;
+        }
+        size_type m = s + (t - s >> 1);
+        if (s != t) push(p, m - s + 1, t - m);
+        if (x <= m) set(s, m, p * 2, x, c);
+        else set(m + 1, t, p * 2 + 1, x, c);
+        pull(p);
+    }
+    
+    void range_apply(size_type s, size_type t, size_type p, size_type l, size_type r, const tag_type& c) {
+        if (l <= s && t <= r) {
+            d[p].apply(c, t - s + 1);
+            b[p].apply(c);
+            return;
+        }
+        size_type m = s + (t - s >> 1);
+        push(p, m - s + 1, t - m);
+        if (l <= m) range_apply(s, m, p * 2, l, r, c);
+        if (r > m)  range_apply(m + 1, t, p * 2 + 1, l, r, c);
+        pull(p);
+    }
+    info_type range_query(size_type s, size_type t, size_type p, size_type l, size_type r) {
+        if (l <= s && t <= r) {
+            return d[p];
+        }
+        size_type m = s + (t - s >> 1);
+        info_type res = {};
+        push(p, m - s + 1, t - m);
+        if (l <= m) res = res + range_query(s, m, p * 2, l, r);
+        if (r > m)  res = res + range_query(m + 1, t, p * 2 + 1, l, r);
+        return res;
+    }
+    void build(const Sequence& a, size_type s, size_type t, size_type p) {
+        if (s == t) {
+            d[p] = a[s];
+            return;
+        }
+        int m = s + (t - s >> 1);
+        build(a, s, m, p * 2);
+        build(a, m + 1, t, p * 2 + 1);
+        pull(p);
+    }
+public:
+    segtree(size_type __max) : d(4 * __max), b(4 * __max), _max(__max - 1) {}
+    segtree(const Sequence& a) : segtree(a.size()) {
+        build(a, {}, _max, 1);
+    }
+    void set(size_type i, const info_type& c) {
+        set({}, _max, 1, i, c);
+    }
+    
+    void range_apply(size_type l, size_type r, const tag_type& c) {
+        range_apply({}, _max, 1, l, r, c);
+    }
+    void apply(size_type i, const tag_type& c) {
+        range_apply(i, i, c);
+    }
+    info_type range_query(size_type l, size_type r) {
+        return range_query({}, _max, 1, l, r);
+    }
+    info_type query(size_type i) {
+        return range_query(i, i);
+    }
+    Sequence serialize() {
+        Sequence res = {};
+        for (size_type i = 0; i <= _max; ++i) {
+            res.push_back(query(i));
+        }
+        return res;
+    }
+    const vector<info_type>& get_d() {
+        return d;
+    }
+};
+struct Tag {
+    void apply(const Tag& rhs) { }
+};
+struct Info {
+    int minval = INF, minpos = 0, maxval = -INF, maxpos = 0;
+    void apply(const Tag& rhs, size_t len) { }
+};
+Info operator+(const Info &a, const Info &b) {
+    return {
+        .minval = min(a.minval, b.minval),
+        .minpos = a.minval < b.minval ? a.minpos : a.minval > b.minval ? b.minpos : min(a.minpos, b.minpos),
+        .maxval = max(a.maxval, b.maxval),
+        .maxpos = a.maxval > b.maxval ? a.maxpos : a.maxval < b.maxval ? b.maxpos : min(a.maxpos, b.maxpos),
+    };
+}
+
+void solve() {
+    read(int, n);
+    readvec(int, a, n);
+    vector<vector<int>> bk(n + 1);
+    for (int i = 0; i < n; ++i) {
+        bk[a[i]].emplace_back(i);
+    }
+    segtree<Info, Tag> tr(n);
+    for (int i = 0; i < n; ++i) {
+        tr.set(i, {
+            .minval = a[i],
+            .minpos = i,
+            .maxval = a[i],
+            .maxpos = i,
+        });
+    }
+    vector<int> res;
+    set<int> st;
+    for (int i = 0; i <= n; ++i) {
+        if (bk[i].size()) {
+            st.emplace(bk[i].back());
+        };
+    }
+    int start = 0;
+    int neg = 1;
+    while (st.size()) {
+        int t = *st.begin();
+        int curr;
+        if (neg) {
+            curr = tr.range_query(start, t).maxpos;
+        } else {
+            curr = tr.range_query(start, t).minpos;
+        }
+        res.emplace_back(a[curr]);
+        for (auto&& j : bk[a[curr]]) {
+            tr.set(j, {
+                .minval = INF,
+                .minpos = j,
+                .maxval = -INF,
+                .maxpos = j,
+            });
+        }
+        st.erase(bk[a[curr]].back());
+        neg ^= 1;
+        start = curr + 1;
+    }
+    cout << res.size() << '\n';
+    putvec(res);
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/cf-2001e1.cc

@@ -0,0 +1,524 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    read(int, n, k, p);
+    vector dp(n + 1, vector<ll>(k + 1));
+    vector dp1(n + 1, vector<ll>(k + 1));
+    for (int j = 0; j <= k; ++j) {
+        dp[1][j] = 1;
+        dp1[1][j] = 1;
+    }
+    for (int i = 2; i <= n; ++i) {
+        vector<ll> curr(k + 1);
+        vector<ll> curr1(k + 1);
+        for (int j = 0; j <= k; ++j) {
+            for (int l = 0; l <= j; ++l) {
+                curr1[j] = (curr1[j] + ((dp1[i - 1][l] * dp1[i - 1][j - l]) % p)) % p;
+                if (l == j - l) continue;
+                if (l > j - l) {
+                    curr[j] = (curr[j] + ((dp[i - 1][l] * dp1[i - 1][j - l]) % p)) % p;
+                } else {
+                    curr[j] = (curr[j] + ((dp1[i - 1][l] * dp[i - 1][j - l]) % p)) % p;
+                }
+            }
+        }
+        partial_sum(curr.begin(), curr.end(), dp[i].begin(), expr((x + y) % p, ll x, ll y));
+        partial_sum(curr1.begin(), curr1.end(), dp1[i].begin(), expr((x + y) % p, ll x, ll y));
+    }
+    cout << dp[n][k] << '\n';
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/d.cc

@@ -469,64 +469,163 @@ void dump_ignore() {}
 void prep() {
 }
 
-unordered_map<char, int> mp = {
+template<typename Addable_Info_t, typename Tag_t, typename Sequence = std::vector<Addable_Info_t>> class segtree {
-    {'R', 0},
+private:
-    {'G', 1},
+    using size_type = uint64_t;
-    {'Y', 2},
+    using info_type = Addable_Info_t;
-    {'B', 3},
+    using tag_type = Tag_t;
+    size_type _max;
+    vector<info_type> d;
+    vector<tag_type> b;
+    void pull(size_type p) {
+        d[p] = d[p * 2] + d[p * 2 + 1];
+    }
+    void push(size_type p, size_type left_len, size_type right_len) {
+        d[p * 2].apply(b[p], left_len), d[p * 2 + 1].apply(b[p], right_len);
+        b[p * 2].apply(b[p]), b[p * 2 + 1].apply(b[p]);
+        b[p] = tag_type();
+    }
+    void set(size_type s, size_type t, size_type p, size_type x, const info_type& c) {
+        if (s == t) {
+            d[p] = c;
+            return;
+        }
+        size_type m = s + (t - s >> 1);
+        if (s != t) push(p, m - s + 1, t - m);
+        if (x <= m) set(s, m, p * 2, x, c);
+        else set(m + 1, t, p * 2 + 1, x, c);
+        pull(p);
+    }
+    
+    void range_apply(size_type s, size_type t, size_type p, size_type l, size_type r, const tag_type& c) {
+        if (l <= s && t <= r) {
+            d[p].apply(c, t - s + 1);
+            b[p].apply(c);
+            return;
+        }
+        size_type m = s + (t - s >> 1);
+        push(p, m - s + 1, t - m);
+        if (l <= m) range_apply(s, m, p * 2, l, r, c);
+        if (r > m)  range_apply(m + 1, t, p * 2 + 1, l, r, c);
+        pull(p);
+    }
+    info_type range_query(size_type s, size_type t, size_type p, size_type l, size_type r) {
+        if (l <= s && t <= r) {
+            return d[p];
+        }
+        size_type m = s + (t - s >> 1);
+        info_type res = {};
+        push(p, m - s + 1, t - m);
+        if (l <= m) res = res + range_query(s, m, p * 2, l, r);
+        if (r > m)  res = res + range_query(m + 1, t, p * 2 + 1, l, r);
+        return res;
+    }
+    void build(const Sequence& a, size_type s, size_type t, size_type p) {
+        if (s == t) {
+            d[p] = a[s];
+            return;
+        }
+        int m = s + (t - s >> 1);
+        build(a, s, m, p * 2);
+        build(a, m + 1, t, p * 2 + 1);
+        pull(p);
+    }
+public:
+    segtree(size_type __max) : d(4 * __max), b(4 * __max), _max(__max - 1) {}
+    segtree(const Sequence& a) : segtree(a.size()) {
+        build(a, {}, _max, 1);
+    }
+    void set(size_type i, const info_type& c) {
+        set({}, _max, 1, i, c);
+    }
+    
+    void range_apply(size_type l, size_type r, const tag_type& c) {
+        range_apply({}, _max, 1, l, r, c);
+    }
+    void apply(size_type i, const tag_type& c) {
+        range_apply(i, i, c);
+    }
+    info_type range_query(size_type l, size_type r) {
+        return range_query({}, _max, 1, l, r);
+    }
+    info_type query(size_type i) {
+        return range_query(i, i);
+    }
+    Sequence serialize() {
+        Sequence res = {};
+        for (size_type i = 0; i <= _max; ++i) {
+            res.push_back(query(i));
+        }
+        return res;
+    }
+    const vector<info_type>& get_d() {
+        return d;
+    }
 };
+struct Tag {
+    void apply(const Tag& rhs) { }
+};
+struct Info {
+    int minval = INF, minpos = 0, maxval = -INF, maxpos = 0;
+    void apply(const Tag& rhs, size_t len) { }
+};
+Info operator+(const Info &a, const Info &b) {
+    return {
+        .minval = min(a.minval, b.minval),
+        .minpos = a.minval < b.minval ? a.minpos : a.minval > b.minval ? b.minpos : min(a.minpos, b.minpos),
+        .maxval = max(a.maxval, b.maxval),
+        .maxpos = a.maxval > b.maxval ? a.maxpos : a.maxval < b.maxval ? b.maxpos : min(a.maxpos, b.maxpos),
+    };
+}
 
 void solve() {
-    read(int, n, q);
+    read(int, n);
-    vector<int> type(n);
+    readvec(int, a, n);
+    vector<vector<int>> bk(n + 1);
     for (int i = 0; i < n; ++i) {
-        read(string, s);
+        bk[a[i]].emplace_back(i);
-        type[i] = mp[s[0]] * 4 + mp[s[1]];
     }
-
+    segtree<Info, Tag> tr(n);
-    vector left(n + 1, vector<int>(16, -1)), right(n + 1, vector<int>(16, -1));
+    for (int i = 0; i < n; ++i) {
-    for (int i = 1; i <= n; ++i) {
+        tr.set(i, {
-        for (int j = 0; j < 16; ++j) {
+            .minval = a[i],
-            if (type[i - 1] == j) {
+            .minpos = i,
-                left[i][j] = i - 1;
+            .maxval = a[i],
-            } else {
+            .maxpos = i,
-                left[i][j] = left[i - 1][j];
+        });
-            }
-        }
-    }
-    for (int i = n - 1; ~i; --i) {
-        for (int j = 0; j < 16; ++j) {
-            if (type[i] == j) {
-                right[i][j] = i;
-            } else {
-                right[i][j] = right[i + 1][j];
-            }
-        }
-    }
-
-    auto check = [] (int x, int y) {
-        if ((x >> 2 & 3) != (y & 3) and (x >> 2 & 3) != (y >> 2 & 3) and (x & 3) != (y >> 2 & 3) and (x & 3) != (y & 3)) {
-            return false;
-        } else {
-            return true;
     }
+    vector<int> res;
+    set<int> st;
+    for (int i = 0; i <= n; ++i) {
+        if (bk[i].size()) {
+            st.emplace(bk[i].back());
         };
-
-    while (q--) {
-        read(int, u, v);
-        --u, --v;
-        int res = INF;
-        for (int j = 0; j < 16; ++j) {
-            if (not check(j, type[u]) or not check(j, type[v])) {
-                continue;
     }
-            for (int w : { left[u][j], right[u][j] }) {
+    int start = 0;
-                if (w == -1) continue;
+    int neg = 1;
-                chmin(res, abs(u - w) + abs(v - w));
+    while (st.size()) {
+        int t = *st.begin();
+        int curr;
+        if (neg) {
+            curr = tr.range_query(start, t).maxpos;
+        } else {
+            curr = tr.range_query(start, t).minpos;
         }
+        res.emplace_back(a[curr]);
+        for (auto&& j : bk[a[curr]]) {
+            tr.set(j, {
+                .minval = INF,
+                .minpos = j,
+                .maxval = -INF,
+                .maxpos = j,
+            });
         }
-        cout << (res == INF ? -1 : res) << '\n';
+        st.erase(bk[a[curr]].back());
+        neg ^= 1;
+        start = curr + 1;
     }
+    cout << res.size() << '\n';
+    putvec(res);
 }
 
 int main() {

src/bin/e1.cc

@@ -0,0 +1,524 @@
+// #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
+#pragma GCC optimize("Ofast")
+/************* This code 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) remove_reference<decltype(container)>::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 int128 = __int128_t;
+using uint128 = __uint128_t;
+using ld = long double;
+using pii = pair<int, int>;           using pil = pair<int, ll>;           using pid = pair<int, ld>;
+using pli = pair<ll, int>;            using pll = pair<ll, ll>;            using pld = pair<ll, ld>;
+using pdi = pair<ld, int>;            using pdl = pair<ld, ll>;            using pdd = pair<ld, ld>;
+using tiii = tuple<int, int, int>;    using tiil = tuple<int, int, ll>;    using tiid = tuple<int, int, ld>;
+using tili = tuple<int, ll, int>;     using till = tuple<int, ll, ll>;     using tild = tuple<int, ll, ld>;
+using tidi = tuple<int, ld, int>;     using tidl = tuple<int, ld, ll>;     using tidd = tuple<int, ld, ld>;
+using tlii = tuple<ll, int, int>;     using tlil = tuple<ll, int, ll>;     using tlid = tuple<ll, int, ld>;
+using tlli = tuple<ll, ll, int>;      using tlll = tuple<ll, ll, ll>;      using tlld = tuple<ll, ll, ld>;
+using tldi = tuple<ll, ld, int>;      using tldl = tuple<ll, ld, ll>;      using tldd = tuple<ll, ld, ld>;
+using tdii = tuple<ld, int, int>;     using tdil = tuple<ld, int, ll>;     using tdid = tuple<ld, int, ld>;
+using tdli = tuple<ld, ll, int>;      using tdll = tuple<ld, ll, ll>;      using tdld = tuple<ld, ll, ld>;
+using tddi = tuple<ld, ld, int>;      using tddl = tuple<ld, ld, ll>;      using tddd = tuple<ld, ld, ld>;
+template <typename T> using max_heap = priority_queue<T>;
+template <typename T> using min_heap = priority_queue<T, vector<T>, greater<>>;
+template <typename T> using oi = ostream_iterator<T>;
+template <typename T> using ii = istream_iterator<T>;
+
+/* 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_64 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 faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
+#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 edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__), ch[v].emplace_back(u, __VA_ARGS__);)
+#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
+#define Edgew(ch, u, v, ...) __AS_PROCEDURE(ch[u].emplace_back(v, __VA_ARGS__);)
+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, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
+    return in >> p.first >> p.second;
+}
+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;
+}
+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 (auto& x : a) cin >> x;)
+#define readvec1(type, a, n) __AS_PROCEDURE(vector<type> a((n) + 1); copy_n(ii<type>(cin), (n), a.begin() + 1);)
+#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;)
+#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));)
+#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
+#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
+#define deb(...) debug(make_tuple(__VA_ARGS__))
+
+/* 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 */
+template <typename return_t>
+return_t qpow(ll b, ll p) {
+    if (b == 0 and p != 0) return 0;
+    if (p == 0) return 1;
+    return_t half = qpow<return_t>(b, p / 2);
+    if (p % 2 == 1) return half * half * b;
+    else return half * half;
+}
+
+#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)])
+#define fastcomb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] * factrev[k] * factrev[(n) - (k)])
+
+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) {
+    // return (factor, count, factor ** count)
+    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;
+}
+
+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();
+  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;
+}
+
+// miscancellous
+template <typename T, typename U>
+bool chmax(T& lhs, const U& rhs) {
+    bool ret = lhs < rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+template <typename T, typename U>
+bool chmin(T& lhs, const U& rhs) {
+    bool ret = lhs > rhs;
+    if (ret) {
+        lhs = rhs;
+    }
+    return ret;
+}
+
+#define functor(func) ([&](auto&&... val) \
+noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
+{return func(std::forward<decltype(val)>(val)...);})
+#define expr(ret, ...) ([&] (__VA_ARGS__) { return (ret); })
+template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
+}
+template <typename Func, typename RandomIt, typename Compare> void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) {
+    std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); });
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) {
+    vector<pair<T, U>> res;
+    auto a_it = a_first;
+    auto b_it = b_first;
+    for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) {
+        res.emplace_back(*a_it, *b_it);
+    }
+    return res;
+}
+template <typename T, typename U, typename Iterator_T, typename Iterator_U>
+vector<pair<T, U>> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) {
+    vector<pair<T, U>> res;
+    if (n > 0) {
+        res.emplace_back(*a_first, *b_first);
+        for (size_t i = 1; i != n; ++i) {
+            res.emplace_back(*++a_first, *++b_first);
+        }
+    }
+    return res;
+}
+template <typename T>
+class ArithmeticIterator : bidirectional_iterator_tag {
+public:
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+private:
+    value_type value;
+public:
+    ArithmeticIterator(const T& value) : value(value) {}
+    value_type operator*() const { return value; }
+    ArithmeticIterator<T>& operator++() { ++value; return *this; }
+    ArithmeticIterator<T>& operator--() { --value; return *this; }
+    bool operator==(const ArithmeticIterator<T>& rhs) const { return value == rhs.value; }
+};
+template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
+    return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
+}
+#define initarray(init, N) (__initarray<decay<decltype(init)>::type, (N)>(init))
+namespace detail {
+    template <typename T, std::size_t...Is>
+    constexpr std::array<T, sizeof...(Is)>
+    make_array(const T& value, std::index_sequence<Is...>) {
+        return {{(static_cast<void>(Is), value)...}};
+    }
+}
+
+template <typename T, std::size_t N>
+constexpr std::array<T, N> __initarray(const T& value) {
+    return detail::make_array(value, std::make_index_sequence<N>());
+}
+/*******************************************************/
+
+// #define SINGLE_TEST_CASE
+// #define DUMP_TEST_CASE 7219
+// #define TOT_TEST_CASE 10000
+
+void dump() {}
+
+void dump_ignore() {}
+
+void prep() {
+}
+
+void solve() {
+    read(int, n, k, p);
+    vector dp(n + 1, vector<ll>(k + 1));
+    vector dp1(n + 1, vector<ll>(k + 1));
+    for (int j = 0; j <= k; ++j) {
+        dp[1][j] = 1;
+        dp1[1][j] = 1;
+    }
+    for (int i = 2; i <= n; ++i) {
+        vector<ll> curr(k + 1);
+        vector<ll> curr1(k + 1);
+        for (int j = 0; j <= k; ++j) {
+            for (int l = 0; l <= j; ++l) {
+                curr1[j] = (curr1[j] + ((dp1[i - 1][l] * dp1[i - 1][j - l]) % p)) % p;
+                if (l == j - l) continue;
+                if (l > j - l) {
+                    curr[j] = (curr[j] + ((dp[i - 1][l] * dp1[i - 1][j - l]) % p)) % p;
+                } else {
+                    curr[j] = (curr[j] + ((dp1[i - 1][l] * dp[i - 1][j - l]) % p)) % p;
+                }
+            }
+        }
+        partial_sum(curr.begin(), curr.end(), dp[i].begin(), expr((x + y) % p, ll x, ll y));
+        partial_sum(curr1.begin(), curr1.end(), dp1[i].begin(), expr((x + y) % p, ll x, ll y));
+    }
+    cout << dp[n][k] << '\n';
+}
+
+int main() {
+#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
+    assert(false && "incompatible compiler variant detected.");
+#endif
+    untie;
+    prep();
+#ifdef SINGLE_TEST_CASE
+    solve();
+#else
+    read(int, t);
+    for (int i = 0; i < t; ++i) {
+#ifdef DUMP_TEST_CASE
+        if (t != (TOT_TEST_CASE)) {
+            solve();
+        } else if (i + 1 == (DUMP_TEST_CASE)) {
+            dump();
+        } else {
+            dump_ignore();
+        }
+#else
+        solve();
+#endif
+    }
+#endif
+}

src/bin/std.in

@@ -1,3 +1,19 @@
-5
+6 9 2
-0 11 12 13 14
 
+3 1 1
+
+2 5 2
+
+1 6 3
+
+6 2 4
+
+5 4 5
+
+5 1 6
+
+1 4 7
+
+4 3 8
+
+4 1 9

src/bin/template.cc

@@ -469,6 +469,7 @@ void dump_ignore() {}
 void prep() {
 }
 
+// __attribute__((target("popcnt")))
 void solve() {
 }
 

src/bin/test.cc

@@ -1,26 +1,12 @@
+#pragma GCC target("popcnt")
 #include <bits/stdc++.h>
 using namespace std;
 
-using ll = long long;
+__attribute__((target("lzcnt")))
-
 int main() {
-    int n = 100;
+    int x;
-    vector<int> sg(n + 1);
+    cin >> x;
-    for (int i = 1; i <= n; ++i) {
+    cout << __builtin_clzll(x) << '\n';
-        vector<int> has(n + 2);
+    // scanf("%d", &x);
-        for (int j = 1; j <= i; ++j) {
+    // printf("%d\n", __builtin_popcount(x));
-            if (gcd(j, i) == 1) {
-                has[sg[j]] = 1;
-            }
-        }
-        for (int j = 0; j < n + 2; ++j) {
-            if (not has[j]) {
-                sg[i] = j;
-                break;
-            }
-        }
-    }
-    for (int i = 0; i <= n; ++i) {
-        cout << i << ' ' << sg[i] << '\n';
-    }
 }

src/bin/test.s

@@ -1,116 +1,54 @@
 	.file	"test.cc"
 	.text
+#APP
+	.globl _ZSt21ios_base_library_initv
+#NO_APP
+	.section	.text.startup,"ax",@progbits
 	.p2align 4
-	.globl	_Z5solvePiiS_i
+	.globl	main
-	.type	_Z5solvePiiS_i, @function
+	.type	main, @function
-_Z5solvePiiS_i:
+main:
-.LFB0:
+.LFB9872:
 	.cfi_startproc
-	endbr64
+	subq	$24, %rsp
-	pushq	%r14
+	.cfi_def_cfa_offset 32
-	.cfi_def_cfa_offset 16
+	movq	_ZSt3cin@GOTPCREL(%rip), %rdi
-	.cfi_offset 14, -16
+	movq	%fs:40, %rax
-	pushq	%rbx
+	movq	%rax, 8(%rsp)
-	.cfi_def_cfa_offset 24
+	xorl	%eax, %eax
-	.cfi_offset 3, -24
+	leaq	4(%rsp), %rsi
-	cmpl	%esi, %ecx
+	call	_ZNSirsERi@PLT
-	jge	.L10
+	movslq	4(%rsp), %rsi
-	movl	%esi, %r10d
+	movq	_ZSt4cout@GOTPCREL(%rip), %rdi
-	movq	%rdx, %r11
+	lzcntq	%rsi, %rsi
-	movl	%ecx, %r8d
+	call	_ZNSolsEi@PLT
-	xorl	%r9d, %r9d
+	movb	$10, 3(%rsp)
-	subl	%ecx, %r10d
+	movq	%rax, %rdi
-	xorl	%ebx, %ebx
+	movq	(%rax), %rax
-	.p2align 4,,10
+	movq	-24(%rax), %rax
-	.p2align 3
+	cmpq	$0, 16(%rdi,%rax)
+	je	.L2
+	leaq	3(%rsp), %rsi
+	movl	$1, %edx
+	call	_ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l@PLT
 .L3:
-	movq	%r11, %rdx
+	movq	8(%rsp), %rax
-	movl	%r9d, %eax
+	subq	%fs:40, %rax
-	testl	%ecx, %ecx
-	jg	.L8
-	jmp	.L14
-	.p2align 4,,10
-	.p2align 3
-.L4:
-	testl	%esi, %esi
 	jne	.L7
-	movslq	%eax, %rsi
+	xorl	%eax, %eax
-	movl	(%rdi,%rsi,4), %r14d
+	addq	$24, %rsp
-	cmpl	%r14d, 4(%rdi,%rsi,4)
-	jne	.L5
-.L6:
-	addl	$1, %eax
-	addq	$4, %rdx
-	cmpl	%eax, %r8d
-	je	.L14
-.L8:
-	movl	(%rdx), %esi
-	cmpl	$1, %esi
-	jne	.L4
-	movslq	%eax, %rsi
-	movl	(%rdi,%rsi,4), %r14d
-	cmpl	%r14d, 4(%rdi,%rsi,4)
-	jg	.L6
-.L5:
-	addl	$1, %r9d
-	addl	$1, %r8d
-	cmpl	%r9d, %r10d
-	jne	.L3
-.L1:
-	movl	%ebx, %eax
-	popq	%rbx
 	.cfi_remember_state
-	.cfi_def_cfa_offset 16
-	popq	%r14
 	.cfi_def_cfa_offset 8
 	ret
-	.p2align 4,,10
+.L2:
-	.p2align 3
-.L7:
 	.cfi_restore_state
-	cmpl	$-1, %esi
+	movl	$10, %esi
-	jne	.L6
+	call	_ZNSo3putEc@PLT
-	movslq	%eax, %rsi
+	jmp	.L3
-	movl	(%rdi,%rsi,4), %r14d
+.L7:
-	cmpl	%r14d, 4(%rdi,%rsi,4)
+	call	__stack_chk_fail@PLT
-	jge	.L5
-	addl	$1, %eax
-	addq	$4, %rdx
-	cmpl	%eax, %r8d
-	jne	.L8
-.L14:
-	addl	$1, %r9d
-	addl	$1, %ebx
-	addl	$1, %r8d
-	cmpl	%r9d, %r10d
-	jne	.L3
-	jmp	.L1
-.L10:
-	xorl	%ebx, %ebx
-	movl	%ebx, %eax
-	popq	%rbx
-	.cfi_def_cfa_offset 16
-	popq	%r14
-	.cfi_def_cfa_offset 8
-	ret
 	.cfi_endproc
-.LFE0:
+.LFE9872:
-	.size	_Z5solvePiiS_i, .-_Z5solvePiiS_i
+	.size	main, .-main
-	.ident	"GCC: (Ubuntu 13.2.0-4ubuntu3) 13.2.0"
+	.ident	"GCC: (GNU) 13.2.0"
 	.section	.note.GNU-stack,"",@progbits
-	.section	.note.gnu.property,"a"
-	.align 8
-	.long	1f - 0f
-	.long	4f - 1f
-	.long	5
-0:
-	.string	"GNU"
-1:
-	.align 8
-	.long	0xc0000002
-	.long	3f - 2f
-2:
-	.long	0x3
-3:
-	.align 8
-4: