more code

codeforces/923/.clang-format

@@ -0,0 +1,2 @@
+BasedOnStyle: Google
+AllowShortFunctionsOnASingleLine: Empty

codeforces/923/a.cc

@@ -0,0 +1,120 @@
+#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 print(std::string const &str, Args &&...args) {
+  std::cout << std::vformat(str,
+                            // make_format_args binds arguments to const
+                            std::make_format_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_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())
+#define FOR(a, b, c) for (int a = b; a < c; ++a)
+
+mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
+#define randint(a, b) uniform_int_distribution(a, b)(rng)
+
+void YES() {
+  cout << "YES\n";
+}
+void NO() {
+  cout << "NO\n";
+}
+
+#ifdef LOCAL
+#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n";
+#else
+#define dbg(x)
+#endif
+
+static constexpr int MOD = 1e9 + 7;
+
+void solve() {
+  int n;
+  cin >> n;
+  int l = -1, r = -1;
+
+  FOR(i, 0, n) {
+    char c;
+    cin >> c;
+    if (l == -1 && c == 'B') l = i;
+    if (c == 'B') r = i;
+  }
+
+  println(r - l + 1);
+}
+
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}

codeforces/923/a.in

@@ -0,0 +1,17 @@
+8
+6
+WBBWBW
+1
+B
+2
+WB
+3
+BBW
+4
+BWWB
+6
+BWBWWB
+6
+WWBBWB
+9
+WBWBWWWBW

codeforces/923/a.out

@@ -0,0 +1,24 @@
+hi
+
+4
+hi
+
+1
+hi
+
+1
+hi
+
+2
+hi
+
+4
+hi
+
+6
+hi
+
+4
+hi
+
+7

codeforces/923/b.cc

@@ -0,0 +1,231 @@
+#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 print(std::string const &str, Args &&...args) {
+  std::cout << std::vformat(str,
+                            // make_format_args binds arguments to const
+                            std::make_format_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_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())
+#define FOR(a, b, c) for (int a = b; a < c; ++a)
+
+mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
+#define randint(a, b) uniform_int_distribution(a, b)(rng)
+
+void YES() {
+  cout << "YES\n";
+}
+void NO() {
+  cout << "NO\n";
+}
+
+#ifdef LOCAL
+#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n";
+#else
+#define dbg(x)
+#endif
+
+static constexpr int MOD = 1e9 + 7;
+
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+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
+
+void solve() {
+  int n;
+  cin >> n;
+
+  string ans;
+  vec<deque<char>> rev(n + 1);
+  int last_used = -1;
+
+  FOR(i, 0, n) {
+    int a;
+    cin >> a;
+    if (a == 0) {
+      ++last_used;
+      cout << (char(last_used + 'a'));
+      rev[1].push_back(last_used);
+    } else {
+      cout << char(rev[a].front() + 'a');
+      rev[a + 1].push_back(rev[a].front());
+      rev[a].pop_front();
+    }
+  }
+
+  println();
+}
+
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}

codeforces/923/b.in

@@ -0,0 +1,11 @@
+5
+11
+0 0 0 1 0 2 0 3 1 1 4
+10
+0 0 0 0 0 1 0 1 1 0
+1
+0
+8
+0 1 2 3 4 5 6 7
+8
+0 0 0 0 0 0 0 0

codeforces/923/b.out

@@ -0,0 +1,5 @@
+abcadaeabca
+abcdeafbcg
+a
+aaaaaaaa
+abcdefgh

codeforces/923/c.cc

@@ -0,0 +1,150 @@
+#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 print(std::string const &str, Args &&...args) {
+  std::cout << std::vformat(str,
+                            // make_format_args binds arguments to const
+                            std::make_format_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_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())
+#define FOR(a, b, c) for (int a = b; a < c; ++a)
+
+mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
+#define randint(a, b) uniform_int_distribution(a, b)(rng)
+
+void YES() {
+  cout << "YES\n";
+}
+void NO() {
+  cout << "NO\n";
+}
+
+#ifdef LOCAL
+#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n";
+#else
+#define dbg(x)
+#endif
+
+static constexpr int MOD = 1e9 + 7;
+
+bitset<2 * 2 * 100000 + 1> a, b;
+
+void solve() {
+  int n, m, k;
+  cin >> n >> m >> k;
+
+  // ensure:
+  // a) all found
+  // b) <= k / 2 elements in [1,k] from just one arry
+
+  int x;
+
+  while (n--) {
+    cin >> x;
+    if (x > k) continue;
+    a.set(x);
+  }
+
+  while (m--) {
+    cin >> x;
+    if (x > k) continue;
+    b.set(x);
+  }
+
+  bool all_found = true;
+
+  int unique_to_a = 0, unique_to_b = 0;
+  for (int i = 1; i <= k; ++i) {
+    if (!a[i] && !b[i]) {
+      all_found = false;
+      break;
+    }
+    if (a[i] && !b[i]) ++unique_to_a;
+    if (!a[i] && b[i]) ++unique_to_b;
+  }
+
+  if (all_found && unique_to_a <= k / 2 && unique_to_b <= k / 2)
+    YES();
+  else
+    NO();
+
+  a.reset();
+  b.reset();
+}
+
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}

codeforces/923/c.in

@@ -0,0 +1,19 @@
+6
+6 5 6
+2 3 8 5 6 5
+1 3 4 10 5
+6 5 6
+2 3 4 5 6 5
+1 3 8 10 3
+3 3 4
+1 3 5
+2 4 6
+2 5 4
+1 4
+7 3 4 4 2
+1 4 2
+2
+6 4 4 2
+1 5 2
+3
+2 2 1 4 3

codeforces/923/c.out

@@ -0,0 +1,6 @@
+YES
+NO
+YES
+YES
+NO
+NO

codeforces/923/compile_flags.txt

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

codeforces/923/d.cc

@@ -0,0 +1,136 @@
+#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 print(std::string const &str, Args &&...args) {
+  std::cout << std::vformat(str,
+                            // make_format_args binds arguments to const
+                            std::make_format_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_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())
+#define FOR(a, b, c) for (int a = b; a < c; ++a)
+
+mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
+#define randint(a, b) uniform_int_distribution(a, b)(rng)
+
+void YES() {
+  cout << "YES\n";
+}
+void NO() {
+  cout << "NO\n";
+}
+
+#ifdef LOCAL
+#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n";
+#else
+#define dbg(x)
+#endif
+
+static constexpr int MOD = 1e9 + 7;
+
+void solve() {
+  int n;
+  cin >> n;
+  vec<int> a(n);
+  vec<int> p(n, -1);
+  cin >> a[0];
+
+  FOR(i, 1, n) {
+    cin >> a[i];
+    p[i] = p[i - 1];
+    if (a[i] != a[i - 1]) p[i] = i - 1;
+  }
+
+  int q;
+  cin >> q;
+  while (q--) {
+    int l, r;
+    cin >> l >> r;
+
+    --l;
+    --r;
+
+    int i = r;
+    int j = p[r];
+
+    if (j < l) i = -2, j = -2;
+
+    println("{} {}", i + 1, j + 1);
+  }
+}
+
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}

codeforces/923/d.in

@@ -0,0 +1,40 @@
+5
+5
+1 1 2 1 1
+3
+1 5
+1 2
+1 3
+6
+30 20 20 10 10 20
+5
+1 2
+2 3
+2 4
+2 6
+3 5
+4
+5 2 3 4
+4
+1 2
+1 4
+2 3
+2 4
+5
+1 4 3 2 4
+5
+1 5
+2 4
+3 4
+3 5
+4 5
+5
+2 3 1 4 2
+7
+1 2
+1 4
+1 5
+2 4
+2 5
+3 5
+4 5

codeforces/923/d.out

@@ -0,0 +1,24 @@
+5 3
+-1 -1
+3 2
+2 1
+-1 -1
+4 3
+6 5
+5 3
+2 1
+4 3
+3 2
+4 3
+5 4
+4 3
+4 3
+5 4
+5 4
+2 1
+4 3
+5 4
+4 3
+5 4
+5 4
+5 4

codeforces/923/j.cc

@@ -0,0 +1,110 @@
+#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 print(std::string const &str, Args &&...args) {
+  std::cout << std::vformat(str,
+                            // make_format_args binds arguments to const
+                            std::make_format_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_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())
+#define FOR(a, b, c) for (int a = b; a < c; ++a)
+
+mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
+#define randint(a, b) uniform_int_distribution(a, b)(rng)
+
+void YES() {
+  cout << "YES\n";
+}
+void NO() {
+  cout << "NO\n";
+}
+
+#ifdef LOCAL
+#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n";
+#else
+#define dbg(x)
+#endif
+
+static constexpr int MOD = 1e9 + 7;
+
+void solve() {
+  aknf;
+  kdsafkjadsfjadsfj
+}
+
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}

codeforces/923/j.out

@@ -0,0 +1,8 @@
+j.cc: In function ‘void solve()’:
+j.cc:72:3: error: ‘aknf’ was not declared in this scope
+   72 |   aknf;kdsafkjadsfjadsfj
+      |   ^~~~
+j.cc:72:8: error: ‘kdsafkjadsfjadsfj’ was not declared in this scope
+   72 |   aknf;kdsafkjadsfjadsfj
+      |        ^~~~~~~~~~~~~~~~~
+zsh:1: permission denied: /tmp/tmp.yMxI36SPlf

codeforces/923/k.cc

@@ -0,0 +1,86 @@
+#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 print(std::string const &str, Args &&...args) {
+  std::cout << std::vformat(str,
+                            // make_format_args binds arguments to const
+                            std::make_format_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_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())
+#define FOR(a, b, c) for (int a = b; a < c; ++a)
+
+mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
+#define randint(a, b) uniform_int_distribution(a, b)(rng)
+
+void YES() { cout << "YES\n"; }
+void NO() { cout << "NO\n"; }
+
+#ifdef LOCAL
+#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n";
+#else
+#define dbg(x)
+#endif
+
+static constexpr int MOD = 1e9 + 7;
+
+void solve() {
+  
+}
+
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+      solve();
+  }
+
+  return 0;
+}