CP template file

cptemplate.cpp

#include <bits/stdc++.h>
using namespace std;
typedef long long let;
typedef vector<let> vec;
typedef map<let, let> omap;
typedef set<let> oset;
typedef set<let, greater<let>> revset;
typedef pair<let, let> couple;
typedef vector<couple> couples;
typedef vector<vector<let>> graph;
typedef vector<vector<let>> matrix;
typedef vector<vector<array<let, 2>>> wgraph;
typedef queue<let> que;
typedef priority_queue<let> pque;
typedef priority_queue<let, vector<let>, greater<let>> rpque;
#define all(v) v.begin(), v.end()
#define rall(v) v.begin(), v.end(), greater<let>
#define endl '\n'
const let INF = LONG_LONG_MAX;

let power_modulo(let a, let b, let m);
let modulo_inverse(let n, let prime);
void input_graph(graph &g, let edges, bool directed = false);
void input_graph(wgraph &g, let edges, bool directed = false);
let lg(let num);

/*
// RMQ sparse table implementation
void rmq_populate_table(vector<let> &record);
let rmq_query(let L, let R);
let rmq_lookup[300001][24]; // rmq lookup table
*/

void solve() {
  // iko
}

int main() {
  ios_base::sync_with_stdio(0);
  std::cin.tie(nullptr);
  std::cout.tie(nullptr);

#ifndef ONLINE_JUDGE
  freopen("../input.txt", "r", stdin);
  freopen("../output.txt", "w", stdout);
#endif

  /*
  // Prime sieve
  vec prime;
  vector<bool> sieve(6e6, 1);

  for (let i = 2; i < 6e6; ++i) {
    if (!sieve[i]) continue;
    prime.push_back(i);
    for (int j = i*i; j < 6e6; j += i) {
      sieve[j] = 0;
    }
  }
  */

  let t;
  cin >> t;
  while (t--) {
    solve();
  }

  return 0;
}

// Who uses pow even
let power_modulo(let a, let b, let m) {
  if (b == 0) return 1;
  let tmp = power_modulo(a, b / 2, m) % m;
  if (b % 2 == 0)
    return (tmp * tmp) % m;
  else
    return (((tmp * tmp) % m) * a) % m;
}

// Fermat didnt die so we can fw his little theorem like this :(
let modulo_inverse(let n, let prime) {
  // a ^ (prime-1) = 1 (mod prime)
  // a ^ (prime-2) = a^(-1) (mod prime)

  return power_modulo(n, prime - 2, prime);
}

// Populate an unweighted graph
void input_graph(graph &g, let edges, bool directed) {
  let u, v;
  for (let i = 0; i < edges; i += 1) {
    cin >> u >> v;
    u -= 1;
    v -= 1;
    g[u].push_back(v);
    if (!directed) g[v].push_back(u);
  }
}

// Populate a weighted graph
void input_graph(wgraph &g, let edges, bool directed) {
  let u, v, w;
  for (let i = 0; i < edges; i += 1) {
    cin >> u >> v >> w;
    u -= 1;
    v -= 1;
    g[u].push_back({v, w});
    if (!directed) g[v].push_back({u, w});
  }
}

// Safe log (floor) for integers
let lg(let num) { return bit_width((unsigned long long)num) - 1; }

/* RMQ sparse table implementation

void rmq_populate_table(vector<let> &record) {
  let m = record.size();
  for (let i = 0; i < m; i++) rmq_lookup[i][0] = record[i];
  for (let j = 1; (1 << j) <= m; j++) {
    for (let i = 0; (i + (1 << j) - 1) < m; i++) {
      rmq_lookup[i][j] = min(rmq_lookup[i][j - 1], rmq_lookup[i + (1 << (j -
1))][j - 1]);
    }
  }
}

let rmq_query(let L, let R) {
  let j = lg(R - L + 1);
  return min(rmq_lookup[L][j], rmq_lookup[R - (1 << j) + 1][j]);
}

*/