diff --git a/src/bin/a.cc b/src/bin/a.cc
index 8f8e87f..228cafb 100644
--- a/src/bin/a.cc
+++ b/src/bin/a.cc
@@ -257,15 +257,12 @@ void dump() {}
 void prep() {}
 
 void solve() {
-    read(int, n);
-    cout << "0 ";
-    for (int i = 1; i <= (n - 1) / 2; ++i) {
-        cout << i << ' ' << -i << ' ';
+    read(int, n, m, k);
+    if (n - k >= 1 && m * (n - k - 1) >= n) {
+        cout << "YES\n";
+    } else {
+        cout << "NO\n";
     }
-    if (n % 2 == 0) {
-        cout << (n - 1) / 2 + 1;
-    }
-    cout << '\n';
 }
 
 int main() {
diff --git a/src/bin/a.out b/src/bin/a.out
index 4de3451..8304283 100755
Binary files a/src/bin/a.out and b/src/bin/a.out differ
diff --git a/src/bin/b.cc b/src/bin/b.cc
index 854c0f1..3da0e57 100644
--- a/src/bin/b.cc
+++ b/src/bin/b.cc
@@ -1,3 +1,4 @@
+#pragma GCC optimize("Ofast")
 /////////////////////////////////////////////////////////
 /**
  * Useful Macros
@@ -257,37 +258,26 @@ void prep() {}
 
 void solve() {
     read(int, n);
-    readvec(ll, a, n + 1);
-    vector<ll> ps(n + 2);
-    for (int i = 1; i <= n + 1; ++i) {
-        ps[i] = ps[i - 1] ^ a[i - 1];
-    }
-    vector<int> res(n + 2);
-    for (int i = 0; i <= n; ++i) {
-        if (ps[i] == a[i]) {
-            res[max(0, n - i - 1)] += 1;
-        }
-    }
-    int ptr = 0;
-    while (ptr <= n + 1 && res[ptr] == 2) {
-        res[ptr] = 0;
-        res[++ptr] += 1;
-    }
-    int lo = 0;
-    for (int i = n + 1; ~i; --i) {
-        if (res[i] == 0) {
-            if (lo == 0) {
-                ;;
-            } else {
-                cout << 0;
-            }
+    readvec(int, a, n);
+    int target = a[0];
+    int mn = INF;
+    int cnt = 0;
+    for (int i = 0; i < n; ++i) {
+        if (a[i] != target) {
+            mn = min(mn, cnt);
+            cnt = 0;
         } else {
-            lo = 1;
-            cout << 1;
+            cnt += 1;
         }
     }
-    if (lo == 0) cout << 0;
-    cout << '\n';
+    if (cnt) {
+        mn = min(mn, cnt);
+    }
+    if (mn == INF || mn == n) {
+        cout << -1 << '\n';
+    } else {
+        cout << mn << '\n';
+    }
 }
 
 int main() {
diff --git a/src/bin/c.cc b/src/bin/c.cc
index 85611e2..dc0af56 100644
--- a/src/bin/c.cc
+++ b/src/bin/c.cc
@@ -1,3 +1,4 @@
+#pragma GCC optimize("Ofast")
 /////////////////////////////////////////////////////////
 /**
  * Useful Macros
@@ -248,60 +249,32 @@ int period(string s) {  // find the length of shortest recurring period
 }
 /////////////////////////////////////////////////////////
 
-#define SINGLE_TEST_CASE
+// #define SINGLE_TEST_CASE
 // #define DUMP_TEST_CASE 512
 
 void dump() {}
 
 void prep() {}
 
-template<typename T>
-struct BIT {
-    int n;
-    vector<T> c;
-    BIT(size_t n) : n(n), c(n + 1) {}
-    void add(size_t i, const T& k) {
-        while (i <= n) {
-            c[i] += k;
-            i += lowbit(i);
-        }
-    }
-    T getsum(size_t i) {
-        T res = {};
-        while (i) {
-            res += c[i];
-            i -= lowbit(i);
-        }
-        return res;
-    }
-};
-
 void solve() {
-    read(int, n, q);
-    BIT<int> tr(n);
-    for (int i = 1; i <= n; ++i) {
-        read(int, x);
-        tr.add(i, x);
-    }
-    while (q--) {
-        read(int, x, p);
-        tr.add(x, ll(p) - tr.getsum(x) + tr.getsum(x - 1));
-        int l = 0, r = lg2(n);
-        while (l < r) {
-            int mid = l + r >> 1;
-            if (tr.getsum(n - (1 << mid)) == 0) {
-                r = mid;
+    read(string, a, b);
+    int n = a.size();
+    int f = 0;
+    for (int i = 0; i < n; ++i) {
+        if (a[i] != b[i]) {
+            if (f == 0) {
+                if (a[i] > b[i]) {
+                    swap(a[i], b[i]);
+                }
+                f = 1;
             } else {
-                l = mid + 1;
+                if (a[i] < b[i]) {
+                    swap(a[i], b[i]);
+                }
             }
         }
-        // debug(l);
-        if (tr.getsum(n - (1 << l)) != 0) {
-            cout << (1 << l + 1) << '\n';
-        } else {
-            cout << (1 << l) << '\n';
-        }
     }
+    cout << a << '\n' << b << '\n';
 }
 
 int main() {
diff --git a/src/bin/cf-1909d.cc b/src/bin/cf-1909d.cc
index cbf25c5..16a0043 100644
--- a/src/bin/cf-1909d.cc
+++ b/src/bin/cf-1909d.cc
@@ -256,46 +256,40 @@ void dump() {}
 
 void prep() {}
 
-template <typename Set, typename Key = typename Set::value_type>
-static inline Set
-set_intersection(const Set& lhs, const Set& rhs) {
-    if (lhs.size() <= rhs.size()) {
-        Set iset;
-        for (const Key& key : lhs) {
-            if (rhs.count(key) > 0) {
-                iset.insert(key);
-            }
-        }
-        return std::move(iset);
+ll mygcd(ll a, ll b) {
+    if (a == 0 || b == 0) {
+        return 0;
     } else {
-        return set_intersection(rhs, lhs);
+        return std::gcd(a, b);
     }
 }
+
 void solve() {
     read(int, n), read(ll, k);
     readvec(ll, a, n);
-    auto work = [&] (int idx) -> unordered_set<ll, safe_hash> {
-        ll x = a[idx];
-        unordered_set<ll, safe_hash> res;
-        while (x) {
-            res.emplace(x);
-            if (((x + k) & 1) || (x + k) / 2 == x) {
-                break;
-            }
-            x = (x + k) / 2;
-        }
-        return res;
-    };
-    auto st = work(0);
+    if (*min_element(a.begin(), a.end()) < k && *max_element(a.begin(), a.end()) > k) {
+        cout << -1 << '\n';
+        return;
+    }
+    ll tar = abs(a[0] - k);
     for (int i = 1; i < n; ++i) {
-        st = set_intersection(st, work(i));
+        tar = mygcd(tar, abs(a[i] - k));
     }
-    if (!st.size()) {
-        debug(-1);
-    } else {
-        ll target = *max_element(st.begin(), st.end());
-        debug(*max_element(st.begin(), st.end()));
+    if (tar == 0) {
+        for (int i = 0; i < n; ++i) {
+            if (a[i] != k) {
+                cout << -1 << '\n';
+                return;
+            }
+        }
+        cout << 0 << '\n';
+        return;
     }
+    ll res = 0;
+    for (int i = 0; i < n; ++i) {
+        res += abs(a[i] - k) / tar - 1;
+    }
+    cout << res << '\n';
 }
 
 int main() {
diff --git a/src/bin/d.cc b/src/bin/d.cc
index 80fae64..6ece7b2 100644
--- a/src/bin/d.cc
+++ b/src/bin/d.cc
@@ -1,3 +1,4 @@
+#pragma GCC optimize("Ofast")
 /////////////////////////////////////////////////////////
 /**
  * Useful Macros
@@ -263,6 +264,8 @@ template <ll mdl> struct MLL {
     friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); }
     friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); }
     friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); }
+    friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; }
+    friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; }
     void operator+=(const MLL& rhs) { val = (*this + rhs).val; }
     void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
     void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
@@ -281,51 +284,39 @@ istream& operator>>(istream& in, MLL<mdl>& num) {
 }
 
 void solve() {
-    using ll = MLL<PRIME>;
     read(int, n);
-    vector<vector<pii>> ch(n + 1);
-    for (int i = 0; i < n - 1; ++i) {
-        read(int, u, v);
-        ch[u].emplace_back(v, i);
-        ch[v].emplace_back(u, i);
-    }
-    read(ll, e);
-    int root = -1;
-    int root_edge;
-    for (int i = 1; i <= n; ++i) {
-        if (ch[i].size() == 1) {
-            root = i;
-            root_edge = ch[i][0].second;
-            break;
+    readvec(int, a, n);
+    sort(a.begin(), a.end());
+    array<vector<MLL<PRIME>>, 2> cnt = {vector<MLL<PRIME>>(10001), vector<MLL<PRIME>>(10001)};
+    int curr = 0;
+    cnt[curr][0] = 1;
+    for (auto&& x : a) {
+        curr ^= 1;
+        for (int i = 0; i <= 10000; ++i) {
+            cnt[curr][i] = cnt[1 ^ curr][i];
+        }
+        for (int i = x; i <= 10000; ++i) {
+            cnt[curr][i] += cnt[1 ^ curr][i - x];
         }
     }
-    if (root == -1) {
-        cout << -1 << '\n';
-        return;
-    }
-    vector<int> dis(n + 1);
-    auto dfs = [&] (auto dfs, int v, int pa, int d) -> void {
-        dis[v] = d;
-        for (auto&& [u, _] : ch[v]) {
-            if (u == pa) continue;
-            dfs(dfs, u, v, d + 1);
-        }
-    };
-    dfs(dfs, root, 0, 0);
-    ll res = accumulate(dis.begin(), dis.end(), ll(0)) + *max_element(dis.begin(), dis.end());
-    ll target = e * n;
-    ll tar = (target - res) / n + 1;
-    int64_t tar_val = tar.val;
-    if (tar_val <= n + 2) {
-        tar_val += PRIME;
-    }
-    for (int i = 0; i < n - 1; ++i) {
-        if (i == root_edge) {
-        cout << tar_val << '\n';
-        } else {
-            cout << 1 << '\n';
+    MLL<PRIME> res = 0;
+    MLL<PRIME> plus = 0, minus = 0;
+    for (auto&& x : a) {
+        for (int i = 0; i < x; ++i) {
+            res += cnt[curr][i] * x;
+            plus += cnt[curr][i] * x;
+            res -= cnt[curr][i] * ((x + i + 1) / 2);
+            minus += cnt[curr][i] * ((x + i + 1) / 2);
+            // cnt[curr][i] -= cnt[1 ^ curr][x - i];
         }
     }
+    // debug(res);
+    // debug(plus), debug(minus);
+    // debug(cnt[curr]);
+    for (int i = 1; i <= 5000; ++i) {
+        res += i * (cnt[curr][2 * i] + cnt[curr][2 * i - 1]);
+    }
+    cout << res << '\n';
 }
 
 int main() {
diff --git a/src/bin/e.cc b/src/bin/e.cc
index aa4d1a4..1e617da 100644
--- a/src/bin/e.cc
+++ b/src/bin/e.cc
@@ -249,55 +249,72 @@ int period(string s) {  // find the length of shortest recurring period
 }
 /////////////////////////////////////////////////////////
 
-// #define SINGLE_TEST_CASE
+#define SINGLE_TEST_CASE
 // #define DUMP_TEST_CASE 512
 
 void dump() {}
 
 void prep() {}
 
-template <ll mdl> struct MLL {
-    ll val;
-    MLL(ll v = 0) : val(mod(v, 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 * 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); }
-    void operator+=(const MLL& rhs) { val = (*this + rhs).val; }
-    void operator-=(const MLL& rhs) { val = (*this - rhs).val; }
-    void operator*=(const MLL& rhs) { val = (*this * rhs).val; }
-    void operator/=(const MLL& rhs) { val = (*this / rhs).val; }
-    void operator%=(const MLL& rhs) { val = (*this % rhs).val; }
-};
-
-template <ll mdl>
-ostream& operator<<(ostream& out, const MLL<mdl>& num) {
-    return out << num.val;
-}
-
-template <ll mdl>
-istream& operator>>(istream& in, MLL<mdl>& num) {
-    return in >> num.val;
-}
-
 void solve() {
-    using ll = MLL<MDL>;
-    read(int, n, m, k);
-    vector<ll> fact;
-    fact.push_back(1);
-    for (int i = 1; i <= n; ++i) {
-        fact.push_back(fact.back() * i);
+    read(int, n);
+    readvec(int, a, n);
+    vector<vector<int>> open(100010);
+    for (int i = 0; i < n; ++i) {
+        open[a[i]].push_back(i);
     }
-    // (M - K + 1) powers
-    vector<ll> pw1;
-    pw1.push_back(1);
-    for (int i = 1; i < k; ++i) {
-        pw1.push_back(pw1.back() * (m - k + 1));
+    vector<int> cnt(100010);
+    vector<int> state(n, 1);
+    int curr = 1;
+    for (int i = 0; i <= 1e5; ++i) {
+        int prev = -2;
+        int left = -1, right = -1;
+        for (auto&& x : open[i]) {
+            if (x == prev + 1) {
+                right = x;
+            } else {
+                if (left != -1) {
+                    if (left == 0 || state[left - 1] == 0) {
+                        if (right == n - 1 || state[right + 1] == 0) {
+                            curr -= 1;
+                        }
+                    } else {
+                        if (right == n - 1 || state[right + 1] == 0) {
+                            ;;
+                        } else {
+                            curr += 1;
+                        }
+                    }
+                }
+                left = x;
+                right = x;
+            }
+            state[x] = 0;
+        }
+        if (left != -1) {
+            if (left == 0 || state[left - 1] == 0) {
+                if (right == n - 1 || state[right + 1] == 0) {
+                    curr -= 1;
+                }
+            } else {
+                if (right == n - 1 || state[right + 1] == 0) {
+                    ;;
+                } else {
+                    curr += 1;
+                }
+            }
+        }
+        cnt[i] = curr;
+    }
+    // debug(cnt);
+    int mx = *max_element(a.begin(), a.end());
+    for (int k = 1; k <= mx; ++k) {
+        ll res = 0;
+        for (int i = 0; i <= mx; i += k) {
+            res += cnt[i];
+        }
+        cout << res << " \n"[k == mx];
     }
-    // (K - 1) powers
-    vector<ll> pw2;
-    for (int i = 1; i < k; ++i)
 }
 
 int main() {
diff --git a/src/bin/std.in b/src/bin/std.in
index d46e28e..205c90d 100644
--- a/src/bin/std.in
+++ b/src/bin/std.in
@@ -1,20 +1,3 @@
-9
-2 1
-3 4
-2 3
-7 11
-3 10
-100 40 100
-2 1
-1 2
-2 2
-1 2
-1 327869541
-327869541
-5 26250314066
-439986238782 581370817372 409476934981 287439719777 737637983182
-5 616753575719
-321037808624 222034505841 214063039282 441536506916 464097941819
-5 431813672576
-393004301966 405902283416 900951084746 672201172466 518769038906
+10
+1 9 7 6 2 4 7 8 1 3
 
diff --git a/src/bin/template.cc b/src/bin/template.cc
index f28bb5f..7d1dd69 100644
--- a/src/bin/template.cc
+++ b/src/bin/template.cc
@@ -257,7 +257,6 @@ void dump() {}
 void prep() {}
 
 void solve() {
-    
 }
 
 int main() {
diff --git a/src/bin/test.cc b/src/bin/test.cc
index b3c7b83..6f71774 100644
--- a/src/bin/test.cc
+++ b/src/bin/test.cc
@@ -1,421 +1,12 @@
-#pragma GCC optimize("Ofast")
-/////////////////////////////////////////////////////////
-/**
- * Useful Macros
- *   by subcrip
- * (requires C++17)
- */
-
-#include<bits/stdc++.h>
+#include <bits/stdc++.h>
 using namespace std;
 
-/* macro helpers */
-#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
-#define __DECOMPOSE_S(a, x) auto x = a;
-#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
-constexpr void __() {}
-#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
-#define __as_typeof(container) decltype(container)::value_type
-
-/* type aliases */
-using ll = int64_t;
-using ull = uint64_t;
-using pii = pair<int, int>;
-using pil = pair<int, ll>;
-using pli = pair<ll, int>;
-using pll = pair<ll, ll>;
-
-/* 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;
-
-/* random */
-
-mt19937 rd(chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count());
-
-/* bit-wise operations */
-#define lowbit(x) ((x) & -(x))
-#define popcount(x) (__builtin_popcountll(ll(x)))
-#define parity(x) (__builtin_parityll(ll(x)))
-#define msp(x) (63LL - __builtin_clzll(ll(x)))
-#define lsp(x) (__builtin_ctzll(ll(x)))
-
-/* arithmetic operations */
-#define mod(x, y) ((((x) % (y)) + (y)) % (y))
-
-/* fast pairs */
-#define upair ull
-#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1)))
-#define u1(p) ((p) >> 32)
-#define u2(p) ((p) & ((1ULL << 32) - 1))
-#define ult std::less<upair>
-#define ugt std::greater<upair>
-
-#define ipair ull
-#define imake(x, y) (umake(x, y))
-#define i1(p) (int(u1(ll(p))))
-#define i2(p) (ll(u2(p) << 32) >> 32)
-struct ilt {
-    bool operator()(const ipair& a, const ipair& b) const {
-        if (i1(a) == i1(b)) return i2(a) < i2(b);
-        else return i1(a) < i1(b);
-    }
-};
-struct igt {
-    bool operator()(const ipair& a, const ipair& b) const {
-        if (i1(a) == i1(b)) return i2(a) > i2(b);
-        else return i1(a) > i1(b);
-    }
-};
-
-/* conditions */
-#define loop while (1)
-#define if_or(var, val) if (!(var == val)) var = val; else
-#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
-#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
-
-/* hash */
-struct safe_hash {
-    // https://codeforces.com/blog/entry/62393
-    static uint64_t splitmix64(uint64_t x) {
-        // http://xorshift.di.unimi.it/splitmix64.c
-        x += 0x9e3779b97f4a7c15;
-        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
-        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
-        return x ^ (x >> 31);
-    }
-
-    size_t operator()(uint64_t x) const {
-        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
-        return splitmix64(x + FIXED_RANDOM);
-    }
-};
-
-struct pair_hash {
-    template <typename T, typename U>
-    size_t operator()(const pair<T, U>& a) const {
-        auto hash1 = safe_hash()(a.first);
-        auto hash2 = safe_hash()(a.second);
-        if (hash1 != hash2) {
-            return hash1 ^ hash2;
-        }
-        return hash1;
-    }
-};
-
-/* build data structures */
-#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
-#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
-#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
-#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
-#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
-#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
-#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
-template <typename T, typename Iterator> pair<size_t, map<T, size_t>> discretize(Iterator __first, Iterator __last) {
-    set<T> st(__first, __last);
-    size_t N = 0;
-    map<T, size_t> mp;
-    for (auto&& x : st) mp[x] = ++N;
-    return {N, mp};
-}
-template <typename T, typename Iterator> pair<size_t, unordered_map<T, size_t, safe_hash>> unordered_discretize(Iterator __first, Iterator __last) {
-    set<T> st(__first, __last);
-    size_t N = 0;
-    unordered_map<T, size_t, safe_hash> mp;
-    for (auto&& x : st) mp[x] = ++N;
-    return {N, mp};
-}
-
-/* io */
-#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
-template<typename T> void __read(T& x) { cin >> x; }
-template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
-#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
-#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
-#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
-#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;)
-#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
-template<typename T, typename U> ostream& operator<<(ostream& out, const pair<T, U>& p) {
-    out << "{" << p.first << ", " << p.second << "}";
-    return out;
-}
-template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
-void print_tuple_impl(std::basic_ostream<Char, Traits>& os, const Tuple& t, std::index_sequence<Index...>) {
-    using swallow = int[]; // guaranties left to right order
-    (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)... };
-}
-template<typename Char, typename Traits, typename... Args>
-decltype(auto) operator<<(std::basic_ostream<Char, Traits>& os, const std::tuple<Args...>& t) {
-    os << "{";
-    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
-    return os << "}";
-}
-template<typename T> ostream& operator<<(ostream& out, const vector<T>& vec) {
-    for (auto&& i : vec) out << i << ' ';
-    return out;
-}
-
-/* pops */
-#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
-#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
-#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
-
-/* math */
-constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); }
-
-void __exgcd(ll a, ll b, ll& x, ll& y) {
-  if (b == 0) {
-    x = 1, y = 0;
-    return;
-  }
-  __exgcd(b, a % b, y, x);
-  y -= a / b * x;
-}
-
-ll inverse(ll a, ll b) {
-    ll x, y;
-    __exgcd(a, b, x, y);
-    return mod(x, b);
-}
-
-vector<tuple<int, int, ll>> decompose(ll x) {
-    vector<tuple<int, int, ll>> res;
-    for (int i = 2; i * i <= x; i++) {
-        if (x % i == 0) {
-            int cnt = 0;
-            ll pw = 1;
-            while (x % i == 0) ++cnt, x /= i, pw *= i;
-            res.emplace_back(i, cnt, pw);
-        }
-    }
-    if (x != 1) {
-        res.emplace_back(x, 1, x);
-    }
-    return res;
-}
-
-/* string algorithms */
-vector<int> calc_next(string t) {  // pi function of t
-  int n = (int)t.length();
-  vector<int> pi(n);
-  for (int i = 1; i < n; i++) {
-    int j = pi[i - 1];
-    while (j > 0 && t[i] != t[j]) j = pi[j - 1];
-    if (t[i] == t[j]) j++;
-    pi[i] = j;
-  }
-  return pi;
-}
-vector<int> calc_z(string t) {  // z function of t
-    int m = t.length();
-    vector<int> z;
-    z.push_back(m);
-    pair<int, int> prev = {1, -1};
-    for (int i = 1; i < m; ++i) {
-        if (z[i - prev.first] + i <= prev.second) {
-            z.push_back(z[i - prev.first]);
-        } else {
-            int j = max(i, prev.second + 1);
-            while (j < m && t[j] == t[j - i]) ++j;
-            z.push_back(j - i);
-            prev = {i, j - 1};
-        }
-    }
-    return z;
-}
-vector<int> kmp(string s, string t) {  // find all t in s
-  string cur = t + '#' + s;
-  int sz1 = s.size(), sz2 = t.size();
-  vector<int> v;
-  vector<int> lps = calc_next(cur);
-  for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
-    if (lps[i] == sz2) v.push_back(i - 2 * sz2);
-  }
-  return v;
-}
-int period(string s) {  // find the length of shortest recurring period
-    int n = s.length();
-    auto z = calc_z(s);
-    for (int i = 1; i <= n / 2; ++i) {
-        if (n % i == 0 && z[i] == n - i) {
-            return i;
-        }
-    }
-    return n;
-}
-/////////////////////////////////////////////////////////
-
-#define SINGLE_TEST_CASE
-// #define DUMP_TEST_CASE 512
-
-void dump() {}
-
-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);
-        d[p] = d[p * 2] + d[p * 2 + 1];
-    }
-    
-    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 Set_Tag {
-    ll val = -1;
-    void apply(const Set_Tag& rhs) {
-        if (rhs.val != -1)
-        val = rhs.val;
-    }
-};
-
-struct Set_Info {
-    ll val = 0;
-    void apply(const Set_Tag& rhs, size_t len) {
-        if (rhs.val != -1)
-        val = rhs.val * len;
-    }
-};
-
-Set_Info operator+(const Set_Info &a, const Set_Info &b) {
-    return {a.val + b.val};
-}
-
-void solve() {
-    segtree<Set_Info, Set_Tag> tr(5);
-    tr.range_apply(0, 3, {1});
-    for (auto&& x : tr.serialize()) {
-        cerr << x.val << ' ';
-    }
-    cerr << endl;
-    assert(tr.range_query(0, 4).val == 4);
-    tr.set(3, {2});
-    for (auto&& x : tr.serialize()) {
-        cerr << x.val << ' ';
-    }
-    cerr << endl;
-}
-
 int main() {
-#if __cplusplus < 201703L || defined(_MSC_VER) && !defined(__clang__)
-    assert(false && "incompatible compiler variant detected.");
-#endif
-    untie, cout.tie(NULL);
-    prep();
-#ifdef SINGLE_TEST_CASE
-    solve();
-#else
-    read(int, t);
-    for (int i = 0; i < t; ++i) {
-#ifdef DUMP_TEST_CASE
-        if (i + 1 == (DUMP_TEST_CASE)) {
-            dump();
-        } else {
-            solve();
-        }
-#else
-        solve();
-#endif
-    }
-#endif
+    cerr << gcd(0, 1) << '\n';;
+    assert(gcd(0, 1) == 0);
+    assert(gcd(0, 2) == 0);
+    assert(gcd(0, 10) == 0);
+    assert(gcd(1, 0) == 0);
+    assert(gcd(2, 0) == 0);
+    assert(gcd(10, 0) == 0);
 }