feat(cf): update ignore

.gitignore

@@ -0,0 +1,3 @@
+.null-ls.*
+*.debug
+*.run

codeforces/971/.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

codeforces/971/a.cc

@@ -0,0 +1,95 @@
+#include <bits/stdc++.h>
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename... Args>
+void dbg(std::string const &str, Args &&...args) {
+  std::cout << std::vformat(str, std::make_format_args(args...));
+}
+
+template <typename T>
+void dbg(T const &t) {
+  std::cout << t;
+}
+
+template <std::ranges::range T>
+void dbgln(T const &t) {
+  if constexpr (std::is_convertible_v<T, char const *>) {
+    std::cout << t << '\n';
+  } else {
+    for (auto const &e : t) {
+      std::cout << e << ' ';
+    }
+    std::cout << '\n';
+  }
+}
+
+template <typename... Args>
+void dbgln(std::string const &str, Args &&...args) {
+  dbg(str, std::forward<Args>(args)...);
+  cout << '\n';
+}
+
+template <typename T>
+void dbgln(T const &t) {
+  dbg("{}\n", t);
+}
+
+void println() {
+  std::cout << '\n';
+}
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::min();
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define ll long long
+#define ld long double
+#define vec vector
+#define endl '\n'
+
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (r).rbegin(), (x).rend()
+#define sz(x) static_cast<int>((x).size())
+#define FOR(a, b, c) for (int(a) = (b); (a) < (c); ++(a))
+#define ROF(a, b, c) for (int(a) = (b); (a) > (c); --(a))
+
+std::random_device rd;
+std::mt19937 gen(rd());
+
+void YES() {
+  cout << "YES\n";
+}
+
+void NO() {
+  cout << "NO\n";
+}
+
+void solve() {
+  int a, b;
+  cin >> a >> b;
+  dbgln(b - a);
+}
+
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}

codeforces/971/a.in

@@ -0,0 +1,4 @@
+3
+1 2
+3 10
+5 5

codeforces/971/b.cc

@@ -0,0 +1,108 @@
+#include <bits/stdc++.h>
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename... Args>
+void dbg(std::string const &str, Args &&...args) {
+  std::cout << std::vformat(str, std::make_format_args(args...));
+}
+
+template <typename T>
+void dbg(T const &t) {
+  std::cout << t;
+}
+
+template <std::ranges::range T>
+void dbgln(T const &t) {
+  if constexpr (std::is_convertible_v<T, char const *>) {
+    std::cout << t << '\n';
+  } else {
+    for (auto const &e : t) {
+      std::cout << e << ' ';
+    }
+    std::cout << '\n';
+  }
+}
+
+template <typename... Args>
+void dbgln(std::string const &str, Args &&...args) {
+  dbg(str, std::forward<Args>(args)...);
+  cout << '\n';
+}
+
+template <typename T>
+void dbgln(T const &t) {
+  dbg("{}\n", t);
+}
+
+void dbgln() {
+  std::cout << '\n';
+}
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::min();
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define ll long long
+#define ld long double
+#define vec vector
+#define endl '\n'
+
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (r).rbegin(), (x).rend()
+#define sz(x) static_cast<int>((x).size())
+#define FOR(a, b, c) for (int(a) = (b); (a) < (c); ++(a))
+#define ROF(a, b, c) for (int(a) = (b); (a) > (c); --(a))
+
+std::random_device rd;
+std::mt19937 gen(rd());
+
+void YES() {
+  cout << "YES\n";
+}
+
+void NO() {
+  cout << "NO\n";
+}
+
+void solve() {
+  int n;
+  cin >> n;
+  vec<int> ans;
+  while (n--) {
+    string s;
+    cin >> s;
+    for (int i = 0; i < s.size(); ++i) {
+      if (s[i] == '#')
+        ans.push_back(i + 1);
+    }
+  }
+  while (!ans.empty()) {
+    dbg("{} ", ans.back());
+    ans.pop_back();
+  }
+  dbgln();
+}
+
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}

codeforces/971/b.in

@@ -0,0 +1,11 @@
+3
+4
+#...
+.#..
+..#.
+...#
+2
+.#..
+.#..
+1
+...#

codeforces/971/b.out

@@ -0,0 +1,3 @@
+4 3 2 1 
+2 2 
+4 

codeforces/971/c.cc

@@ -0,0 +1,99 @@
+#include <bits/stdc++.h>
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename... Args>
+void dbg(std::string const &str, Args &&...args) {
+  std::cout << std::vformat(str, std::make_format_args(args...));
+}
+
+template <typename T>
+void dbg(T const &t) {
+  std::cout << t;
+}
+
+template <std::ranges::range T>
+void dbgln(T const &t) {
+  if constexpr (std::is_convertible_v<T, char const *>) {
+    std::cout << t << '\n';
+  } else {
+    for (auto const &e : t) {
+      std::cout << e << ' ';
+    }
+    std::cout << '\n';
+  }
+}
+
+template <typename... Args>
+void dbgln(std::string const &str, Args &&...args) {
+  dbg(str, std::forward<Args>(args)...);
+  cout << '\n';
+}
+
+template <typename T>
+void dbgln(T const &t) {
+  dbg("{}\n", t);
+}
+
+void println() {
+  std::cout << '\n';
+}
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::min();
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define ll long long
+#define ld long double
+#define vec vector
+#define endl '\n'
+
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (r).rbegin(), (x).rend()
+#define sz(x) static_cast<int>((x).size())
+#define FOR(a, b, c) for (int(a) = (b); (a) < (c); ++(a))
+#define ROF(a, b, c) for (int(a) = (b); (a) > (c); --(a))
+
+std::random_device rd;
+std::mt19937 gen(rd());
+
+void YES() {
+  cout << "YES\n";
+}
+
+void NO() {
+  cout << "NO\n";
+}
+
+void solve() {
+  int x, y, k;
+  cin >> x >> y >> k;
+
+  int xleft = 2 * ((x + k - 1) / k) - 1;
+  int yleft = 2 * ((y + k - 1) / k);
+
+  dbgln(max(xleft, yleft));
+}
+
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}

codeforces/971/c.in

@@ -0,0 +1,4 @@
+3
+9 11 3
+0 10 8
+1000000 100000 10

codeforces/971/c.out

@@ -0,0 +1,3 @@
+8
+4
+199999

codeforces/971/compile_flags.txt

@@ -0,0 +1,5 @@
+-std=c++20
+-Wall
+-Wextra
+-Wpedantic
+-Wshadow

codeforces/971/d.cc

@@ -0,0 +1,117 @@
+#include <bits/stdc++.h>
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename... Args>
+void dbg(std::string const &str, Args &&...args) {
+  std::cout << std::vformat(str, std::make_format_args(args...));
+}
+
+template <typename T>
+void dbg(T const &t) {
+  std::cout << t;
+}
+
+template <std::ranges::range T>
+void dbgln(T const &t) {
+  if constexpr (std::is_convertible_v<T, char const *>) {
+    std::cout << t << '\n';
+  } else {
+    for (auto const &e : t) {
+      std::cout << e << ' ';
+    }
+    std::cout << '\n';
+  }
+}
+
+template <typename... Args>
+void dbgln(std::string const &str, Args &&...args) {
+  dbg(str, std::forward<Args>(args)...);
+  cout << '\n';
+}
+
+template <typename T>
+void dbgln(T const &t) {
+  dbg("{}\n", t);
+}
+
+void prllln() {
+  std::cout << '\n';
+}
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::min();
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define ll long long
+#define ld long double
+#define vec vector
+#define endl '\n'
+
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (r).rbegin(), (x).rend()
+#define sz(x) static_cast<ll>((x).size())
+#define FOR(a, b, c) for (ll(a) = (b); (a) < (c); ++(a))
+#define ROF(a, b, c) for (ll(a) = (b); (a) > (c); --(a))
+
+std::random_device rd;
+std::mt19937 gen(rd());
+
+void YES() {
+  cout << "YES\n";
+}
+
+void NO() {
+  cout << "NO\n";
+}
+
+constexpr auto N_MAX = (2 * 100000) + 1;
+bitset<N_MAX> y_one, y_zero;
+
+void solve() {
+  ll n;
+  cin >> n;
+  y_one.reset();
+  y_zero.reset();
+  FOR(i, 0, n) {
+    ll x, y;
+    cin >> x >> y;
+    y_one[x] = y_one[x] | (y == 1);
+    y_zero[x] = y_zero[x] | (y == 0);
+  }
+
+  ll ans = 0;
+  FOR(x, 0, n + 1) {
+    if (y_one[x] && y_zero[x])
+      ans += n - 2;
+    if (x >= 1 && x < n && y_one[x] && y_zero[x - 1] && y_zero[x + 1])
+      ++ans;
+    if (x >= 1 && x < n && y_zero[x] && y_one[x - 1] && y_one[x + 1])
+      ++ans;
+  }
+
+  dbgln(ans);
+}
+
+signed main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  ll t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}

codeforces/971/d.in

@@ -0,0 +1,21 @@
+3
+5
+1 0
+1 1
+3 0
+5 0
+2 1
+3
+0 0
+1 0
+3 0
+9
+1 0
+2 0
+3 0
+4 0
+5 0
+2 1
+7 1
+8 1
+9 1

codeforces/971/d.out

@@ -0,0 +1,3 @@
+4
+0
+8

codeforces/971/e.cc

@@ -0,0 +1,53 @@
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+
+using namespace std;
+#define ll long long
+
+using ld = long double;
+
+auto inclusive_sum = [](unsigned ll l, unsigned ll r) {
+  unsigned ll sum_r = r / 2 * (r + 1);
+  if (r % 2)
+    sum_r += (r + 1) / 2;
+  l--;
+  unsigned ll sum_l = l / 2 * (l + 1);
+  if (l % 2)
+    sum_l += (l + 1) / 2;
+  return sum_r - sum_l;
+};
+
+auto quad = [](ld a, ld b, ld c) {
+  return (-b + sqrt(b * b - 4 * a * c)) / (2 * a);
+};
+
+void solve() {
+  unsigned ll n, k;
+  cin >> n >> k;
+
+  ll half = inclusive_sum(k, k + n - 1) / 2;
+
+  ld i = quad(0.5, k + 0.5, -half);
+
+  unsigned ll a = max(1LL, static_cast<ll>(ceil(i)));
+  unsigned ll b = min(n, a + 1);
+
+  unsigned ll x = inclusive_sum(k, k + a - 1);
+  unsigned ll y = inclusive_sum(k + a, k + n - 1);
+  unsigned ll diff1 = x < y ? y - x : x - y;
+
+  x = inclusive_sum(k, k + b - 1);
+  y = inclusive_sum(k + b, k + n - 1);
+  unsigned ll diff2 = x < y ? y - x : x - y;
+
+  cout << min(diff1, diff2) << endl;
+}
+
+int main() {
+  int t;
+  cin >> t;
+  while (t--)
+    solve();
+  return 0;
+}

codeforces/971/e.in

@@ -0,0 +1,5 @@
+4
+2 2
+7 2
+5 3
+999999999 999999999

codeforces/971/e.out

@@ -0,0 +1,4 @@
+1
+5
+1
+1490352408

codeforces/971/f.cc

@@ -0,0 +1,143 @@
+#include <bits/stdc++.h>
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename... Args>
+void dbg(std::string const &str, Args &&...args) {
+  std::cout << std::vformat(str, std::make_format_args(args...));
+}
+
+template <typename T>
+void dbg(T const &t) {
+  std::cout << t;
+}
+
+template <std::ranges::range T>
+void dbgln(T const &t) {
+  if constexpr (std::is_convertible_v<T, char const *>) {
+    std::cout << t << '\n';
+  } else {
+    for (auto const &e : t) {
+      std::cout << e << ' ';
+    }
+    std::cout << '\n';
+  }
+}
+
+void dbgln() {
+  std::cout << '\n';
+}
+
+template <typename... Args>
+void dbgln(std::string const &str, Args &&...args) {
+  dbg(str, std::forward<Args>(args)...);
+  cout << '\n';
+}
+
+template <typename T>
+void dbgln(T const &t) {
+  dbg(t);
+  cout << '\n';
+}
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::min();
+
+template <typename T>
+static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define ll long long
+#define ld long double
+#define vec vector
+#define endl '\n'
+
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (r).rbegin(), (x).rend()
+#define sz(x) static_cast<int>((x).size())
+#define FOR(a, b, c) for (int(a) = (b); (a) < (c); ++(a))
+#define ROF(a, b, c) for (int(a) = (b); (a) > (c); --(a))
+
+std::random_device rd;
+std::mt19937 gen(rd());
+
+void solve() {
+  int n, q;
+  cin >> n >> q;
+  ll A = 0;
+  vec<ll> prefix;
+  prefix.push_back(0);
+  FOR(i, 0, n) {
+    ll x;
+    cin >> x;
+    A += x;
+    prefix.push_back(A);
+  }
+
+  // TODO: WRITE A BETTER MIN
+  // c_k = [a_k, a_k+1, ..., a_n ,a_1, ..., ak-1]
+  // [a_2, a_0, a_1]
+  // i = 2
+  auto shift_sum = [&](int k, int i) -> ll {
+    if (i == -1)
+      return 0;
+
+    int shifted_i = (i + k) % n;
+    if (shifted_i < k) {
+      return prefix[n] - prefix[k] + prefix[shifted_i + 1];
+    }
+    return prefix[shifted_i + 1] - prefix[k];
+  };
+
+  FOR(i, 0, q) {
+    ll l, r;
+    cin >> l >> r;
+    --l;
+    --r;
+
+    int I = l / n, J = r / n;
+
+    l = l % n, r = r % n;
+
+    ll ans;
+    if (I != J)
+      ans =
+          max(0LL, (J - I - 1) * A) + A - shift_sum(I, l - 1) + shift_sum(J, r);
+    else {
+      int shifted_l = (l + I) % n;
+      int shifted_r = (r + I) % n;
+
+      if (shifted_l <= shifted_r)
+        ans = prefix[shifted_r + 1] - prefix[shifted_l];
+      else
+        ans = prefix[n] - prefix[shifted_l] + prefix[shifted_r + 1];
+    }
+
+    dbgln(ans);
+  }
+}
+
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}

codeforces/971/f.in

@@ -0,0 +1,30 @@
+5
+3 3
+1 2 3
+1 9
+3 5
+8 8
+5 5
+4 8 3 2 4
+1 14
+3 7
+7 10
+2 11
+1 25
+1 1
+6
+1 1
+5 7
+3 1 6 10 4
+3 21
+6 17
+2 2
+1 5
+1 14
+9 15
+12 13
+5 3
+4 9 10 10 1
+20 25
+3 11
+20 22

codeforces/971/f.out

@@ -0,0 +1,19 @@
+18
+8
+1
+55
+20
+13
+41
+105
+6
+96
+62
+1
+24
+71
+31
+14
+44
+65
+15

codeforces/991/.null-ls_940867_d.cc

@@ -1,188 +0,0 @@
-#include <bits/stdc++.h>
-#include <ext/pb_ds/assoc_container.hpp>
-#include <ext/pb_ds/tree_policy.hpp>
-
-#pragma GCC optimize("O2,unroll-loops")
-#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
-
-using namespace std;
-using namespace __gnu_pbds;
-
-// https://mirror.codeforces.com/blog/entry/124683
-
-namespace hashing {
-using i64 = std::int64_t;
-using u64 = std::uint64_t;
-static const u64 FIXED_RANDOM =
-    std::chrono::steady_clock::now().time_since_epoch().count();
-
-#if USE_AES
-std::mt19937 rd(FIXED_RANDOM);
-const __m128i KEY1{(i64)rd(), (i64)rd()};
-const __m128i KEY2{(i64)rd(), (i64)rd()};
-#endif
-
-template <class T, class D = void> struct custom_hash {};
-
-template <class T> inline void hash_combine(u64 &seed, T const &v) {
-  custom_hash<T> hasher;
-  seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4);
-};
-
-template <class T>
-struct custom_hash<T,
-                   typename std::enable_if<std::is_integral<T>::value>::type> {
-  u64 operator()(T _x) const {
-    u64 x = _x;
-#if USE_AES
-    __m128i m{i64(u64(x) * 0xbf58476d1ce4e5b9u64), (i64)FIXED_RANDOM};
-    __m128i y = _mm_aesenc_si128(m, KEY1);
-    __m128i z = _mm_aesenc_si128(y, KEY2);
-    return z[0];
-#else
-    x += 0x9e3779b97f4a7c15 + FIXED_RANDOM;
-    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
-    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
-    return x ^ (x >> 31);
-#endif
-  }
-};
-
-template <class T>
-struct custom_hash<T, std::void_t<decltype(std::begin(std::declval<T>()))>> {
-  u64 operator()(T const &a) const {
-    u64 value = FIXED_RANDOM;
-    for (auto &x : a)
-      hash_combine(value, x);
-    return value;
-  }
-};
-
-template <class... T> struct custom_hash<std::tuple<T...>> {
-  u64 operator()(const std::tuple<T...> &a) const {
-    u64 value = FIXED_RANDOM;
-    std::apply([&value](T const &...args) { (hash_combine(value, args), ...); },
-               a);
-    return value;
-  }
-};
-
-template <class T, class U> struct custom_hash<std::pair<T, U>> {
-  u64 operator()(std::pair<T, U> const &a) const {
-    u64 value = FIXED_RANDOM;
-    hash_combine(value, a.first);
-    hash_combine(value, a.second);
-    return value;
-  }
-};
-}; // namespace hashing
-
-#ifdef PB_DS_ASSOC_CNTNR_HPP
-template <class Key, class Value>
-using hashmap = gp_hash_table<
-    Key, Value, hashing::custom_hash<Key>, std::equal_to<Key>,
-    direct_mask_range_hashing<>, linear_probe_fn<>,
-    hash_standard_resize_policy<hash_exponential_size_policy<>,
-                                hash_load_check_resize_trigger<>, true>>;
-template <class Key>
-using hashset = gp_hash_table<
-    Key, null_type, hashing::custom_hash<Key>, std::equal_to<Key>,
-    direct_mask_range_hashing<>, linear_probe_fn<>,
-    hash_standard_resize_policy<hash_exponential_size_policy<>,
-                                hash_load_check_resize_trigger<>, true>>;
-
-#endif
-#ifdef PB_DS_TREE_POLICY_HPP
-template <typename T>
-using multiset = tree<T, null_type, std::less_equal<T>, rb_tree_tag,
-                      tree_order_statistics_node_update>;
-template <class Key, class Value = null_type>
-using rbtree = tree<Key, Value, std::less<Key>, rb_tree_tag,
-                    tree_order_statistics_node_update>;
-#endif
-
-template <typename... Args> void print(std::string const &str, Args &&...args) {
-  std::cout << std::vformat(str,
-                            std::make_format_args(std::forward<Args>(args)...));
-}
-
-template <typename T> void print(T const &t) { std::cout << t; }
-
-template <std::ranges::range T> void print(T const &t) {
-  if constexpr (std::is_same_v<T, string> ||
-                std::is_convertible_v<T, char const *>) {
-    std::cout << t << '\n';
-  } else {
-    for (auto const &e : t) {
-      std::cout << e << ' ';
-    }
-    std::cout << '\n';
-  }
-}
-
-template <typename... Args>
-void println(std::string const &str, Args &&...args) {
-  print(str, std::forward<Args>(args)...);
-  cout << '\n';
-}
-
-template <typename T> void println(T const &t) { print("{}\n", t); }
-
-template <std::ranges::range T> void println(T const &t) { cout << t << '\n'; }
-
-void println() { std::cout << '\n'; }
-
-template <typename T> T MAX() { return std::numeric_limits<T>::max(); }
-
-template <typename T> T MIN() { return std::numeric_limits<T>::min(); }
-
-#define ff first
-#define ss second
-#define eb emplace_back
-#define ll long long
-#define ld long double
-#define vec vector
-
-#define all(x) (x).begin(), (x).end()
-#define rall(x) (r).rbegin(), (x).rend()
-#define sz(x) static_cast<int>((x).size())
-
-#ifdef LOCAL
-#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n";
-#else
-#define dbg(x)
-#endif
-
-constexpr static int MOD = 1e9 + 7;
-
-void solve() {
-  string s;
-  cin >> s;
-
-  for (int i = 1; i < s.size(); ++i) {
-    if (s[i] == '0')
-      continue;
-
-    int j = i;
-    while (j >= 1 && s[j] - 1 > s[j - 1]) {
-      --s[j];
-      swap(s[j], s[-1]);
-      --j;
-    }
-  }
-
-  println(s);
-}
-
-int main() {
-  cin.tie(nullptr)->sync_with_stdio(false);
-
-  int t = 1;
-  cin >> t;
-
-  while (t--) {
-    solve();
-  }
-
-  return 0;
-}

codeforces/991/buf

@@ -1,29 +0,0 @@
-void solve() {
-    stGCD.clear();
-    int n, q; cin >> n >> q;
-    vector<int> a(n);
-    for (int &x : a) cin >> x;
-
-    vector<int> b;
-    for (int i = 1; i < n; i++)
-        b.push_back(abs(a[i - 1] - a[i]));
-
-    stGCD.resize(LOGN, vector<int>(b.size(), 1));
-    for (int i = 0; i < b.size(); i++)
-        stGCD[0][i] = b[i];
-    for (int i = 1; i < LOGN; i++)
-        for (int j = 0; j + (1 << (i - 1)) < b.size(); j++)
-            stGCD[i][j] = __gcd(stGCD[i - 1][j], stGCD[i - 1][j + (1 << (i - 1))]);
-
-    while (q--) {
-        int l, r; cin >> l >> r;
-        if (l == r) {
-            cout << 0 << " ";
-            continue;
-        }
-        l--; r -= 2;
-        int gcd = get_gcd(l, r);
-        cout << gcd << " ";
-    }
-}
-