backup

src/bin/a.cc

@@ -1,5 +1,5 @@
 // #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
-#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
+#pragma GCC optimize("Ofast")
 /************* This code requires C++17. ***************/
 
 #include<bits/stdc++.h>
@@ -12,6 +12,8 @@ using namespace std;
 constexpr void __() {}
 #define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
 #define __as_typeof(container) remove_reference<decltype(container)>::type
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
 
 /* type aliases */
 #if LONG_LONG_MAX != INT64_MAX
@@ -177,6 +179,14 @@ template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T,
     out << "{" << p.first << ", " << p.second << "}";
     return out;
 }
+template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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
@@ -217,9 +227,9 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
 }
 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 read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
-#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (auto& x : a) cin >> x;)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::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 readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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"));)
@@ -229,9 +239,24 @@ template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __
 #define deb(...) debug(make_tuple(__VA_ARGS__))
 
 /* pops */
-#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+template <typename Container>
-#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+inline auto poptop(Container& q) {
-#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
 
 /* math */
 template <typename return_t>
@@ -243,11 +268,30 @@ return_t qpow(ll b, ll p) {
     else return half * half;
 }
 
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
 #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)])
 
+__attribute__((target("lzcnt")))
 constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
 
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
 void __exgcd(ll a, ll b, ll& x, ll& y) {
   if (b == 0) {
     x = 1, y = 0;
@@ -358,11 +402,11 @@ template <ll mdl> struct MLL {
     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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
-    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
-    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
-    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
-    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
 };
 
 template <ll mdl>
@@ -469,11 +513,18 @@ void prep() {
 
 // __attribute__((target("popcnt")))
 void solve() {
-    read(int, n);
+    read(int, n, k);
-    for (int i = 1; i <= n; ++i) {
+    readvec(int, a, n);
-        cout << i + i - 1 << ' ';
+    int tot = 0;
+    sort(a.begin(), a.end(), greater());
+    for (int i = 0; i < n; ++i) {
+        if (tot + a[i] <= k) {
+            tot += a[i];
+        } else {
+            break;
         }
-    cout << '\n';
+    }
+    cout << k - tot << '\n';
 }
 
 int main() {

src/bin/b.cc

@@ -1,5 +1,5 @@
 // #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
-#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
+#pragma GCC optimize("Ofast")
 /************* This code requires C++17. ***************/
 
 #include<bits/stdc++.h>
@@ -12,6 +12,8 @@ using namespace std;
 constexpr void __() {}
 #define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
 #define __as_typeof(container) remove_reference<decltype(container)>::type
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
 
 /* type aliases */
 #if LONG_LONG_MAX != INT64_MAX
@@ -177,6 +179,14 @@ template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T,
     out << "{" << p.first << ", " << p.second << "}";
     return out;
 }
+template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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
@@ -217,9 +227,9 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
 }
 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 read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
-#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (auto& x : a) cin >> x;)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::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 readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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"));)
@@ -229,9 +239,24 @@ template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __
 #define deb(...) debug(make_tuple(__VA_ARGS__))
 
 /* pops */
-#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+template <typename Container>
-#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+inline auto poptop(Container& q) {
-#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
 
 /* math */
 template <typename return_t>
@@ -243,11 +268,30 @@ return_t qpow(ll b, ll p) {
     else return half * half;
 }
 
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
 #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)])
 
+__attribute__((target("lzcnt")))
 constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
 
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
 void __exgcd(ll a, ll b, ll& x, ll& y) {
   if (b == 0) {
     x = 1, y = 0;
@@ -358,11 +402,11 @@ template <ll mdl> struct MLL {
     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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
-    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
-    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
-    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
-    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
 };
 
 template <ll mdl>
@@ -469,21 +513,29 @@ void prep() {
 
 // __attribute__((target("popcnt")))
 void solve() {
-    read(string, a);
+    read(int, n);
-    int n = a.size();
+    readvec(int, a, n);
-    vector<int> prev(26, -1);
+    vector<int> bk(n + 1);
-    for (int i = 0; i < n; ++i) {
+    for (auto&& x : a) {
-        if (prev[a[i] - 'a'] != -1 and (i - prev[a[i] - 'a']) % 2 == 1) {
+        bk[x] += 1;
-            cout << a.substr(prev[a[i] - 'a'], i - prev[a[i] - 'a'] + 1) << '\n';
-            return;
     }
-        if (i >= 2 and a[i] != a[i - 1] and a[i - 1] != a[i - 2] and a[i] != a[i - 2]) {
+    sort(bk.begin(), bk.end());
-            cout << a.substr(i - 2, 3) << '\n';
+    int score = 0;
-            return;
+    int turn = 0;
+    for (int i = 1; i <= n; ++i) {
+        if (bk[i] == 0) continue;
+        if (bk[i] == 1) {
+            if (turn % 2) {
+                ;;
+            } else {
+                score += 2;
             }
-        prev[a[i] - 'a'] = i;
+            turn += 1;
+        } else {
+            score += 1;
         }
-    cout << -1 << '\n';
+    }
+    cout << score << '\n';
 }
 
 int main() {

src/bin/c.cc

@@ -1,5 +1,5 @@
 // #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
-#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
+#pragma GCC optimize("Ofast")
 /************* This code requires C++17. ***************/
 
 #include<bits/stdc++.h>
@@ -12,6 +12,8 @@ using namespace std;
 constexpr void __() {}
 #define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
 #define __as_typeof(container) remove_reference<decltype(container)>::type
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
 
 /* type aliases */
 #if LONG_LONG_MAX != INT64_MAX
@@ -177,6 +179,14 @@ template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T,
     out << "{" << p.first << ", " << p.second << "}";
     return out;
 }
+template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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
@@ -217,9 +227,9 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
 }
 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 read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
-#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (auto& x : a) cin >> x;)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::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 readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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"));)
@@ -229,9 +239,24 @@ template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __
 #define deb(...) debug(make_tuple(__VA_ARGS__))
 
 /* pops */
-#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+template <typename Container>
-#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+inline auto poptop(Container& q) {
-#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
 
 /* math */
 template <typename return_t>
@@ -243,11 +268,30 @@ return_t qpow(ll b, ll p) {
     else return half * half;
 }
 
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
 #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)])
 
+__attribute__((target("lzcnt")))
 constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
 
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
 void __exgcd(ll a, ll b, ll& x, ll& y) {
   if (b == 0) {
     x = 1, y = 0;
@@ -358,11 +402,11 @@ template <ll mdl> struct MLL {
     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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
-    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
-    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
-    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
-    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
 };
 
 template <ll mdl>
@@ -469,27 +513,25 @@ void prep() {
 
 // __attribute__((target("popcnt")))
 void solve() {
-    read(int, n);
+    read(int, n, k);
-    readvec(int, a, n);
+    vector<int> ps(n);
-    unordered_map<int, int, safe_hash> cnt;
+    int prev = 0;
-    for (auto&& x : a) {
+    for (int i = 0; i < n; ++i) {
-        cnt[x] += 1;
+        read(char, c);
+        ps[i] = prev + (c == '1' ? 1 : -1);
+        prev = ps[i];
     }
-    vector<int> cand;
+    int tot = ps[n - 1];
-    for (auto [k, v] : cnt) {
+    sort(ps.begin(), ps.end());
-        while (v >= 2) {
+    ll curr = 0;
-            cand.emplace_back(k);
+    for (int i = 0; i < n - 1; ++i) {
-            v -= 2;
+        curr -= ps[i];
+        if (curr + ll(i + 1) * tot >= k) {
+            cout << i + 2 << '\n';
+            return;
         }
     }
-    sort(cand.begin(), cand.end());
+    cout << -1 << '\n';
-    if (cand.size() < 4) {
-        cout << "NO\n";
-    } else {
-        cout << "YES\n";
-        int m = cand.size();
-        cout << cand[0] << ' ' << cand[1] << ' ' << cand[0] << ' ' << cand[m - 1] << ' ' << cand[m - 2] << ' ' << cand[m - 1] << ' ' << cand[m - 2] << ' ' << cand[1] << '\n';
-    }
 }
 
 int main() {

src/bin/cf-1028e.cc

@@ -0,0 +1,566 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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)])
+
+__attribute__((target("lzcnt")))
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n);
+    readvec(int, b, n);
+    for (int i = 0; i < n; ++i) {
+        if (b[(i + 1) % n] > b[i]) {
+            cout << "YES\n";
+            vector<ll> a(n);
+            a[(i + 1) % n] = b[(i + 1) % n];
+            a[i] = b[i] + ll((1e17 - a[(i + 1) % n]) / a[(i + 1) % n]) * a[(i + 1) % n];
+            for (int j = 1; j < n - 1; ++j) {
+                a[mod(i - j, n)] = a[mod(i - j + 1, n)] + b[mod(i - j, n)];
+            }
+            putvec(a);
+            return;
+        }
+    }
+    if (b[0] == 0) {
+        cout << "YES\n";
+        for (int i = 0; i < n; ++i) {
+            cout << "1 ";
+        }
+        cout << endl;
+    } 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-1037f.cc

@@ -499,7 +499,7 @@ constexpr std::array<T, N> __initarray(const T& value) {
 }
 /*******************************************************/
 
-// #define SINGLE_TEST_CASE
+#define SINGLE_TEST_CASE
 // #define DUMP_TEST_CASE 7219
 // #define TOT_TEST_CASE 10000
 
@@ -512,6 +512,57 @@ void prep() {
 
 // __attribute__((target("popcnt")))
 void solve() {
+    using mll = MLL<MDL>;
+
+    read(int, n, k);
+    readvec(int, a, n);
+
+    multiset<int> oc;
+    vector<int> range_max(n - k + 2);
+    for (int i = n - 1; ~i; --i) {
+        oc.emplace(a[i]);
+        if (n - i >= k - 1) {
+            range_max[i] = *oc.rbegin();
+            oc.erase(oc.find(a[i + k - 2]));
+        }
+    }
+
+    mll res = 0;
+
+    vector<vector<tiil>> stack(k - 1);  // { position, value, suffix }
+    for (int i = n - 1; ~i; --i) {
+        if (i < n - k + 1) {
+            int type = (i + 1) % (k - 1);
+            {
+                int l = -1, r = stack[type].size() - 1;
+                while (l < r) {
+                    int mid = l + r + 1 >> 1;
+                    if (mid == -1 or get<1>(stack[type][mid]) > a[i]) {
+                        l = mid;
+                    } else {
+                        r = mid - 1;
+                    }
+                }
+                if (l != -1) {
+                    res += ll(1) * a[i] * ((get<0>(stack[type][l]) - i - 1) / (k - 1));
+                    res += get<2>(stack[type][l]);
+                } else {
+                    res += ll(1) * a[i] * ((n - i - 1) / (k - 1));
+                }
+            }
+        }
+        if (n - i >= k - 1) {
+            int val = range_max[i];
+            int type = i % (k - 1);
+            while (stack[type].size() and get<1>(stack[type].back()) <= range_max[i]) {
+                stack[type].pop_back();
+            }
+            int end = stack[type].size() ? get<0>(stack[type].back()) : n - ((n - k + 1 - i) % (k - 1));
+            stack[type].emplace_back(i, val, ll(1) * val * ((end - i) / (k - 1)) + (stack[type].empty() ? 0 : get<2>(stack[type].back())));
+        }
+    }
+
+    cout << res << '\n';
 }
 
 int main() {

src/bin/cf-1039a.cc

@@ -0,0 +1,583 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n);
+    read(ll, t);
+    readvec(ll, a, n);
+    readvec(int, x, n);
+    transform(x.begin(), x.end(), x.begin(), expr(x - 1, auto&& x));
+    vector<int> diff(n);
+    vector<int> stop(n);
+    for (int i = 0; i < n; ++i) {
+        if (x[i] < i) {
+            cout << "No\n";
+            return;
+        }
+        diff[i] += 1;
+        diff[x[i]] -= 1;
+        stop[x[i]] = 1;
+    }
+    int curr = 0;
+    vector<ll> res(n);
+    for (int i = 0; i < n; ++i) {
+        curr += diff[i];
+        ll l = a[i] + t, r = 3e18;
+        if (i > 0) {
+            chmax(l, res[i - 1] + 1);
+        }
+        int s = stop[i] and i < n - 1;
+        if (curr and s) {
+            cout << "No\n";
+            return;
+        } else if (curr) {
+            chmax(l, a[i + 1] + t);
+        } else if (s) {
+            chmin(r, a[i + 1] + t - 1);
+        }
+        if (l <= r) {
+            res[i] = l;
+        } else {
+            cout << "No\n";
+            return;
+        }
+    }
+    cout << "Yes\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-2034c.cc

@@ -0,0 +1,592 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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)])
+
+__attribute__((target("lzcnt")))
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n, m);
+    vector a(n, vector<char>(m));
+    for (int i = 0; i < n; ++i) {
+        for (int j = 0; j < m; ++j) {
+            cin >> a[i][j];
+        }
+    }
+    int cnt = 0;
+    vector good(n, vector<int>(m, -1));
+    vector vis(n, vector<bool>(m));
+    auto dfs = [&] (auto dfs, int i, int j) -> int {
+        if (i < 0 or i >= n or j < 0 or j >= m) return false;
+        if (vis[i][j]) return true;
+        vis[i][j] = 1;
+        if (good[i][j] != -1) {
+        } else if (a[i][j] == 'U') {
+            good[i][j] = dfs(dfs, i - 1, j);
+        } else if (a[i][j] == 'D') {
+            good[i][j] = dfs(dfs, i + 1, j);
+        } else if (a[i][j] == 'L') {
+            good[i][j] = dfs(dfs, i, j - 1);
+        } else if (a[i][j] == 'R') {
+            good[i][j] = dfs(dfs, i, j + 1);
+        } else {
+            if (i + 1 < n and (a[i + 1][j] == '?' or a[i + 1][j] == 'U' or dfs(dfs, i + 1, j))) {
+                a[i][j] = 'D';
+                good[i][j] = 1;
+            } else if (i - 1 >= 0 and (a[i - 1][j] == '?' or a[i - 1][j] == 'D' or dfs(dfs, i - 1, j))) {
+                a[i][j] = 'U';
+                good[i][j] = 1;
+            } else if (j + 1 < m and (a[i][j + 1] == '?' or a[i][j + 1] == 'L' or dfs(dfs, i, j + 1))) {
+                a[i][j] = 'R';
+                good[i][j] = 1;
+            } else if (j - 1 >= 0 and (a[i][j - 1] == '?' or a[i][j - 1] == 'R' or dfs(dfs, i, j - 1))) {
+                a[i][j] = 'L';
+                good[i][j] = 1;
+            } else {
+                good[i][j] = false;
+            }
+        }
+        vis[i][j] = 0;
+        return good[i][j];
+    };
+    for (int i = 0; i < n; ++i) {
+        for (int j = 0; j < m; ++j) {
+            dfs(dfs, i, j);
+            cnt += good[i][j];
+        }
+    }
+    cout << cnt << '\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-2034d.cc

@@ -0,0 +1,599 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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)])
+
+__attribute__((target("lzcnt")))
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n);
+    readvec(int, a, n);
+    int one = find(a.begin(), a.end(), 1) - a.begin();
+    int l = 0, r = n - 1;
+    vector<pii> seq;
+    while (l < r) {
+        while (l < n and a[l] == 1) l += 1;
+        while (r > 0 and a[r] == 1) r -= 1;
+        if (l < r and a[l] == 2 and a[r] == 0) {
+            if (one > r) {
+                seq.emplace_back(one, l);
+                swap(a[one], a[l]);
+                one = l;
+            } else if (one < l) {
+                seq.emplace_back(one, r);
+                swap(a[one], a[r]);
+                one = r;
+            } else {
+                seq.emplace_back(one, r);
+                swap(a[one], a[r]);
+                one = r;
+                seq.emplace_back(one, l);
+                swap(a[one], a[l]);
+                one = l;
+            }
+        }
+        if (a[l] != 2) l += 1;
+        if (a[r] != 0) r -= 1;
+    }
+    int cnt[3] = {};
+    for (int i = 0; i < n; ++i) {
+        cnt[a[i]] += 1;
+    }
+    int ptr = cnt[0];
+    for (int i = 0; i < cnt[0]; ++i) {
+        if (a[i] != 0) {
+            assert(a[i] == 1);
+            while (a[ptr] != 0) ptr += 1;
+            seq.emplace_back(i, ptr);
+            swap(a[i], a[ptr]);
+            ptr += 1;
+        }
+    }
+    ptr = n - cnt[2] - 1;
+    for (int i = n - 1; i >= n - cnt[2]; --i) {
+        if (a[i] != 2) {
+            assert(a[i] == 1);
+            while (a[ptr] != 2) ptr -= 1;
+            seq.emplace_back(i, ptr);
+            swap(a[i], a[ptr]);
+            ptr -= 1;
+        }
+    }
+    cout << seq.size() << '\n';
+    for (auto&& [x, y] : seq) {
+        cout << x + 1 << ' ' << y + 1 << '\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-2042a.cc

@@ -0,0 +1,554 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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)])
+
+__attribute__((target("lzcnt")))
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n, k);
+    readvec(int, a, n);
+    int tot = 0;
+    sort(a.begin(), a.end(), greater());
+    for (int i = 0; i < n; ++i) {
+        if (tot + a[i] <= k) {
+            tot += a[i];
+        } else {
+            break;
+        }
+    }
+    cout << k - tot << '\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-2042b.cc

@@ -0,0 +1,565 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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)])
+
+__attribute__((target("lzcnt")))
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n);
+    readvec(int, a, n);
+    vector<int> bk(n + 1);
+    for (auto&& x : a) {
+        bk[x] += 1;
+    }
+    sort(bk.begin(), bk.end());
+    int score = 0;
+    int turn = 0;
+    for (int i = 1; i <= n; ++i) {
+        if (bk[i] == 0) continue;
+        if (bk[i] == 1) {
+            if (turn % 2) {
+                ;;
+            } else {
+                score += 2;
+            }
+            turn += 1;
+        } else {
+            score += 1;
+        }
+    }
+    cout << score << '\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-2042c.cc

@@ -0,0 +1,561 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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)])
+
+__attribute__((target("lzcnt")))
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n, k);
+    vector<int> ps(n);
+    int prev = 0;
+    for (int i = 0; i < n; ++i) {
+        read(char, c);
+        ps[i] = prev + (c == '1' ? 1 : -1);
+        prev = ps[i];
+    }
+    int tot = ps[n - 1];
+    sort(ps.begin(), ps.end());
+    ll curr = 0;
+    for (int i = 0; i < n - 1; ++i) {
+        curr -= ps[i];
+        if (curr + ll(i + 1) * tot >= k) {
+            cout << i + 2 << '\n';
+            return;
+        }
+    }
+    cout << -1 << '\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-2042d.cc

@@ -0,0 +1,704 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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)])
+
+__attribute__((target("lzcnt")))
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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 val = -INF;
+    void apply(const Tag& rhs, size_t len) { }
+};
+Info operator+(const Info &a, const Info &b) {
+    return {max(a.val, b.val)};
+}
+struct MinInfo {
+    int val = INF;
+    void apply(const Tag& rhs, size_t len) { }
+};
+MinInfo operator+(const MinInfo &a, const MinInfo &b) {
+    return {min(a.val, b.val)};
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n);
+    vector<tiii> a;
+    vector<int> oc;
+    for (int i = 0; i < n; ++i) {
+        read(int, l, r);
+        a.emplace_back(l, r, i);
+        oc.emplace_back(l);
+        oc.emplace_back(r);
+    }
+    sort(oc.begin(), oc.end());
+    int m = unique(oc.begin(), oc.end()) - oc.begin();
+    oc.resize(m);
+    auto rev = [&] (int x) {
+        return lower_bound(oc.begin(), oc.end(), x) - oc.begin();
+    };
+    sort_by_key(a.begin(), a.end(), expr(pair(get<0>(p), -get<1>(p)), auto&& p));
+    segtree<Info, Tag> left(m);
+    vector<int> ll(n);
+    for (int i = 0; i < n; ++i) {
+        auto [l, r, idx] = a[i];
+        // deb(l, r, idx);
+        // deb(rev(l), rev(r));
+        l = rev(l), r = rev(r);
+        ll[idx] = left.range_query(r, m - 1).val;
+        left.set(r, {max(l, left.query(r).val)});
+        if (i and get<0>(a[i]) == get<0>(a[i - 1]) and get<1>(a[i]) == get<1>(a[i - 1])) {
+            ll[get<2>(a[i - 1])] = l;
+        }
+    }
+    sort_by_key(a.begin(), a.end(), expr(pair(-get<1>(p), get<0>(p)), auto&& p));
+    segtree<MinInfo, Tag> right(m);
+    vector<int> rr(n);
+    for (int i = 0; i < n; ++i) {
+        auto [l, r, idx] = a[i];
+        l = rev(l), r = rev(r);
+        rr[idx] = right.range_query(0, l).val;
+        right.set(l, {min(r, right.query(l).val)});
+        if (i and get<0>(a[i]) == get<0>(a[i - 1]) and get<1>(a[i]) == get<1>(a[i - 1])) {
+            rr[get<2>(a[i - 1])] = r;
+        }
+    }
+    sort_by_key(a.begin(), a.end(), expr(get<2>(p), auto&& p));
+    for (int i = 0; i < n; ++i) {
+        if (ll[i] == -INF) {
+            cout << 0 << '\n';
+        } else {
+            // deb(ll[i], rr[i]);
+            // debug(a[i]);
+            cout << oc[rr[i]] - oc[ll[i]] - (get<1>(a[i]) - get<0>(a[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-988f.cc

@@ -0,0 +1,570 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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)])
+
+__attribute__((target("lzcnt")))
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, l, n, m);
+    vector<bool> mark(l + 1);
+    for (int i = 0; i < n; ++i) {
+        read(int, l, r);
+        for (int j = l; j < r; ++j) {
+            assert(mark[j] == 0);
+            mark[j] = 1;
+        }
+    }
+    vector<int> a(l + 1, INF);
+    for (int i = 0; i < m; ++i) {
+        read(int, x, w);
+        chmin(a[x], w);
+    }
+    vector<ll> dp(l + 2, INFLL);
+    dp[0] = 0;
+    for (int i = 1; i <= l + 1; ++i) {
+        if (mark[i - 1]) {
+            for (int j = 0; j < i; ++j) {
+                if (a[j] < INF) {
+                    chmin(dp[i], dp[j] + ll(1) * a[j] * (i - j));
+                }
+            }
+        } else {
+            chmin(dp[i], dp[i - 1]);
+        }
+    }
+    cout << (dp[l + 1] == INFLL ? -1 : dp[l + 1]) << '\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-990f.cc

@@ -0,0 +1,611 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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)])
+
+__attribute__((target("lzcnt")))
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+class quick_union {
+private:
+    vector<size_t> c, sz;
+public:
+    quick_union(size_t n) : c(n), sz(n) {
+        iota(c.begin(), c.end(), 0);
+        sz.assign(n, 1);
+    }
+    size_t query(size_t i) {
+        if (c[i] != i) c[i] = query(c[i]);
+        return c[i];
+    }
+    void merge(size_t i, size_t j) {
+        if (connected(i, j)) return;
+        sz[query(j)] += sz[query(i)];
+        c[query(i)] = query(j);
+    }
+    bool connected(size_t i, size_t j) {
+        return query(i) == query(j);
+    }
+    size_t query_size(size_t i) {
+        return sz[query(i)];
+    }
+};
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n);
+    readvec1(int, w, n);
+    read(int, m);
+    readvec(pii, edges, m);
+    vector<vector<pii>> e(n + 1);
+    quick_union qu(n + 1);
+    for (int i = 0; i < m; ++i) {
+        auto&& [u, v] = edges[i];
+        if (qu.connected(u, v)) continue;
+        qu.merge(u, v);
+        Edgew(e, u, v, i + 1);
+        Edgew(e, v, u, -(i + 1));
+    }
+    vector<int> res(m);
+    vector<int> sum(n + 1);
+    {
+        auto dfs = [&] (auto dfs, int v, int pa) -> void {
+            sum[v] += w[v];
+            for (auto&& [u, i] : e[v]) {
+                if (u == pa) continue;
+                dfs(dfs, u, v);
+                sum[v] += sum[u];
+            }
+        };
+        dfs(dfs, 1, 0);
+    }
+    if (sum[1] != 0) {
+        cout << "Impossible\n";
+        return;
+    }
+    {
+        auto dfs = [&] (auto dfs, int v, int pa) -> void {
+            for (auto [u, i] : e[v]) {
+                if (u == pa) continue;
+                int direction = i / abs(i);
+                i = abs(i) - 1;
+                res[i] = direction * sum[u];
+                dfs(dfs, u, v);
+            }
+        };
+        dfs(dfs, 1, 0);
+    }
+    cout << "Possible\n";
+    putvec_eol(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-990g.cc

@@ -0,0 +1,625 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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)])
+
+__attribute__((target("lzcnt")))
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+class quick_union {
+private:
+    vector<size_t> c, sz;
+public:
+    quick_union(size_t n) : c(n), sz(n) {
+        iota(c.begin(), c.end(), 0);
+        sz.assign(n, 1);
+    }
+    size_t query(size_t i) {
+        if (c[i] != i) c[i] = query(c[i]);
+        return c[i];
+    }
+    void merge(size_t i, size_t j) {
+        if (connected(i, j)) return;
+        sz[query(j)] += sz[query(i)];
+        c[query(i)] = query(j);
+    }
+    bool connected(size_t i, size_t j) {
+        return query(i) == query(j);
+    }
+    size_t query_size(size_t i) {
+        return sz[query(i)];
+    }
+};
+
+// __attribute__((target("popcnt")))
+void solve() {
+    constexpr int N = 2e5;
+    read(int, n);
+    readvec1(int, a, n);
+    vector<vector<pii>> edges(N + 1);
+    vector<vector<int>> vertices(N + 1);
+    for (int i = 0; i < n - 1; ++i) {
+        read(int, u, v);
+        int g = gcd(a[u], a[v]);
+        edges[g].emplace_back(u, v);
+    }
+    for (int i = 1; i <= n; ++i) {
+        vertices[a[i]].emplace_back(i);
+    }
+    vector<ll> f(N + 1);
+    vector<int> rev(n + 1);
+    vector<bool> oc(N + 1);
+    for (int i = 1; i <= N; ++i) {
+        vector<int> vs;
+        auto add = [&] (int i) { if (oc[i] == 0) oc[i] = 1, vs.emplace_back(i); };
+        auto del = [&] (int i) { oc[i] = 0; };
+        for (int j = i; j <= N; j += i) {
+            for (auto&& [u, v] : edges[j]) {
+                add(u), add(v);
+            }
+            for (auto&& v : vertices[j]) {
+                add(v);
+            }
+        }
+        int m = vs.size();
+        for (int j = 0; j < m; ++j) {
+            rev[vs[j]] = j;
+        }
+        quick_union qu(m);
+        for (int j = i; j <= N; j += i) {
+            for (auto&& [u, v] : edges[j]) {
+                qu.merge(rev[u], rev[v]);
+                del(u), del(v);
+            }
+            for (auto&& v : vertices[j]) {
+                del(v);
+            }
+        }
+        for (int j = 0; j < m; ++j) {
+            if (qu.query(j) == j) {
+                f[i] += ll(1) * qu.query_size(j) * (qu.query_size(j) + 1) / 2;
+            }
+        }
+    }
+    for (int i = N; i; --i) {
+        for (int j = 2 * i; j <= N; j += i) {
+            f[i] -= f[j];
+        }
+    }
+    for (int i = 1; i <= N; ++i) {
+        if (f[i] != 0) {
+            cout << i << ' ' << f[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-993d.cc

@@ -0,0 +1,605 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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))
+
+// add declarations to avoid cyclic dependency
+template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
+template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
+template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
+template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
+template<typename T> ostream& operator<<(ostream&, const vector<T>&);
+std::ostream& operator<<(std::ostream&, const int128&);
+
+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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wparentheses"
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+#pragma GCC diagnostic pop
+
+
+#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)])
+
+__attribute__((target("lzcnt")))
+constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n);
+    readvec(int, a, n);
+    readvec(int, b, n);
+    vector<pair<int, vector<int>>> bk;
+    vector<int> idx(n);
+    iota(idx.begin(), idx.end(), 0);
+    sort_by_key(idx.begin(), idx.end(), expr(a[i], int i));
+    for (auto&& i : idx) {
+        if (bk.empty() or a[i] != bk.back().first) {
+            bk.emplace_back(a[i], vector<int>());
+        }
+        bk.back().second.emplace_back(b[i]);
+    }
+    int m = bk.size();
+    for (int i = 0; i < m; ++i) {
+        sort(bk[i].second.begin(), bk[i].second.end(), greater());
+    }
+    auto work = [&] (ld x) {
+        vector<ld> dp(n + 1, INFLL);
+        dp[0] = 0;
+        for (int i = 0; i < m; ++i) {
+            vector<ld> ndp(n + 1, INFLL);
+            int m = bk[i].second.size();
+            vector<ld> ps(m + 1);
+            for (int j = 1; j <= m; ++j) {
+                ps[j] = ps[j - 1] + (bk[i].first - x * bk[i].second[j - 1]);
+            }
+            for (int j = 0; j <= n; ++j) {
+                for (int k = 0; k <= m; ++k) {
+                    int idx = max(0, j - k) + m - k;
+                    if (idx >= 0 and idx <= n) {
+                        chmin(ndp[idx], dp[j] + ps[k]);
+                    }
+                }
+            }
+            dp = std::move(ndp);
+        }
+        return dp[0];
+    };
+    ld l = 0, r = INF;
+    while (r - l > 1e-9) {
+        ld mid = (l + r) / 2;
+        if (work(mid) <= 0) {
+            r = mid;
+        } else {
+            l = mid;
+        }
+    }
+    cout << ll(ceil(l * 1000)) << '\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

@@ -1,5 +1,5 @@
 // #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
-#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
+#pragma GCC optimize("Ofast")
 /************* This code requires C++17. ***************/
 
 #include<bits/stdc++.h>
@@ -12,6 +12,8 @@ using namespace std;
 constexpr void __() {}
 #define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
 #define __as_typeof(container) remove_reference<decltype(container)>::type
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
 
 /* type aliases */
 #if LONG_LONG_MAX != INT64_MAX
@@ -177,6 +179,14 @@ template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T,
     out << "{" << p.first << ", " << p.second << "}";
     return out;
 }
+template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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
@@ -217,9 +227,9 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
 }
 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 read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
-#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (auto& x : a) cin >> x;)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::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 readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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"));)
@@ -229,9 +239,24 @@ template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __
 #define deb(...) debug(make_tuple(__VA_ARGS__))
 
 /* pops */
-#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+template <typename Container>
-#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+inline auto poptop(Container& q) {
-#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
 
 /* math */
 template <typename return_t>
@@ -243,11 +268,30 @@ return_t qpow(ll b, ll p) {
     else return half * half;
 }
 
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
 #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)])
 
+__attribute__((target("lzcnt")))
 constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
 
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
 void __exgcd(ll a, ll b, ll& x, ll& y) {
   if (b == 0) {
     x = 1, y = 0;
@@ -358,11 +402,11 @@ template <ll mdl> struct MLL {
     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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
-    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
-    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
-    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
-    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
 };
 
 template <ll mdl>
@@ -467,44 +511,170 @@ 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 val = -INF;
+    void apply(const Tag& rhs, size_t len) { }
+};
+Info operator+(const Info &a, const Info &b) {
+    return {max(a.val, b.val)};
+}
+struct MinInfo {
+    int val = INF;
+    void apply(const Tag& rhs, size_t len) { }
+};
+MinInfo operator+(const MinInfo &a, const MinInfo &b) {
+    return {min(a.val, b.val)};
+}
+
 // __attribute__((target("popcnt")))
 void solve() {
-    read(int, n, m);
+    read(int, n);
-    readvec(int, a, m);
+    vector<tiii> a;
-    reverse(a.begin(), a.end());
+    vector<int> oc;
-    vector<vector<int>> ban(n + 1);
+    for (int i = 0; i < n; ++i) {
-    vector<int> res(n + 1);
+        read(int, l, r);
-    for (int i = 1; i <= n; ++i) {
+        a.emplace_back(l, r, i);
-        int pos = -1;
+        oc.emplace_back(l);
-        int k = ban[i].size();
+        oc.emplace_back(r);
-        sort(ban[i].begin(), ban[i].end());
+    }
-        if (ban[i].empty() or ban[i][0] != 0) {
+    sort(oc.begin(), oc.end());
-            pos = 0;
+    int m = unique(oc.begin(), oc.end()) - oc.begin();
+    oc.resize(m);
+    auto rev = [&] (int x) {
+        return lower_bound(oc.begin(), oc.end(), x) - oc.begin();
+    };
+    sort_by_key(a.begin(), a.end(), expr(pair(get<0>(p), -get<1>(p)), auto&& p));
+    segtree<Info, Tag> left(m);
+    vector<int> ll(n);
+    for (int i = 0; i < n; ++i) {
+        auto [l, r, idx] = a[i];
+        // deb(l, r, idx);
+        // deb(rev(l), rev(r));
+        l = rev(l), r = rev(r);
+        ll[idx] = left.range_query(r, m - 1).val;
+        left.set(r, {max(l, left.query(r).val)});
+        if (i and get<0>(a[i]) == get<0>(a[i - 1]) and get<1>(a[i]) == get<1>(a[i - 1])) {
+            ll[get<2>(a[i - 1])] = l;
+        }
+    }
+    sort_by_key(a.begin(), a.end(), expr(pair(-get<1>(p), get<0>(p)), auto&& p));
+    segtree<MinInfo, Tag> right(m);
+    vector<int> rr(n);
+    for (int i = 0; i < n; ++i) {
+        auto [l, r, idx] = a[i];
+        l = rev(l), r = rev(r);
+        rr[idx] = right.range_query(0, l).val;
+        right.set(l, {min(r, right.query(l).val)});
+        if (i and get<0>(a[i]) == get<0>(a[i - 1]) and get<1>(a[i]) == get<1>(a[i - 1])) {
+            rr[get<2>(a[i - 1])] = r;
+        }
+    }
+    sort_by_key(a.begin(), a.end(), expr(get<2>(p), auto&& p));
+    for (int i = 0; i < n; ++i) {
+        if (ll[i] == -INF) {
+            cout << 0 << '\n';
         } else {
-            for (int j = 1; j < k; ++j) {
+            // deb(ll[i], rr[i]);
-                if (ban[i][j] > ban[i][j - 1] + 1) {
+            // debug(a[i]);
-                    pos = ban[i][j - 1] + 1;
+            cout << oc[rr[i]] - oc[ll[i]] - (get<1>(a[i]) - get<0>(a[i])) << '\n';
-                    goto fi;
         }
     }
-            if (ban[i].back() + 1 < m) {
-                pos = ban[i].back() + 1;
-            }
-        }
-    fi:
-        if (pos == -1) {
-            cout << -1 << '\n';
-            return;
-        } else {
-            res[i] = a[pos];
-            for (int j = i + i; j <= n; j += i) {
-                ban[j].emplace_back(pos);
-            }
-        }
-    }
-    for (int i = 1; i <= n; ++i) {
-        cout << res[i] << " \n"[i == n];
-    }
 }
 
 int main() {

src/bin/e.cc

@@ -1,5 +1,5 @@
 // #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
-#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
+#pragma GCC optimize("Ofast")
 /************* This code requires C++17. ***************/
 
 #include<bits/stdc++.h>
@@ -12,6 +12,8 @@ using namespace std;
 constexpr void __() {}
 #define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
 #define __as_typeof(container) remove_reference<decltype(container)>::type
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
 
 /* type aliases */
 #if LONG_LONG_MAX != INT64_MAX
@@ -177,6 +179,14 @@ template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T,
     out << "{" << p.first << ", " << p.second << "}";
     return out;
 }
+template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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
@@ -217,9 +227,9 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
 }
 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 read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
-#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (auto& x : a) cin >> x;)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::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 readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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"));)
@@ -229,9 +239,24 @@ template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __
 #define deb(...) debug(make_tuple(__VA_ARGS__))
 
 /* pops */
-#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+template <typename Container>
-#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+inline auto poptop(Container& q) {
-#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
 
 /* math */
 template <typename return_t>
@@ -243,11 +268,29 @@ return_t qpow(ll b, ll p) {
     else return half * half;
 }
 
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
 #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); }
 
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
 void __exgcd(ll a, ll b, ll& x, ll& y) {
   if (b == 0) {
     x = 1, y = 0;
@@ -358,11 +401,11 @@ template <ll mdl> struct MLL {
     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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
-    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
-    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
-    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
-    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
 };
 
 template <ll mdl>
@@ -456,7 +499,7 @@ constexpr std::array<T, N> __initarray(const T& value) {
 }
 /*******************************************************/
 
-// #define SINGLE_TEST_CASE
+#define SINGLE_TEST_CASE
 // #define DUMP_TEST_CASE 7219
 // #define TOT_TEST_CASE 10000
 
@@ -469,21 +512,25 @@ void prep() {
 
 // __attribute__((target("popcnt")))
 void solve() {
-    using mll = MLL<PRIME>;
-
     read(int, n);
-    vector<array<mll, 4>> dp(n + 1);
+    readvec(ll, a, n);
-    vector<array<mll, 4>> ps(n + 1);
+    vector<int> left(n, -1);
-    dp[2][0] = 1;
+    for (int i = 0; i < 32; ++i) {
-    for (int i = 3; i <= n; ++i) {
+        vector<int> stack;
-        dp[i][0] += dp[i - 1][0];
+        for (int j = 0; j < n; ++j) {
-        dp[i][1] += dp[i - 1][0];
+            if (a[j] >> i & 1) {
-        dp[i][2] += ps[i - 1][1] + ps[i - 1][2];
+                stack.emplace_back(j);
-        dp[i][3] += dp[i - 1][2] + dp[i - 1][3];
-        ps[i][1] = ps[i - 1][1] + dp[i][1] * (i - 1);
-        ps[i][2] = ps[i - 1][2] + dp[i][2] * i;
             }
-    cout << dp[n][2] + dp[n][3] + n - 1 << '\n';
+            if (stack.size() > 1) {
+                chmax(left[j], stack[stack.size() - 2]);
+            }
+        }
+    }
+    ll res = 0;
+    for (int i = 0; i < n; ++i) {
+        res += i - left[i];
+    }
+    cout << res << '\n';
 }
 
 int main() {

src/bin/f.cc

@@ -1,5 +1,5 @@
 // #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
-#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
+#pragma GCC optimize("Ofast")
 /************* This code requires C++17. ***************/
 
 #include<bits/stdc++.h>
@@ -12,6 +12,8 @@ using namespace std;
 constexpr void __() {}
 #define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
 #define __as_typeof(container) remove_reference<decltype(container)>::type
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
 
 /* type aliases */
 #if LONG_LONG_MAX != INT64_MAX
@@ -177,6 +179,14 @@ template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T,
     out << "{" << p.first << ", " << p.second << "}";
     return out;
 }
+template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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
@@ -217,9 +227,9 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
 }
 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 read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
-#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (auto& x : a) cin >> x;)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::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 readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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"));)
@@ -229,9 +239,24 @@ template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __
 #define deb(...) debug(make_tuple(__VA_ARGS__))
 
 /* pops */
-#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
+template <typename Container>
-#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
+inline auto poptop(Container& q) {
-#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
 
 /* math */
 template <typename return_t>
@@ -243,11 +268,29 @@ return_t qpow(ll b, ll p) {
     else return half * half;
 }
 
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
 #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); }
 
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
 void __exgcd(ll a, ll b, ll& x, ll& y) {
   if (b == 0) {
     x = 1, y = 0;
@@ -358,11 +401,11 @@ template <ll mdl> struct MLL {
     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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
-    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
-    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
-    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
-    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
 };
 
 template <ll mdl>
@@ -456,7 +499,7 @@ constexpr std::array<T, N> __initarray(const T& value) {
 }
 /*******************************************************/
 
-// #define SINGLE_TEST_CASE
+#define SINGLE_TEST_CASE
 // #define DUMP_TEST_CASE 7219
 // #define TOT_TEST_CASE 10000
 
@@ -469,34 +512,21 @@ void prep() {
 
 // __attribute__((target("popcnt")))
 void solve() {
-    read(int, n, m, k);
+    read(int, n, c);
-    readvec(int, h, n);
+    readvec(ll, a, n);
-    readvec(int, p, n);
+    readvec(ll, b, n);
-    auto check = [&] (int target) {
+    vector<ll> psa(n + 1), psb(n + 1);
-        map<int, int> all;
+    partial_sum(a.begin(), a.end(), psa.begin() + 1);
-        for (int i = 0; i < n; ++i) {
+    partial_sum(b.begin(), b.end(), psb.begin() + 1);
-            if (ll(m) * target < h[i]) continue;
+    vector dp(n + 1, vector<int128>(2, -INFLL));
-            int d = min<ll>(m - 1, (ll(m) * target - h[i]) / target);
+    dp[0] = { 0, 0 };
-            all[p[i] - d] += 1;
+    for (int i = 1; i <= n; ++i) {
-            all[p[i] + d + 1] -= 1;
+        for (int j = 1; j < 65 and i - j >= 0; ++j) {
-        }
+            chmax(dp[i][0], dp[i - j][1] - c * ((int128(1) << j) - 1) + psa[i] - psa[i - j]);
-        int tot = 0;
+            chmax(dp[i][1], dp[i - j][0] - c * ((int128(1) << j) - 1) + psb[i] - psb[i - j]);
-        for (auto&& [_, v] : all) {
-            tot += v;
-            if (tot >= k) return true;
-        }
-        return false;
-    };
-    int l = 1, r = INF;
-    while (l < r) {
-        int mid = l + r >> 1;
-        if (check(mid)) {
-            r = mid;
-        } else {
-            l = mid + 1;
         }
     }
-    cout << (l == INF ? -1 : l) << '\n';
+    cout << max(dp[n][0], dp[n][1]) << '\n';
 }
 
 int main() {

src/bin/fdupc-24a.cc

@@ -0,0 +1,549 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(ll, n);
+    ll res = -1;
+    for (ll i = 0; 328 * i <= n; ++i) {
+        if ((n - 328 * i) % 268 == 0) {
+            chmax(res, i);
+        }
+    }
+    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/fdupc-24b.cc

@@ -0,0 +1,621 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+struct pollard_rho {
+    ll max_factor;
+    pollard_rho() : max_factor(0) { srand(time(NULL)); }
+
+    ll quick_pow(ll x, ll p, ll mod) {
+        ll ans = 1;
+        while (p) {
+            if (p & 1) ans = (__int128)ans * x % mod;
+            x = (__int128)x * x % mod;
+            p >>= 1;
+        }
+        return ans;
+    }
+    bool Miller_Rabin(ll p) {
+        if (p < 2) return 0;
+        if (p == 2) return 1;
+        if (p == 3) return 1;
+        ll d = p - 1, r = 0;
+        while (!(d & 1)) ++r, d >>= 1;
+        for (ll k = 0; k < 10; ++k) {
+            ll a = rand() % (p - 2) + 2;
+            ll x = quick_pow(a, d, p);
+            if (x == 1 || x == p - 1) continue;
+            for (int i = 0; i < r - 1; ++i) {
+                x = (__int128)x * x % p;
+                if (x == p - 1) break;
+            }
+            if (x != p - 1) return 0;
+        }
+        return 1;
+    }
+    ll Pollard_Rho(ll x) {
+        ll s = 0, t = 0;
+        ll c = (ll)rand() % (x - 1) + 1;
+        int step = 0, goal = 1;
+        ll val = 1;
+        for (goal = 1;; goal *= 2, s = t, val = 1) {
+            for (step = 1; step <= goal; ++step) {
+                t = ((__int128)t * t + c) % x;
+                val = (__int128)val * abs(t - s) % x;
+                if ((step % 127) == 0) {
+                    ll d = gcd(val, x);
+                    if (d > 1) return d;
+                }
+            }
+            ll d = gcd(val, x);
+            if (d > 1) return d;
+        }
+    }
+    void fac(ll x) {
+        if (x <= max_factor || x < 2) return;
+        if (Miller_Rabin(x)) {
+            max_factor = max(max_factor, x);
+            return;
+        }
+        ll p = x;
+        while (p >= x) p = Pollard_Rho(x);
+        while ((x % p) == 0) x /= p;
+        fac(x), fac(p);
+    }
+    // find greatest prime factor of `x`
+    ll solve(ll x) {
+        max_factor = 0;
+        fac(x);
+        return max_factor;
+    }
+};
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n);
+    if (n % 2 == 0) {
+        cout << n / 2 << '\n';
+    } else {
+        for (int i = 3; i * i <= n + 1; ++i) {
+            if (n % i == 0) {
+                cout << 1 + (n - i) / 2 << '\n';
+                return;
+            }
+        }
+        cout << 1 << '\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/fdupc-24c.cc

@@ -0,0 +1,549 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n, k);
+    readvec(int, a, n);
+    sort(a.begin(), a.end(), greater());
+    ll d = 0;
+    for (int i = k; i < n; i += k + 1) {
+        d += a[i];
+    }
+    cout << accumulate(a.begin(), a.end(), ll(0)) - d << '\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/fdupc-24d.cc

@@ -0,0 +1,555 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(ll, n);
+    int128 l = 0, r = INFLL;
+    while (l < r) {
+        int128 mid = l + r >> 1;
+        if ((1 + mid) * mid / 2 >= n) {
+            r = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    while (((1 + l) * l / 2 - n) % 2 != 0) {
+        l += 1;
+    }
+    cout << l << '\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/fdupc-24e.cc

@@ -0,0 +1,560 @@
+// #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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n);
+    readvec(ll, a, n);
+    vector<int> left(n, -1);
+    for (int i = 0; i < 32; ++i) {
+        vector<int> stack;
+        for (int j = 0; j < n; ++j) {
+            if (a[j] >> i & 1) {
+                stack.emplace_back(j);
+            }
+            if (stack.size() > 1) {
+                chmax(left[j], stack[stack.size() - 2]);
+            }
+        }
+    }
+    ll res = 0;
+    for (int i = 0; i < n; ++i) {
+        res += i - left[i];
+    }
+    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/fdupc-24f.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
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
+
+/* 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 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 T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
+    for (size_t i = 0; i < N; ++i) in >> a[i];
+    return in;
+}
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a(n); for (auto& x : a) cin >> x;)
+#define readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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 */
+template <typename Container>
+inline auto poptop(Container& q) {
+    auto ret = q.top();
+    q.pop();
+    return ret;
+}
+template <typename Container>
+inline auto popback(Container& q) {
+    auto ret = q.back();
+    q.pop_back();
+    return ret;
+}
+template <typename Container>
+inline auto popfront(Container& q) {
+    auto ret = q.front();
+    q.pop_front();
+    return ret;
+}
+
+/* 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;
+}
+
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
+#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); }
+
+template <typename T>
+T mygcd(T a, T b) { return b == 0 ? a : mygcd(b, a % b); }
+
+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; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
+};
+
+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() {
+}
+
+// __attribute__((target("popcnt")))
+void solve() {
+    read(int, n, c);
+    readvec(ll, a, n);
+    readvec(ll, b, n);
+    vector<ll> psa(n + 1), psb(n + 1);
+    partial_sum(a.begin(), a.end(), psa.begin() + 1);
+    partial_sum(b.begin(), b.end(), psb.begin() + 1);
+    vector dp(n + 1, vector<int128>(2, -INFLL));
+    dp[0] = { 0, 0 };
+    for (int i = 1; i <= n; ++i) {
+        for (int j = 1; j < 65 and i - j >= 0; ++j) {
+            chmax(dp[i][0], dp[i - j][1] - c * ((int128(1) << j) - 1) + psa[i] - psa[i - j]);
+            chmax(dp[i][1], dp[i - j][0] - c * ((int128(1) << j) - 1) + psb[i] - psb[i - j]);
+        }
+    }
+    cout << max(dp[n][0], dp[n][1]) << '\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,13 +1,19 @@
+4
+3
+3 8
+2 5
+4 5
+2
+42 42
+1 1000000000
+3
+42 42
+1 1000000000
+42 42
 6
-
+1 10
-1 10 1
+3 10
-
+3 7
-1 2 2
+5 7
-
+4 4
-2 10 3
+1 2
-
-2 20 3
-
-3 1 4
-
-4 10 4

src/bin/template.cc

@@ -172,6 +172,17 @@ template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, s
 
 /* io */
 #define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
+
+// add declarations to avoid cyclic dependency
+template<typename T, typename U> istream& operator>>(istream&, pair<T, U>&);
+template<typename T, typename U> ostream& operator<<(ostream&, const pair<T, U>&);
+template<typename T, size_t N> istream& operator>>(istream&, array<T, N>&);
+template <typename T, size_t N> ostream& operator<<(ostream&, const array<T, N>&);
+template<typename Char, typename Traits, typename... Args>
+decltype(auto) operator<<(std::basic_ostream<Char, Traits>&, const std::tuple<Args...>&);
+template<typename T> ostream& operator<<(ostream&, const vector<T>&);
+std::ostream& operator<<(std::ostream&, const int128&);
+
 template<typename T, typename U> istream& operator>>(istream& in, pair<T, U>& p) {
     return in >> p.first >> p.second;
 }
@@ -269,6 +280,8 @@ return_t qpow(ll b, ll p) {
 }
 
 // Accurately find `i` 'th root of `n` (taking the floor)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wparentheses"
 inline ll root(ll n, ll i) {
     ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
     while (l < r) {
@@ -281,11 +294,13 @@ inline ll root(ll n, ll i) {
     }
     return l;
 }
+#pragma GCC diagnostic pop
 
 
 #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)])
 
+__attribute__((target("lzcnt")))
 constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
 
 template <typename T>

src/bin/test.cc

@@ -1,5 +1,5 @@
 // #pragma GCC target("popcnt,lzcnt,abm,bmi,bmi2")
-// #pragma GCC optimize("Ofast")
+#pragma GCC optimize("Ofast")
 /************* This code requires C++17. ***************/
 
 #include<bits/stdc++.h>
@@ -12,6 +12,8 @@ using namespace std;
 constexpr void __() {}
 #define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
 #define __as_typeof(container) remove_reference<decltype(container)>::type
+template <typename T> struct argument_type;
+template <typename T, typename U> struct argument_type<T(U)> { using type = U; };
 
 /* type aliases */
 #if LONG_LONG_MAX != INT64_MAX
@@ -178,9 +180,13 @@ template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T,
     return out;
 }
 template<typename T, size_t N> istream& operator>>(istream& in, array<T, N>& a) {
-    for (int i = 0; i < N; ++i) in >> a[i];
+    for (size_t i = 0; i < N; ++i) in >> a[i];
     return in;
 }
+template <typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
+    for (auto&& i : a) out << i << ' ';
+    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
@@ -221,9 +227,9 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) {
 }
 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 read(t, ...) __AS_PROCEDURE(argument_type<void(t)>::type __VA_ARGS__; __read(__VA_ARGS__);)
-#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (auto& x : a) cin >> x;)
+#define readvec(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::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 readvec1(t, a, n) __AS_PROCEDURE(vector<argument_type<void(t)>::type> a((n) + 1); copy_n(ii<argument_type<void(t)>::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"));)
@@ -262,6 +268,21 @@ return_t qpow(ll b, ll p) {
     else return half * half;
 }
 
+// Accurately find `i` 'th root of `n` (taking the floor)
+inline ll root(ll n, ll i) {
+    ll l = 0, r = pow(LLONG_MAX, ld(1) / i);
+    while (l < r) {
+        ll mid = l + r + 1 >> 1;
+        if (qpow<int128>(mid, i) <= n) {
+            l = mid;
+        } else {
+            r = mid - 1;
+        }
+    }
+    return l;
+}
+
+
 #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)])
 
@@ -380,11 +401,11 @@ template <ll mdl> struct MLL {
     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) { return *this = *this + rhs; }
+    MLL& operator+=(const MLL& rhs) { return *this = *this + rhs; }
-    void operator-=(const MLL& rhs) { return *this = *this - rhs; }
+    MLL& operator-=(const MLL& rhs) { return *this = *this - rhs; }
-    void operator*=(const MLL& rhs) { return *this = *this * rhs; }
+    MLL& operator*=(const MLL& rhs) { return *this = *this * rhs; }
-    void operator/=(const MLL& rhs) { return *this = *this / rhs; }
+    MLL& operator/=(const MLL& rhs) { return *this = *this / rhs; }
-    void operator%=(const MLL& rhs) { return *this = *this % rhs; }
+    MLL& operator%=(const MLL& rhs) { return *this = *this % rhs; }
 };
 
 template <ll mdl>
@@ -489,81 +510,25 @@ void dump_ignore() {}
 void prep() {
 }
 
-// WARN: Input could contain multiple edges, but not self loops
-//
-// Returns: (BCC count, indices of BCCs of each vertex)
-//
-// BCC index starts from 1
-pair<int, vector<vector<int>>> vbcc(const vector<vector<int>>& ch) {
-    int n = ch.size() - 1;
-    vector<vector<int>> c(n + 1);  // a vertex could be contained in multiple vBCCs
-
-    int tm = 0;
-    int cnt = 0;
-
-    vector<int> low(n + 1), dfn(n + 1);
-    vector<int> stack;
-    auto dfs = [&] (auto dfs, int v, int pa) -> void {
-        int son = 0;
-        low[v] = dfn[v] = ++tm;
-        stack.emplace_back(v);
-        for (auto&& u : ch[v]) {
-            if (u == pa) continue;
-            son += 1;
-            if (not dfn[u]) {
-                dfs(dfs, u, v);
-                chmin(low[v], low[u]);
-                if (low[u] >= dfn[v]) {
-                    cnt += 1;
-                    int z;
-                    do {
-                        z = popback(stack);
-                        c[z].emplace_back(cnt);
-                    } while (z != u);
-                    c[v].emplace_back(cnt);
-                }
-            }
-            chmin(low[v], dfn[u]);
-        }
-        if (pa == 0 and son == 0) {
-            cnt += 1;
-            c[v].emplace_back(cnt);
-        }
-    };
-    for (int i = 1; i <= n; ++i) {
-        if (not dfn[i]) {
-            dfs(dfs, i, 0);
-        }
-    }
-    return { cnt, c };
-}
-
 // __attribute__((target("popcnt")))
 void solve() {
-    read(int, n, m);
+    read(int, n);
-    adj(ch, n);
+    readvec(int, a, n);
-    while (m--) {
+    vector<int> rev(n + 1);
-        read(int, u, v);
+    for (int i = 0; i < n; ++i) {
-        if (u == v) continue;
+        rev[a[i]] = i;
-        edge(ch, u, v);
     }
-    auto [cnt, c] = vbcc(ch);
+    int res = 0;
-    cout << cnt << '\n';
-    vector<vector<int>> bk(cnt);
-    // debug(cnt);
     for (int i = 1; i <= n; ++i) {
-        // deb(i, c[i]);
+        for (int j = i + 1; ll(i) * j <= n; ++j) {
-        for (auto&& j : c[i]) {
+            for (int k = j + 1; ll(k) * i * j <= n; ++k) {
-            bk[j - 1].emplace_back(i);
+                if (rev[i * j * k] > rev[k] and rev[k] > rev[j] and rev[j] > rev[i]) {
+                    res += 1;
                 }
             }
-    for (auto&& v : bk) {
-        cout << v.size() << ' ';
-        for (auto&& u : v) {
-            cout << u << ' ';
         }
-        cout << '\n';
     }
+    cout << res << '\n';
 }
 
 int main() {

src/bin/test.py

@@ -7,10 +7,7 @@ import io
 PRIME = 998_244_353
 
 if __name__ == '__main__':
-    N = 100000
+    N = 200000
     print(N)
-    print(*(random() for _ in range(N)))
+    print(*(166320 for _ in range(N)))
-    print(*(f'{randint(0, i - 1)} {i}' for i in range(1, N)), sep='\n')
+    print(*(f'{i} {randint(1, i - 1)}' for i in range(2, N + 1)))
-    print(N)
-    for _ in range(N):
-        print(randint(0, N - 1), random())