C++競プロ用ライブラリ

string s;
getline(cin, s);

#include <iomanip>

double x = 3.141592653589793;

// 有効数字（全体桁数）
cout << setprecision(10) << x;

// 小数点以下固定
cout << fixed << setprecision(5) << x;

// 指数表記
cout << scientific << setprecision(3) << x;

// 元に戻す
cout << defaultfloat << x;

int a, b;
long long x;
string s;
char c;
double d;

cin >> a >> b;
cin >> x;
cin >> s;
cin >> c;
cin >> d;

int n = stoi("123");
long long m = stoll("999999999999");
double d = stod("3.14159");

string s1 = to_string(42);
string s2 = to_string(1000000000000LL);

string s = "competitive programming";
string t = s.substr(0, 10);        // "competitive"
size_t p = s.find("program");
if (p != string::npos) {
    s.replace(p, 8, "contest");
}

stringstream ss;
ss << "10 20 30";
int a, b, c;
ss >> a >> b >> c;

// 2 つの文字列または配列間のハミング距離を計算 (O(N))
template <typename T>
long long hamming_distance(const T& a, const T& b) {
    if (a.size() != b.size()) return -1; // 長さが異なる場合は定義不可
    long long dist = 0;
    for (size_t i = 0; i < a.size(); ++i) {
        if (a[i] != b[i]) dist++;
    }
    return dist;
}

// 2 つの整数 (ビット列) 間のハミング距離を計算 (O(1))
long long hamming_distance_bit(unsigned long long a, unsigned long long b) {
    return __builtin_popcountll(a ^ b);
}

// ローリングハッシュ構造体 (衝突対策として 2^61-1 のモジュロを使用)
struct RollingHash {
    using ull = unsigned long long;
    const ull mod = (1ULL << 61) - 1;
    const ull base = 2023; // 任意の基数
    vector hash, power;
    
    ull calc_mod(ull x) const {
        ull res = (x >> 61) + (x & mod);
        if (res >= mod) res -= mod;
        return res;
    }
    
    ull mul(ull a, ull b) const {
        ull au = a >> 31, ad = a & ((1ULL << 31) - 1);
        ull bu = b >> 31, bd = b & ((1ULL << 31) - 1);
        ull mid = ad * bu + au * bd;
        ull midu = mid >> 30, midd = mid & ((1ULL << 30) - 1);
        return calc_mod(au * bu * 2 + midu + (midd << 31) + ad * bd);
    }
    
    RollingHash(const string& s) {
        int n = s.size();
        hash.assign(n + 1, 0);
        power.assign(n + 1, 1);
        for (int i = 0; i < n; i++) {
            hash[i + 1] = calc_mod(mul(hash[i], base) + s[i]);
            power[i + 1] = mul(power[i], base);
        }
    }
    
    // [l, r) のハッシュ値を取得
    ull get(int l, int r) const {
        ull res = hash[r] + mod - mul(hash[l], power[r - l]);
        return calc_mod(res);
    }
    
    // 二分探索による LCP (Longest Common Prefix) の計算: O(log N)
    int get_lcp(const RollingHash& b, int l1, int r1, int l2, int r2) const {
        int len = min(r1 - l1, r2 - l2);
        int low = 0, high = len + 1;
        while (high - low > 1) {
            int mid = (low + high) / 2;
            if (get(l1, l1 + mid) == b.get(l2, l2 + mid)) low = mid;
            else high = mid;
        }
        return low;
    }
};

// 最大 K 回の不一致を許容して S から T を検索し、マッチする開始インデックスのリストを返す
vector search_with_k_mismatches(const string& S, const string& T, int K) {
    vector res;
    int n = S.size(), m = T.size();
    if (n < m) return res;
    
    RollingHash rhS(S), rhT(T);
    
    for (int i = 0; i <= n - m; i++) {
        int mismatches = 0;
        int s_pos = i, t_pos = 0;
        
        while (t_pos < m && mismatches <= K) {
            // 一致している区間を O(log N) で一気にスキップ
            int lcp = rhS.get_lcp(rhT, s_pos, n, t_pos, m);
            s_pos += lcp;
            t_pos += lcp;
            
            // 不一致箇所を見つけた場合
            if (t_pos < m) {
                mismatches++;
                s_pos++;
                t_pos++;
            }
        }
        
        // 不一致が K 回以内なら条件を満たす
        if (mismatches <= K) {
            res.push_back(i);
        }
    }
    return res;
}

// 2つの配列・文字列の編集距離を空間 O(|T|) で求める。
// K を指定した場合、距離が K を超えれば K + 1 を返し、時間 O(K min(|S|, |T|)) で動作する。
template <typename Seq>
long long levenshtein_distance(const Seq& S, const Seq& T, long long K = -1) {
    long long n = S.size();
    long long m = T.size();
    if (n == 0) return (K == -1 || m <= K) ? m : K + 1;
    if (m == 0) return (K == -1 || n <= K) ? n : K + 1;

    // 文字数差の時点で K を超えるなら早期リターン
    if (K != -1 && abs(n - m) > K) return K + 1;

    const long long INF = 1e16;
    vector<long long> dp(m + 1, INF);

    // 0行目の初期化
    long long j_limit = (K == -1) ? m : min(m, K);
    for (long long j = 0; j <= j_limit; ++j) {
        dp[j] = j;
    }

    for (long long i = 1; i <= n; ++i) {
        // バンドDPのための計算範囲（K=-1なら全範囲）
        long long j_min = (K == -1) ? 1 : max(1LL, i - K);
        long long j_max = (K == -1) ? m : min(m, i + K);

        long long prev = dp[j_min - 1]; // dp[i-1][j_min-1] に相当
        if (j_min > 1) {
            dp[j_min - 1] = INF; // バンド左外側からの遷移を無効化
        } else {
            dp[0] = (K == -1 || i <= K) ? i : INF;
        }

        for (long long j = j_min; j <= j_max; ++j) {
            long long temp = dp[j];
            long long cost = (S[i - 1] == T[j - 1]) ? 0 : 1;
            
            dp[j] = min({
                dp[j] + 1,      // Sの文字を削除 (上から)
                dp[j - 1] + 1,  // Tの文字を挿入 (左から)
                prev + cost     // 置換または一致 (左上から)
            });
            prev = temp;
        }
    }
    
    long long res = dp[m];
    return (K != -1 && res > K) ? K + 1 : res;
}

// 2つの文字列 S, T の LCS の長さを O(|S||T|) で求める
ll lcs_length(const string& S, const string& T) {
    ll n = S.size();
    ll m = T.size();
    
    // dp[i][j] := Sをi文字、Tをj文字目まで見たときのLCSの長さ
    vector<vector<ll>> dp(n + 1, vector<ll>(m + 1, 0));

    for (ll i = 0; i < n; i++) {
        for (ll j = 0; j < m; j++) {
            if (S[i] == T[j]) {
                // 文字が一致していれば、両方から1文字ずつ進める
                dp[i + 1][j + 1] = dp[i][j] + 1;
            } else {
                // 一致していなければ、どちらかを1文字進めた状態の最大値を取る
                dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j]);
            }
        }
    }
    
    return dp[n][m];
}

// S の各文字が互いに異なる場合の LCS を O(|S| + |T|log|T|) で求める
ll optimized_lcs(const string& S, const string& T) {
    // 1. S の各文字の出現位置を記録（S の文字は重複しない前提）
    // ※文字の種類が ASCII (256種類) に収まる場合の配列。
    // ※数値配列や種類が多い場合は map<ll, ll> などを利用してください。
    vector<ll> pos(256, -1); 
    for (ll i = 0; i < (ll)S.size(); i++) {
        pos[S[i]] = i;
    }

    // 2. T の各文字を S でのインデックスに変換し、配列 A を作成
    vector<ll> A;
    for (char c : T) {
        if (pos[c] != -1) {
            A.push_back(pos[c]);
        }
    }

    // 3. 配列 A の LIS (最長増加部分列) の長さを求める
    const ll INF = 1e18;
    vector<ll> dp(A.size() + 1, INF);
    
    for (ll x : A) {
        // x 以上の値が最初に現れる位置を二分探索で見つけて更新
        auto it = lower_bound(dp.begin(), dp.end(), x);
        *it = x;
    }
    
    // INF でない要素の数が LIS (＝LCS) の長さ
    ll lcs_len = lower_bound(dp.begin(), dp.end(), INF) - dp.begin();
    return lcs_len;
}

// S と S[i:|S|-1] の最長共通接頭辞(LCP)を O(N) で求める構造体
struct ZArray {
  ll n;
  vector<ll> z;

  // 通常の文字列用
  ZArray(const string& s) {
    build(s);
  }

  // 複数文字列を扱う場合や数列用（番兵を利用可能）
  template <typename T>
  ZArray(const vector<T>& v) {
    build(v);
  }

private:
  template <typename Container>
  void build(const Container& s) {
    n = s.size();
    z.assign(n, 0);
    if (n == 0) return;
    z[0] = n;
    ll i = 1, j = 0;
    while (i < n) {
      while (i + j < n && s[j] == s[i + j]) j++;
      z[i] = j;
      if (j == 0) {
        i++;
        continue;
      }
      ll k = 1;
      while (i + k < n && k + z[k] < j) {
        z[i + k] = z[k];
        k++;
      }
      i += k;
      j -= k;
    }
  }
};

// S の各文字を中心とする最長回文の半径を O(N) で求める構造体
struct Manacher {
  ll n;
  vector<ll> R;

  // 通常の文字列用
  Manacher(const string& s) {
    build(s);
  }

  // 複数文字列を扱う場合や数列用、ダミー文字挿入後の配列用
  template <typename T>
  Manacher(const vector<T>& v) {
    build(v);
  }

private:
  template <typename Container>
  void build(const Container& s) {
    n = s.size();
    R.assign(n, 0);
    ll i = 0, j = 0;
    while (i < n) {
      while (i - j >= 0 && i + j < n && s[i - j] == s[i + j]) ++j;
      R[i] = j;
      ll k = 1;
      while (i - k >= 0 && i + k < n && k + R[i - k] < j) {
        R[i + k] = R[i - k];
        ++k;
      }
      i += k;
      j -= k;
    }
  }
};

#include <atcoder/string>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

// ACLをラップし、任意2点間LCPクエリ（RMQ）をサポートした実戦用構造体
struct AclStringAutomaton {
  int n;
  vector<int> sa;
  vector<int> lcp;
  vector<int> rank;
  vector<vector<int>> st;
  vector<int> log_table;

  // 通常の文字列用
  AclStringAutomaton(const string& s) {
    n = s.size();
    sa = atcoder::suffix_array(s);
    lcp = atcoder::lcp_array(s, sa);
    build();
  }

  // 複数文字列を扱う場合用（int配列版番兵を利用可能）
  // 例: SとTを合わせる際、Sの各文字、200000(番兵1)、Tの各文字、200001(番兵2) のように格納
  AclStringAutomaton(const vector<int>& v) {
    n = v.size();
    sa = atcoder::suffix_array(v);
    lcp = atcoder::lcp_array(v, sa);
    build();
  }

  // 元の文字配列のインデックス i と j から始まる接尾辞の LCP を O(1) で取得
  int get_lcp(int i, int j) {
    if (i < 0 || i >= n || j < 0 || j >= n) return 0; // 範囲外アクセスを防止
    if (i == j) return n - i;
    int r_i = rank[i], r_j = rank[j];
    if (r_i > r_j) swap(r_i, r_j);
    int l = r_i, r = r_j - 1;
    int len = r - l + 1;
    int k = log_table[len];
    return min(st[k][l], st[k][r - (1 << k) + 1]);
  }

private:
  void build() {
    // rank のサイズは n ぴったりでOKです
    rank.resize(n);

    // i <= n ではなく、i < n に修正（範囲外アクセスを防止）
    for (int i = 0; i < n; i++)
      rank[sa[i]] = i;

    int m = lcp.size(); // m は確実に n-1 になります
    if (m == 0) return; // 要素が1つ以下の場合はSparse Tableの構築をスキップ

    log_table.assign(m + 1, 0);
    for (int i = 2; i <= m; i++)
      log_table[i] = log_table[i >> 1] + 1;

    int max_log = log_table[m] + 1;
    st.assign(max_log, vector<int>(m));
    for (int i = 0; i < m; i++)
      st[0][i] = lcp[i];

    for (int k = 1; k < max_log; k++) {
      for (int i = 0; i + (1 << k) <= m; i++) {
        st[k][i] = min(st[k - 1][i], st[k - 1][i + (1 << (k - 1))]);
      }
    }
  }
};

#include <atcoder/string>
#include <vector>
#include <string>

using namespace std;

// ACLのSAとLCPを利用してO(N)でSuffix Treeを構築する構造体
struct SuffixTree {
  struct Node {
    int l, r;             // 親からこのノードへ向かう辺の文字列区間 S[l, r)
    int depth;            // 根からこのノードまでの総文字列長
    int parent;           // 親ノードのインデックス
    vector<int> children; // 子ノード群のインデックス

    Node(int l, int r, int depth, int parent)
      : l(l), r(r), depth(depth), parent(parent) {}
  };

  string S;
  vector<Node> nodes;

  SuffixTree(const string& s) : S(s) {
    int n = s.size();
    auto sa = atcoder::suffix_array(s);
    auto lcp = atcoder::lcp_array(s, sa);

    // root (id = 0) を追加
    nodes.emplace_back(0, 0, 0, -1);
    int curr = 0;

    for (int i = 0; i < n; i++) {
      int suffix_idx = sa[i];
      int lcp_val = (i == 0 ? 0 : lcp[i - 1]);

      // 現在のノードから根へ遡り、LCPの深さ以下の分岐点を探す
      while (curr != 0 && nodes[curr].depth > lcp_val) {
        int p = nodes[curr].parent;
        if (nodes[p].depth <= lcp_val) {
          if (nodes[p].depth < lcp_val) {
            // 辺の途中で分岐する必要があるため、ノードを分割 (Edge Split)
            int split_id = nodes.size();
            int split_l = nodes[curr].l;
            int split_r = split_l + (lcp_val - nodes[p].depth);
            nodes.emplace_back(split_l, split_r, lcp_val, p);

            // 親の参照先を新しい分割ノードに更新
            for (int& child : nodes[p].children) {
              if (child == curr) {
                child = split_id;
                break;
              }
            }
            nodes[split_id].children.push_back(curr);
            nodes[curr].parent = split_id;
            nodes[curr].l += (lcp_val - nodes[p].depth);
            
            curr = split_id;
          } else {
            // ちょうど分岐点(親ノード)が LCP の深さと一致する場合
            curr = p;
          }
          break;
        }
        curr = p;
      }

      // 新しい葉ノードを追加
      int leaf_id = nodes.size();
      nodes.emplace_back(suffix_idx + lcp_val, n, n - suffix_idx, curr);
      nodes[curr].children.push_back(leaf_id);
      curr = leaf_id;
    }
  }
};

// char_size: 文字の種類数 (英小文字のみなら26)
// base: 基準となる文字 ('a', 'A', '0' など)
template <int char_size = 26, int base = 'a'>
struct Trie {
  struct Node {
    vector<int> next;       // 子ノードのインデックス (-1は子が存在しない)
    int accept_count;       // このノードを「終端」とする文字列の数
    int pass_count;         // このノードを「通過」した文字列の数 (部分木の要素数)
    
    // --- 汎用拡張データ ---
    vector<int> accept_ids; // このノードで終わる文字列のラベル(追加時のIDなど)
    long long val;          // 関数値、重み、DPの結果などを持たせる汎用変数

    Node() : next(char_size, -1), accept_count(0), pass_count(0), val(0) {}
  };

  vector<Node> nodes;

  Trie() {
    nodes.push_back(Node()); // root (id = 0) を追加
  }

  // 現在のTrie木に含まれる全文字列の数を取得 O(1)
  int size() const {
    return nodes[0].pass_count;
  }

  // 文字列の挿入
  void insert(const string &s, int id = -1, long long val = 0) {
    int curr = 0;
    nodes[curr].pass_count++;
    for (char c : s) {
      int to = c - base;
      if (nodes[curr].next[to] == -1) {
        nodes[curr].next[to] = nodes.size();
        nodes.push_back(Node());
      }
      curr = nodes[curr].next[to];
      nodes[curr].pass_count++;
    }
    nodes[curr].accept_count++;
    if (id != -1) nodes[curr].accept_ids.push_back(id);
    nodes[curr].val += val; 
  }

  // 単一文字列の正確な削除 (集合からsを1つだけ減らす)
  // 成功したらtrue, そもそも存在しなかったらfalseを返す
  bool erase(const string &s) {
    int curr = 0;
    vector<int> path;
    for (char c : s) {
      path.push_back(curr);
      int to = c - base;
      if (nodes[curr].next[to] == -1) return false; // 存在しない
      curr = nodes[curr].next[to];
    }
    if (nodes[curr].accept_count == 0) return false; // 終端として存在しない
    
    nodes[curr].accept_count--;
    nodes[curr].pass_count--;
    for (int p : path) nodes[p].pass_count--; // 祖先の通過数を減らす
    return true;
  }

  // 完全一致する文字列の個数を取得
  int count(const string &s) {
    int curr = 0;
    for (char c : s) {
      int to = c - base;
      if (nodes[curr].next[to] == -1) return 0;
      curr = nodes[curr].next[to];
    }
    return nodes[curr].accept_count;
  }

  // 終端ノードのID検索 (見つかれば終端ノードのIDを、なければ -1)
  int search(const string &s) {
    int curr = 0;
    for (char c : s) {
      int to = c - base;
      if (nodes[curr].next[to] == -1) return -1;
      curr = nodes[curr].next[to];
    }
    return nodes[curr].accept_count > 0 ? curr : -1;
  }

  // Prefix(接頭辞)検索 (S から始まる文字列の数を返す)
  int count_prefix(const string &s) {
    int curr = 0;
    for (char c : s) {
      int to = c - base;
      if (nodes[curr].next[to] == -1) return 0;
      curr = nodes[curr].next[to];
    }
    return nodes[curr].pass_count;
  }

  // 特定の文字列をprefixに持つ要素を全て削除する
  void erase_by_prefix(const string &s) {
    if (s.empty()) { 
      nodes[0] = Node(); // 空文字列指定は全クリアと同義
      return;
    }
    int curr = 0;
    vector<int> path;
    for (char c : s) {
      path.push_back(curr);
      int to = c - base;
      if (nodes[curr].next[to] == -1) return; // 存在しない
      curr = nodes[curr].next[to];
    }
    int removed = nodes[curr].pass_count;
    if (removed == 0) return;
    
    nodes[path.back()].next[s.back() - base] = -1; // 木から切断
    for (int p : path) nodes[p].pass_count -= removed;
  }

  // sがprefixとなるような、木内の文字列の「総数」ではなく
  // 「sのprefixとなるような木内の文字列」の個数 (s="catch"なら"cat", "catch"等)
  int count_prefixes_of(const string &s) {
    int curr = 0, res = 0;
    for (char c : s) {
      res += nodes[curr].accept_count;
      int to = c - base;
      if (nodes[curr].next[to] == -1) return res;
      curr = nodes[curr].next[to];
    }
    res += nodes[curr].accept_count;
    return res;
  }

  // 最長共通接頭辞 (LCP) のマッチ長取得
  // 木に含まれるいずれかの文字列と、sが先頭から何文字一致するか
  int get_lcp_length(const string &s) {
    int curr = 0, len = 0;
    for (char c : s) {
      int to = c - base;
      if (nodes[curr].next[to] == -1) break;
      curr = nodes[curr].next[to];
      len++;
    }
    return len;
  }

  // 辞書順で k 番目 (1-indexed) の文字列を取得
  // k が要素数を超える、または k <= 0 の場合は空文字列を返す
  string kth_element(int k) {
    if (k <= 0 || k > nodes[0].pass_count) return "";
    int curr = 0;
    string res = "";
    while (true) {
      if (k <= nodes[curr].accept_count) return res;
      k -= nodes[curr].accept_count;
      for (int i = 0; i < char_size; i++) {
        int nxt = nodes[curr].next[i];
        if (nxt != -1) {
          if (k <= nodes[nxt].pass_count) {
            res += (char)(base + i);
            curr = nxt;
            break;
          } else {
            k -= nodes[nxt].pass_count;
          }
        }
      }
    }
  }
};

// T: 数列の要素の型 (int, long long など)
template <typename T = long long>
struct Trie {
  struct Node {
    map<T, int> next;       // 子ノードのインデックス
    int accept_count;       // このノードを「終端」とする数列の数
    int pass_count;         // このノードを「通過」した数列の数 (部分木の要素数)
    
    // --- 汎用拡張データ ---
    vector<int> accept_ids; // このノードで終わる数列のラベル(追加時のIDなど)
    long long val;          // 関数値、重み、DPの結果などを持たせる汎用変数

    Node() : accept_count(0), pass_count(0), val(0) {}
  };

  vector<Node> nodes;

  Trie() {
    nodes.push_back(Node()); // root (id = 0) を追加
  }

  // 現在のTrie木に含まれる全数列の数を取得 O(1)
  int size() const {
    return nodes[0].pass_count;
  }

  // 数列の挿入
  void insert(const vector<T> &s, int id = -1, long long val = 0) {
    int curr = 0;
    nodes[curr].pass_count++;
    for (const T& c : s) {
      if (!nodes[curr].next.count(c)) {
        nodes[curr].next[c] = nodes.size();
        nodes.push_back(Node());
      }
      curr = nodes[curr].next[c];
      nodes[curr].pass_count++;
    }
    nodes[curr].accept_count++;
    if (id != -1) nodes[curr].accept_ids.push_back(id);
    nodes[curr].val += val; 
  }

  // 単一数列の正確な削除 (集合からsを1つだけ減らす)
  // 成功したらtrue, そもそも存在しなかったらfalseを返す
  bool erase(const vector<T> &s) {
    int curr = 0;
    vector<int> path;
    for (const T& c : s) {
      path.push_back(curr);
      if (!nodes[curr].next.count(c)) return false; // 存在しない
      curr = nodes[curr].next[c];
    }
    if (nodes[curr].accept_count == 0) return false; // 終端として存在しない
    
    nodes[curr].accept_count--;
    nodes[curr].pass_count--;
    for (int p : path) nodes[p].pass_count--; // 祖先の通過数を減らす
    return true;
  }

  // 完全一致する数列の個数を取得
  int count(const vector<T> &s) {
    int curr = 0;
    for (const T& c : s) {
      if (!nodes[curr].next.count(c)) return 0;
      curr = nodes[curr].next[c];
    }
    return nodes[curr].accept_count;
  }

  // 終端ノードのID検索 (見つかれば終端ノードのIDを、なければ -1)
  int search(const vector<T> &s) {
    int curr = 0;
    for (const T& c : s) {
      if (!nodes[curr].next.count(c)) return -1;
      curr = nodes[curr].next[c];
    }
    return nodes[curr].accept_count > 0 ? curr : -1;
  }

  // Prefix(接頭辞)検索 (S から始まる数列の数を返す)
  int count_prefix(const vector<T> &s) {
    int curr = 0;
    for (const T& c : s) {
      if (!nodes[curr].next.count(c)) return 0;
      curr = nodes[curr].next[c];
    }
    return nodes[curr].pass_count;
  }

  // 特定の数列をprefixに持つ要素を全て削除する
  void erase_by_prefix(const vector<T> &s) {
    if (s.empty()) { 
      nodes[0] = Node(); // 空数列指定は全クリアと同義
      return;
    }
    int curr = 0;
    vector<int> path;
    for (const T& c : s) {
      path.push_back(curr);
      if (!nodes[curr].next.count(c)) return; // 存在しない
      curr = nodes[curr].next[c];
    }
    int removed = nodes[curr].pass_count;
    if (removed == 0) return;
    
    nodes[path.back()].next.erase(s.back()); // 木から切断
    for (int p : path) nodes[p].pass_count -= removed;
  }

  // sがprefixとなるような、木内の数列の「総数」ではなく
  // 「sのprefixとなるような木内の数列」の個数 (s={1,2,3}なら{1,2}, {1,2,3}等)
  int count_prefixes_of(const vector<T> &s) {
    int curr = 0, res = 0;
    for (const T& c : s) {
      res += nodes[curr].accept_count;
      if (!nodes[curr].next.count(c)) return res;
      curr = nodes[curr].next[c];
    }
    res += nodes[curr].accept_count;
    return res;
  }

  // 最長共通接頭辞 (LCP) のマッチ長取得
  // 木に含まれるいずれかの数列と、sが先頭から何要素一致するか
  int get_lcp_length(const vector<T> &s) {
    int curr = 0, len = 0;
    for (const T& c : s) {
      if (!nodes[curr].next.count(c)) break;
      curr = nodes[curr].next[c];
      len++;
    }
    return len;
  }

  // 辞書順で k 番目 (1-indexed) の数列を取得
  // k が要素数を超える、または k <= 0 の場合は空の数列を返す
  vector<T> kth_element(int k) {
    if (k <= 0 || k > nodes[0].pass_count) return {};
    int curr = 0;
    vector<T> res;
    while (true) {
      if (k <= nodes[curr].accept_count) return res;
      k -= nodes[curr].accept_count;
      // mapはキー(要素の値)で自動的に昇順ソートされている
      for (auto& [val, nxt] : nodes[curr].next) {
        if (k <= nodes[nxt].pass_count) {
          res.push_back(val);
          curr = nxt;
          break;
        } else {
          k -= nodes[nxt].pass_count;
        }
      }
    }
  }
};

// T: 扱う整数の型 (int なら MAX_LOG=30, long long なら MAX_LOG=60 が目安)
template <typename T = long long, int MAX_LOG = 60>
struct BinaryTrie {
  struct Node {
    int next[2];       // 0/1 の子ノードへのインデックス (-1は子が存在しない)
    int accept_count;  // このノードを「終端」とする整数の数 (重複管理用)
    int pass_count;    // このノードを「通過」した整数の数 (部分木の要素数)

    Node() : accept_count(0), pass_count(0) {
      next[0] = next[1] = -1;
    }
  };

  vector<Node> nodes;

  BinaryTrie() {
    nodes.push_back(Node()); // root (id = 0) を追加
  }

  // 現在のTrie木に含まれる全要素数を取得 O(1)
  int size() const {
    return nodes[0].pass_count;
  }

  // 要素の挿入 (count 個まとめて追加可能)
  void insert(T val, int count = 1) {
    if (count <= 0) return;
    int curr = 0;
    nodes[curr].pass_count += count;
    for (int i = MAX_LOG - 1; i >= 0; i--) {
      int b = (val >> i) & 1;
      if (nodes[curr].next[b] == -1) {
        nodes[curr].next[b] = nodes.size();
        nodes.push_back(Node());
      }
      curr = nodes[curr].next[b];
      nodes[curr].pass_count += count;
    }
    nodes[curr].accept_count += count;
  }

  // 要素の削除 (count 個まとめて削除可能)
  bool erase(T val, int count = 1) {
    if (count <= 0) return true;
    int curr = 0;
    int existing = this->count(val);
    int remove_cnt = min(existing, count);
    if (remove_cnt == 0) return false;

    nodes[curr].pass_count -= remove_cnt;
    for (int i = MAX_LOG - 1; i >= 0; i--) {
      int b = (val >> i) & 1;
      curr = nodes[curr].next[b];
      nodes[curr].pass_count -= remove_cnt;
    }
    nodes[curr].accept_count -= remove_cnt;
    return existing >= count;
  }

  // 特定の要素の個数を取得
  int count(T val) const {
    int curr = 0;
    for (int i = MAX_LOG - 1; i >= 0; i--) {
      int b = (val >> i) & 1;
      if (nodes[curr].next[b] == -1) return 0;
      curr = nodes[curr].next[b];
    }
    return nodes[curr].accept_count;
  }

  // xor_val と木内の要素を XOR したとき、最小となる値を返す
  T min_element(T xor_val = 0) const {
    if (size() == 0) return -1; 
    int curr = 0;
    T res = 0;
    for (int i = MAX_LOG - 1; i >= 0; i--) {
      int b = (xor_val >> i) & 1;
      if (nodes[curr].next[b] != -1 && nodes[nodes[curr].next[b]].pass_count > 0) {
        curr = nodes[curr].next[b];
      } else {
        curr = nodes[curr].next[b ^ 1];
        res |= (1LL << i); 
      }
    }
    return res;
  }

  // xor_val と木内の要素を XOR したとき、最大となる値を返す
  T max_element(T xor_val = 0) const {
    if (size() == 0) return -1;
    int curr = 0;
    T res = 0;
    for (int i = MAX_LOG - 1; i >= 0; i--) {
      int b = (xor_val >> i) & 1;
      if (nodes[curr].next[b ^ 1] != -1 && nodes[nodes[curr].next[b ^ 1]].pass_count > 0) {
        curr = nodes[curr].next[b ^ 1];
        res |= (1LL << i); 
      } else {
        curr = nodes[curr].next[b];
      }
    }
    return res;
  }

  // 昇順で k 番目 (1-indexed) の値を取得 (オプションで全体に xor_val を作用)
  T kth_element(int k, T xor_val = 0) const {
    if (k <= 0 || k > size()) return -1;
    int curr = 0;
    T res = 0;
    for (int i = MAX_LOG - 1; i >= 0; i--) {
      int b = (xor_val >> i) & 1;
      int left_child = nodes[curr].next[b];
      int left_cnt = (left_child != -1) ? nodes[left_child].pass_count : 0;

      if (k <= left_cnt) {
        curr = left_child;
      } else {
        k -= left_cnt;
        curr = nodes[curr].next[b ^ 1];
        res |= (1LL << i);
      }
    }
    return res;
  }

  // 指定した値未満(xor_val作用時)の要素がいくつあるか
  int count_less_than(T val, T xor_val = 0) const {
    int curr = 0;
    int res = 0;
    for (int i = MAX_LOG - 1; i >= 0; i--) {
      if (curr == -1) break;
      int b = (val >> i) & 1;
      int x = (xor_val >> i) & 1;

      if (b == 1) {
        int zero_child = nodes[curr].next[x];
        if (zero_child != -1) res += nodes[zero_child].pass_count;
        curr = nodes[curr].next[x ^ 1]; 
      } else {
        curr = nodes[curr].next[x];
      }
    }
    return res;
  }

  // 【追加】指定した区間 [L, R] の要素数を取得 (xor_val 作用時)
  int count_in_range(T L, T R, T xor_val = 0) const {
    if (L > R) return 0;
    return count_less_than(R + 1, xor_val) - count_less_than(L, xor_val);
  }

  // 【追加】指定した区間 [L, R] の要素をまとめて削除 (xor_val 作用時)
  // セグメント木のように、完全に区間に含まれる部分木をまるごと切り落とすため O(MAX_LOG)
  // 削除された要素の総数を返す
  int erase_in_range(T L, T R, T xor_val = 0) {
    if (L > R || size() == 0) return 0;
    return _erase_range_rec(0, MAX_LOG - 1, L, R, xor_val, 0);
  }

private:
  int _erase_range_rec(int curr, int depth, T L, T R, T xor_val, T current_xor_prefix) {
    if (curr == -1 || nodes[curr].pass_count == 0) return 0;

    // 現在の部分木に含まれる要素の (XOR適用後の) 最小値と最大値
    T low = current_xor_prefix;
    T high = current_xor_prefix | (T)((1ULL << (depth + 1)) - 1);

    if (high < L || R < low) return 0; // 完全に削除範囲外ならスキップ

    if (L <= low && high <= R) {
      // 完全に削除範囲内なら、この部分木を根元から切断して一括削除
      int deleted = nodes[curr].pass_count;
      nodes[curr].pass_count = 0;
      nodes[curr].accept_count = 0;
      nodes[curr].next[0] = nodes[curr].next[1] = -1;
      return deleted;
    }

    if (depth < 0) return 0;

    int x = (xor_val >> depth) & 1;
    int deleted = 0;

    // 元の木での 0 の枝 (XOR 適用後は 0 ^ x のビットを持つ)
    if (nodes[curr].next[0] != -1) {
      T next_prefix = current_xor_prefix | ((T)(0 ^ x) << depth);
      deleted += _erase_range_rec(nodes[curr].next[0], depth - 1, L, R, xor_val, next_prefix);
    }
    // 元の木での 1 の枝 (XOR 適用後は 1 ^ x のビットを持つ)
    if (nodes[curr].next[1] != -1) {
      T next_prefix = current_xor_prefix | ((T)(1 ^ x) << depth);
      deleted += _erase_range_rec(nodes[curr].next[1], depth - 1, L, R, xor_val, next_prefix);
    }

    nodes[curr].pass_count -= deleted;
    return deleted;
  }
};

// T: 扱う整数の型 (int なら MAX_LOG=30, long long なら MAX_LOG=60 が目安)
template <typename T = long long, int MAX_LOG = 60>
struct LSBBinaryTrie {
  struct Node {
    int next[2];       // 0/1 の子ノードへのインデックス (-1は子が存在しない)
    int accept_count;  // このノードを「終端」とする整数の数
    int pass_count;    // このノードを「通過」した整数の数 (部分木の要素数)

    Node() : accept_count(0), pass_count(0) {
      next[0] = next[1] = -1;
    }
  };

  vector<Node> nodes;

  LSBBinaryTrie() {
    nodes.push_back(Node()); // root (id = 0) を追加
  }

  // 現在のTrie木に含まれる全要素数を取得 O(1)
  int size() const {
    return nodes[0].pass_count;
  }

  // 要素の挿入 (下位ビットから処理)
  void insert(T val, int count = 1) {
    if (count <= 0) return;
    int curr = 0;
    nodes[curr].pass_count += count;
    for (int i = 0; i < MAX_LOG; i++) { // LSB-first (0 から昇順)
      int b = (val >> i) & 1;
      if (nodes[curr].next[b] == -1) {
        nodes[curr].next[b] = nodes.size();
        nodes.push_back(Node());
      }
      curr = nodes[curr].next[b];
      nodes[curr].pass_count += count;
    }
    nodes[curr].accept_count += count;
  }

  // 要素の削除
  bool erase(T val, int count = 1) {
    if (count <= 0) return true;
    int curr = 0;
    int existing = this->count(val);
    int remove_cnt = min(existing, count);
    if (remove_cnt == 0) return false;

    nodes[curr].pass_count -= remove_cnt;
    for (int i = 0; i < MAX_LOG; i++) {
      int b = (val >> i) & 1;
      curr = nodes[curr].next[b];
      nodes[curr].pass_count -= remove_cnt;
    }
    nodes[curr].accept_count -= remove_cnt;
    return existing >= count;
  }

  // 特定の要素の個数を取得
  int count(T val) const {
    int curr = 0;
    for (int i = 0; i < MAX_LOG; i++) {
      int b = (val >> i) & 1;
      if (nodes[curr].next[b] == -1) return 0;
      curr = nodes[curr].next[b];
    }
    return nodes[curr].accept_count;
  }

  // 【特化機能】 x % (2^k) == val % (2^k) となる要素の数を取得 O(k)
  // xor_val を作用させた状態での評価も可能
  int count_mod(T val, int k, T xor_val = 0) const {
    if (k > MAX_LOG) k = MAX_LOG;
    int curr = 0;
    for (int i = 0; i < k; i++) {
      if (curr == -1) return 0;
      int b = (val >> i) & 1;
      int x = (xor_val >> i) & 1;
      curr = nodes[curr].next[b ^ x];
    }
    return curr == -1 ? 0 : nodes[curr].pass_count;
  }

  // 【特化機能】 x % (2^k) == val % (2^k) となる要素を木から一括削除 O(k)
  int erase_mod(T val, int k, T xor_val = 0) {
    if (k > MAX_LOG) k = MAX_LOG;
    if (size() == 0) return 0;
    return _erase_mod_rec(0, 0, val, k, xor_val);
  }

  // 【特化機能】 全ての要素に +1 する (O(MAX_LOG))
  // ※ xor_val での仮想的なXOR操作とは独立して、実際に木の中身をインクリメントします
  void add_all_1() {
    if (size() > 0) {
      _add_all_1_rec(0, 0);
    }
  }

private:
  int _erase_mod_rec(int curr, int depth, T val, int k, T xor_val) {
    if (curr == -1 || nodes[curr].pass_count == 0) return 0;
    
    if (depth == k) {
      int deleted = nodes[curr].pass_count;
      nodes[curr].pass_count = 0;
      nodes[curr].accept_count = 0;
      nodes[curr].next[0] = nodes[curr].next[1] = -1;
      return deleted;
    }

    int target_b = (val >> depth) & 1;
    int x = (xor_val >> depth) & 1;
    int path = target_b ^ x;

    int deleted = 0;
    if (nodes[curr].next[path] != -1) {
      deleted = _erase_mod_rec(nodes[curr].next[path], depth + 1, val, k, xor_val);
    }

    nodes[curr].pass_count -= deleted;
    return deleted;
  }

  void _add_all_1_rec(int curr, int depth) {
    if (curr == -1 || depth == MAX_LOG) return;
    
    // 0の枝と1の枝を入れ替える (+1の適用)
    swap(nodes[curr].next[0], nodes[curr].next[1]);
    
    // 元々 1 だった枝 (入れ替えられて今は next[0] にある) は
    // 桁上がり(キャリー)が発生するため、さらに上の桁へ +1 を伝播させる
    if (nodes[curr].next[0] != -1) {
      _add_all_1_rec(nodes[curr].next[0], depth + 1);
    }
  }
};

vector<int> v;
v.push_back(3);
v.emplace_back(5);
v.pop_back();

vector<int> v;
v.resize(10);          // 要素数10
v.assign(5, 7);        // [7, 7, 7, 7, 7]
v.clear();             // 空にする

vector<ll> v = {1, 2, 3, 2, 4};
v.erase(v.begin() + 1);  // 2番目を削除

v.erase(
    remove(v.begin(), v.end(), 2),
    v.end()
);

// 重複削除と座標圧縮
sort(xs.begin(), xs.end());
xs.erase(unique(xs.begin(), xs.end()), xs.end());
auto get_id = [&](long long x) {
    return lower_bound(xs.begin(), xs.end(), x) - xs.begin();
};

sort(v.begin(), v.end());
sort(v.begin(), v.end(), greater<>());
stable_sort(v.begin(), v.end());
reverse(v.begin(), v.end());

// 2番目の要素(pair.second)で降順ソート
sort(v.begin(), v.end(), [](const auto& a, const auto& b) {
    return a.second > b.second;
});

// 自作関数を別途定義して渡す例
// 1つ目の引数 a が 2つ目の引数 b より「真に小さい（前に来るべき）」場合に true を返す
bool compareData(const Data& a, const Data& b) {
    if (a.score != b.score) {
        return a.score > b.score; // 第1条件: スコアが高い順（a.score > b.score のとき true）
    }
    return a.id < b.id;           // 第2条件: スコアが同じならIDが小さい順（a.id < b.id のとき true）
}

sort(v.begin(), v.end(), compareData);

// ラムダ式で単一・複合条件を指定する例
sort(v.begin(), v.end(), [](const auto& a, const auto& b) {
    // a が b より「真に小さい」ときのみ true（a == b のときは必ず false）
    return a.first < b.first;
});

auto it1 = lower_bound(v.begin(), v.end(), x); // x以上の最初
auto it2 = upper_bound(v.begin(), v.end(), x); // xより大きい最初

ll idx1 = it1 - v.begin();
ll idx2 = it2 - v.begin();

vector<int> v1 = {1, 3, 5};
vector<int> v2 = {2, 4, 6};

// パターン1: 事前に出力先のサイズを確保してマージ
vector<int> res1(v1.size() + v2.size());
merge(v1.begin(), v1.end(), v2.begin(), v2.end(), res1.begin());

// パターン2: back_inserterを使って末尾に追加しながらマージ
vector<int> res2;
merge(v1.begin(), v1.end(), v2.begin(), v2.end(), back_inserter(res2));

// パターン3: カスタム比較関数を用いる例（降順）
// ※入力範囲 v3, v4 も同じ基準（降順）でソートされている必要があります
vector<int> v3 = {5, 3, 1};
vector<int> v4 = {6, 4, 2};
vector<int> res3;
merge(v3.begin(), v3.end(), v4.begin(), v4.end(), back_inserter(res3), greater<>());

// H x W のグリッドを時計回りに90度回転させる関数
vector<vector<ll>> rotate(const vector<vector<ll>>& a) {
    ll h = a.size(), w = a[0].size();
    vector<vector<ll>> res(w, vector<ll>(h));
    for (ll i = 0; i < h; ++i) {
        for (ll j = 0; j < w; ++j) {
            res[j][h - 1 - i] = a[i][j];
        }
    }
    return res;
}

// 90度時計回りに回転させた状態の (r, c) の値を取得
ll get_rotated_val(const vector<vector<ll>>& a, ll r, ll c, ll H, ll W) {
    // 元のグリッドのどの位置が (r, c) に来るかを計算
    return a[H - 1 - c][r];
}

set<ll> st;

// insert: 要素追加
st.insert(10);
st.insert(5);

// find: 探索（なければ end()）
auto it = st.find(10);

// erase: 削除（値 or iterator）
st.erase(10);

// size: setの大きさ取得
st.size();

// lower_bound: 以上で最小の要素
auto lb = st.lower_bound(7);

// 最小・最大
ll mn = *st.begin();
ll mx = *st.rbegin();

// イテレータが指す場所を削除し、次のイテレータを返す
it = st.erase(it);

multiset<ll> mst;

mst.insert(5);
mst.insert(5);
mst.insert(2);

// 1個だけ消す（重要）
mst.erase(mst.find(5));

// 全削除はこれ
mst.erase(5);

map<string, ll> mp;
mp["apple"]++;
mp["banana"] = 3;

if (mp.count("apple")) {
    // 存在確認
}

for (auto &[key, value] : mp) {
    // 昇順に巡回
}

unordered_map<long long, ll> ump;
ump[123456789LL]++;

unordered_set<string> us;
us.insert("alpha");

if (st.count(x)) { /* 存在 */ }

auto it = mp.find(key);
if (it != mp.end()) {
    // it->second を使う
}

if (us.contains("hello")) {
    // C++20
}

// ===== stack =====
stack<ll> st;

st.push(10);      // 要素を追加
st.push(20);

ll x = st.top(); // 一番上を見る（20）
st.pop();         // 一番上を削除

bool empty = st.empty(); // 空か判定
size_t sz = st.size();   // 要素数

// ===== queue =====
queue<ll> q;

q.push(10);        // 後ろに追加
q.push(20);

ll front = q.front(); // 先頭を見る（10）
q.pop();               // 先頭を削除

bool empty2 = q.empty();
size_t sz2 = q.size();

// ===== deque =====
deque<ll> dq;

dq.push_front(10); // 前に追加
dq.push_back(20);  // 後ろに追加

ll first = dq.front(); // 先頭
ll last  = dq.back();  // 末尾

dq.pop_front();    // 前を削除
dq.pop_back();     // 後ろを削除

priority_queue<ll> pq; // 最大ヒープ
pq.push(3);
pq.push(10);
ll mx = pq.top();
pq.pop();

priority_queue<ll, vector<ll>, greater<ll>> minpq; // 最小ヒープ

ll x = 1 << 3;     // 8
bool on = (mask & (1 << i)) != 0;
mask |= (1 << i);    // 立てる
mask ^= (1 << i);    // 反転
mask &= ~(1 << i);   // 落とす

ull reverse_bits(ull val, ll length) {
    ull result = 0;
    for (ll i = 0; i < length; ++i) {
        result = (result << 1) | (val & 1);
        val >>= 1;
    }
    return result;
}

// 1. bitsetの宣言と初期化の例
std::bitset<8> bs1;           // 00000000 (すべて0で初期化)
std::bitset<8> bs2(13);       // 00001101 (整数から初期化)
std::bitset<8> bs3("10110");  // 00010110 (文字列から初期化。右詰めで入る)

// 2. 提示された基本操作の具体例
std::bitset<1000> bs;          // すべて0の1000桁のビット列

bs.set(3);                     // 3番目のビットを1にする   -> bs[3]が1になる
bs.reset(3);                   // 3番目のビットを0に戻す   -> bs[3]が0になる

bool ok = bs.test(3);          // 3番目のビットの状態を取得 -> 0なのでfalse
                               // ※境界チェックのない bs[3] も使用可能

bs.flip();                     // 全てのビットを反転する   -> 全て1になる
bs.flip(3);                    // 3番目のビットだけ反転する -> 1から0になる

// 3. 状態を確認する便利な関数の例
bool any_one = bs.any();       // 1つのビットでも1があればtrue
bool all_zero = bs.none();     // 全てのビットが0ならtrue
bool all_one = bs.all();       // 全てのビットが1ならtrue
size_t num_one = bs.count();   // 1になっているビットの個数を数える (popcountと同じ)

// 4. ビット演算の一括処理例
std::bitset<8> target1("1100");
std::bitset<8> target2("1010");

std::bitset<8> res_and = target1 & target2; // 1000 (AND演算)
std::bitset<8> res_or  = target1 | target2; // 1110 (OR演算)
std::bitset<8> res_xor = target1 ^ target2; // 0110 (XOR演算)
std::bitset<8> res_shl = target1 << 2;      // 00110000 (左シフト)

// 5. 組み込み関数（GCC固有）による高速なビット演算の例
// ※bitsetオブジェクトではなく、通常の整数型(int, unsigned等)に対して使用します
ull x = 13; // 2進数表記で 1101

// __builtin_popcount: 立っている(1の)ビットの数を数える
ll cnt = __builtin_popcount((unsigned)x); 
// 1101 には 1 が3つあるため、cnt = 3 となる

// __builtin_ctz: 末尾(右側)に連続する0の数を数える
// ※ x != 0 が必要（0を渡すと未定義動作）
ll tz = __builtin_ctz((unsigned)x); 
// 1101 は末尾が1（0が連続していない）ため、tz = 0 となる
// 仮に x = 4 (100) であれば、右側に0が2つあるため tz = 2 となる

long long g = gcd(a, b);
long long l = a / gcd(a, b) * b;

ll isqrt(ll x) {
    if (x <= 0) return 0;
    ll res = sqrt(x);
    while ((res + 1) * (res + 1) <= x) res++;
    while (res * res > x) res--;
    return res;
}

#include <vector>
using namespace std;
using ll = long long;

struct Matrix {
    vector<vector<ll>> mat;
    
    // コンストラクタ (r行c列の0行列)
    Matrix(int r, int c) : mat(r, vector<ll>(c, 0)) {}
    
    int h() const { return mat.size(); }
    int w() const { return mat[0].size(); }
    
    // 行列の積
    Matrix operator*(const Matrix& a) const {
        int n = h(), m = a.w(), l = w();
        Matrix res(n, m);
        for (int i = 0; i < n; i++) {
            for (int k = 0; k < l; k++) {
                for (int j = 0; j < m; j++) {
                    res.mat[i][j] += mat[i][k] * a.mat[k][j];
                    // res.mat[i][j] %= MOD; // ※MODが必要な場合はここを有効化
                }
            }
        }
        return res;
    }
    
    // 累乗 (A^k)
    Matrix pow(ll k) const {
        int n = h();
        Matrix res(n, n);
        for (int i = 0; i < n; i++) res.mat[i][i] = 1; // 単位行列
        Matrix x = *this;
        while (k > 0) {
            if (k & 1) res = res * x;
            x = x * x;
            k >>= 1;
        }
        return res;
    }
};

// 区間 [l, r] と、その区間での商 q をまとめる構造体
struct QuotientRange {
    ll l, r, q;
};

// K / i (切り捨て) が一定となる i の区間 [l, r] を列挙してリストで返す関数
// [1, N] の範囲の i について列挙する
vector<QuotientRange> enumerate_quotients(ll K, ll N) {
    vector<QuotientRange> res;
    for (ll l = 1; l <= N; ) {
        ll q = K / l;
        // q == 0 のときは無限大になってしまうため、上限を N にする
        ll r = (q == 0) ? N : min(N, K / q);
        res.push_back({l, r, q});
        l = r + 1;
    }
    return res;
}

#include <atcoder/math>
using namespace std;
using namespace atcoder;
using ll = long long;

int main() {
    ll n = 10;
    ll m = 3;
    ll a = 2;
    ll b = 1;
    
    // sum_{i=0}^{n-1} floor((a*i + b) / m) を計算
    // 例: i=0 -> floor(1/3)=0, i=1 -> floor(3/3)=1, ...
    ll ans = floor_sum(n, m, a, b);
    
    return 0;
}

long long norm(long long x, long long mod) {
    x %= mod;
    if (x < 0) x += mod;
    return x;
}

long long powll(long long a, long long e) {
    long long r = 1;
    while (e) {
        if (e & 1) r *= a;
        a *= a;
        e >>= 1;
    }
    return r;
}

long long modpow(long long a, long long e, long long mod) {
    long long r = 1;
    while (e) {
        if (e & 1) r = r * a % mod;
        a = a * a % mod;
        e >>= 1;
    }
    return r;
}

template <typename T, typename F>
T power(T a, long long e, T identity, F op) {
    T res = identity;
    while (e > 0) {
        if (e & 1) res = op(res, a);
        a = op(a, a);
        e >>= 1;
    }
    return res;
}

vector<vector<ll>> C;

// mx: 必要な最大値（Nなど）, mod: 割る数（0の場合はmodをとらない）
void init_nCr(ll mx, ll mod = 0) {
    C.assign(mx + 1, vector<ll>(mx + 1, 0));
    for (ll i = 0; i <= mx; i++) {
        C[i][0] = 1;
        for (ll j = 1; j <= i; j++) {
            C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
            if (mod > 0) C[i][j] %= mod;
        }
    }
}

// 組合せ nCr
ll nCr(ll n, ll r) {
    if (n < 0 || r < 0 || r > n) return 0;
    return C[n][r];
}

// 順列 nPr (※modなしの場合、nが20を超えると階乗がオーバーフローするため注意)
ll nPr(ll n, ll r, ll mod = 0) {
    if (n < 0 || r < 0 || r > n) return 0;
    ll res = 1;
    for (ll i = 0; i < r; i++) {
        res *= (n - i);
        if (mod > 0) res %= mod;
    }
    return res;
}

// 重複組合せ nHr
ll nHr(ll n, ll r) {
    if (n == 0 && r == 0) return 1;
    if (n <= 0 || r < 0) return 0;
    return nCr(n + r - 1, r);
}


// 使用例
int main() {
    // パターン1: modなしの場合 (N <= 60 程度まで)
    ll max_n_no_mod = 60; 
    init_nCr(max_n_no_mod, 0); 
    cout << "60C30 = " << nCr(60, 30) << "\n"; // 118264581564861424

    // パターン2: 任意のmod（非素数など）の場合 (N <= 5000 程度まで)
    ll mod = 100000; // 素数ではないmodの例
    ll max_n_mod = 5000;
    init_nCr(max_n_mod, mod);
    cout << "5000C2500 mod 100000 = " << nCr(5000, 2500) << "\n";
    
    return 0;
}

vector<long long> fact, fact_inv;

// mx: 必要な最大値（Nなど）, mod: 割る数（素数前提）
void init_nCr(ll mx, long long mod) {
    fact.assign(mx + 1, 1);
    fact_inv.assign(mx + 1, 1);
    vector<long long> inv(mx + 1, 1);
    for (ll i = 2; i <= mx; i++) {
        fact[i] = fact[i - 1] * i % mod;
        inv[i] = mod - inv[mod % i] * (mod / i) % mod;
        fact_inv[i] = fact_inv[i - 1] * inv[i] % mod;
    }
}

// 階乗 n!
long long get_fact(ll n) {
    if (n < 0) return 0;
    return fact[n];
}

// 階乗の逆元 (n!)^-1
long long get_fact_inv(ll n) {
    if (n < 0) return 0;
    return fact_inv[n];
}

// 組合せ nCr
long long nCr(ll n, ll r, long long mod) {
    if (r < 0 || r > n) return 0;
    return fact[n] * fact_inv[r] % mod * fact_inv[n - r] % mod;
}

// 順列 nPr
long long nPr(ll n, ll r, long long mod) {
    if (r < 0 || r > n) return 0;
    return fact[n] * fact_inv[n - r] % mod;
}

// 重複組合せ nHr
long long nHr(ll n, ll r, long long mod) {
    if (n == 0 && r == 0) return 1;
    if (n <= 0 || r < 0) return 0;
    return nCr(n + r - 1, r, mod);
}


//使用例
int main() {
    long long mod = 1000000007;
    ll max_n = 200000; // 問題内で登場する最大の N

    // 1. クエリを呼ぶ前に必ず一度だけ前計算を走らせる
    init_nCr(max_n, mod);

    // 2. 必要なタイミングで各種関数を呼び出す (各 O(1))
    long long f5 = get_fact(5);         // 5! = 120
    long long fi5 = get_fact_inv(5);    // (5!)^-1 mod 1000000007
    long long ans1 = nCr(10, 3, mod);   // 10C3 = 120

    cout << "5! = " << f5 << endl;
    cout << "(5!)^-1 mod 10^9+7 = " << fi5 << endl;
    cout << "10C3 = " << ans1 << endl;
}

#include <atcoder/all>
int main() {

    // ===== 初期化 =====
    mint a = 3;
    mint b(5);

    // ===== 四則演算 =====
    mint c = a + b;
    mint d = a - b;
    mint e = a * b;
    mint f = a / b;      // b の逆元を掛ける

    // ===== int や long long と混ぜてもOK =====
    mint x = 10;

    x += 5;
    x -= 2;
    x *= 7;
    x /= 3;

    // ===== 累乗・逆元 =====
    mint p = x.pow(10);  // x^10
    mint inv = x.inv();  // x^{-1}

    // ===== 値の取り出し =====
    cout << x.val() << endl;

    // ===== 配列でも使える =====
    vector<mint> dp(100);

    // ===== 期待値などの分数 =====
    int N = 5;
    mint invN = mint(1) / N; // 1/N (mod)

    mint ans = mint(2) / 3;  // 2/3 (mod)

    // ===== よくある書き方 =====
    ans += mint(100) * invN;
}

// a と m が互いに素なとき、a * x ≡ 1 (mod m) となる x を返す
long long mod_inv(long long a, long long m) {
    long long b = m, u = 1, v = 0;
    while (b) {
        long long t = a / b;
        a -= t * b; swap(a, b);
        u -= t * v; swap(u, v);
    }
    u %= m;
    if (u < 0) u += m;
    return u;
}

vector<pair<long long, ll>> prime_factorize(long long n) {
    vector<pair<long long, ll>> res;

    for (long long p = 2; p * p <= n; p++) {
        if (n % p != 0) continue;

        ll cnt = 0;
        while (n % p == 0) {
            n /= p;
            cnt++;
        }
        res.push_back({p, cnt});
    }

    if (n > 1) res.push_back({n, 1});

    return res;
}

using u64 = unsigned long long;
using u128 = __int128_t;

// a^b mod m を計算する関数
u64 modpow(u64 a, u64 b, u64 m) {
    a %= m;
    u64 res = 1;
    while (b > 0) {
        if (b & 1) res = (u64)((u128)res * a % m);
        a = (u64)((u128)a * a % m);
        b >>= 1;
    }
    return res;
}

// 64bit整数の素数判定 (Miller-Rabin)
bool is_prime(u64 n) {
    if (n <= 1) return false;
    if (n == 2 || n == 3) return true;
    if (n % 2 == 0) return false;

    u64 d = n - 1;
    int s = 0;
    while (d % 2 == 0) {
        d /= 2;
        s++;
    }

    // 64bit整数を確実に判定できる魔法の7つの底 (Jim Sinclair's bases)
    static const u64 bases[] = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};

    for (u64 a : bases) {
        if (n <= a) break; // nがベース以下の素数の場合はループを抜けてtrue
        
        u64 p = modpow(a, d, n);
        if (p == 1 || p == n - 1) continue;
        
        bool ok = false;
        for (int r = 1; r < s; r++) {
            p = (u64)((u128)p * p % n);
            if (p == n - 1) {
                ok = true;
                break;
            }
        }
        if (!ok) return false;
    }
    return true;
}

vector<long long> enumerate_divisors(long long n) {
    vector<long long> res;

    for (long long i = 1; i * i <= n; i++) {
        if (n % i != 0) continue;

        res.push_back(i);
        // 重複しない場合のみ、ペアとなる約数も追加
        if (i * i != n) {
            res.push_back(n / i);
        }
    }

    // 小さい順に並び替える
    sort(res.begin(), res.end());
    
    return res;
}

// メモリ節約のため、必要な機能のみ true にする
const bool ENABLE_OMEGA     = false; // 素因数の種類数 (omega)
const bool ENABLE_BIG_OMEGA = false; // 素因数の重複込みの個数 (Big Omega)
const bool ENABLE_MAX_PRIME = false; // 最大素因数
const bool ENABLE_MOBIUS    = false; // メビウス関数 (mu)
const bool ENABLE_PHI       = false; // オイラーのφ関数 (phi)
const bool ENABLE_DIV_CNT   = false; // 約数の個数
const bool ENABLE_DIV_SUM   = false; // 約数の総和

struct Sieve {
    vector<ll> min_factor;
    vector<ll> primes;
    vector<int> omega, big_omega, mu;
    vector<ll> max_prime, phi, div_cnt, div_sum;

    Sieve(ll n) : min_factor(n + 1) {
        if (ENABLE_OMEGA) omega.assign(n + 1, 0);
        if (ENABLE_BIG_OMEGA) big_omega.assign(n + 1, 0);
        if (ENABLE_MAX_PRIME) max_prime.assign(n + 1, 1);
        if (ENABLE_MOBIUS) mu.assign(n + 1, 0);
        if (ENABLE_PHI) phi.assign(n + 1, 0);
        if (ENABLE_DIV_CNT) div_cnt.assign(n + 1, 0);
        if (ENABLE_DIV_SUM) div_sum.assign(n + 1, 0);

        if (ENABLE_MOBIUS) mu[1] = 1;
        if (ENABLE_PHI) phi[1] = 1;
        if (ENABLE_DIV_CNT) div_cnt[1] = 1;
        if (ENABLE_DIV_SUM) div_sum[1] = 1;

        for (ll i = 0; i <= n; i++) min_factor[i] = i;
        for (ll i = 2; i * i <= n; i++) {
            if (min_factor[i] == i) {
                for (ll j = i * i; j <= n; j += i) {
                    if (min_factor[j] == j) {
                        min_factor[j] = i;
                    }
                }
            }
        }
        
        for (ll i = 2; i <= n; i++) {
            if (min_factor[i] == i) primes.push_back(i);
            
            // 各種関数の計算 (SPFを利用したDP)
            ll p = min_factor[i];
            ll prev = i / p;
            
            if (ENABLE_OMEGA) {
                omega[i] = omega[prev] + ((prev % p == 0) ? 0 : 1);
            }
            if (ENABLE_BIG_OMEGA) {
                big_omega[i] = big_omega[prev] + 1;
            }
            if (ENABLE_MAX_PRIME) {
                max_prime[i] = max(p, max_prime[prev]);
            }
            if (ENABLE_MOBIUS) {
                if (prev % p == 0) mu[i] = 0;
                else mu[i] = -mu[prev];
            }
            if (ENABLE_PHI) {
                if (prev % p == 0) phi[i] = phi[prev] * p;
                else phi[i] = phi[prev] * (p - 1);
            }
            if (ENABLE_DIV_CNT || ENABLE_DIV_SUM) {
                ll k = 0, temp = i, pk = 1;
                while (temp % p == 0) {
                    temp /= p;
                    k++;
                    pk *= p;
                }
                if (ENABLE_DIV_CNT) {
                    div_cnt[i] = div_cnt[temp] * (k + 1);
                }
                if (ENABLE_DIV_SUM) {
                    ll p_sum = (pk * p - 1) / (p - 1);
                    div_sum[i] = div_sum[temp] * p_sum;
                }
            }
        }
    }

    bool is_prime(ll x) const {
        if (x < 2) return false;
        return min_factor[x] == x;
    }

    vector<pair<ll, ll>> factor(ll x) const {
        vector<pair<ll, ll>> res;
        while (x > 1) {
            ll p = min_factor[x];
            ll cnt = 0;
            while (x % p == 0) {
                x /= p;
                cnt++;
            }
            res.push_back({p, cnt});
        }
        return res;
    }

    // 値 x の各種情報を取得するヘルパー
    int get_omega(ll x) const { return omega[x]; }
    int get_big_omega(ll x) const { return big_omega[x]; }
    ll get_max_prime(ll x) const { return max_prime[x]; }
    int get_mobius(ll x) const { return mu[x]; }
    ll get_phi(ll x) const { return phi[x]; }
    ll get_div_cnt(ll x) const { return div_cnt[x]; }
    ll get_div_sum(ll x) const { return div_sum[x]; }
};

// 前提：sieve of eratosthenes, isqrt
// メモリ節約のため、必要な機能のみ true にする
const bool ENABLE_FACTOR    = false; // 素因数分解 (※ 10^7要素だとMLE注意!)
const bool ENABLE_IS_PRIME  = true;  // 素数判定
const bool ENABLE_OMEGA     = false;  // 素因数の種類数 (omega)
const bool ENABLE_BIG_OMEGA = false;  // 素因数の重複込みの個数 (Big Omega)
const bool ENABLE_MAX_PRIME = false;  // 最大素因数
const bool ENABLE_MOBIUS    = false;  // メビウス関数 (mu)
const bool ENABLE_PHI       = false;  // オイラーのφ関数 (phi)
const bool ENABLE_DIV_CNT   = false;  // 約数の個数
const bool ENABLE_DIV_SUM   = false;  // 約数の総和

struct SegmentSieve {
    ll L, R;
    vector<ll> val;
    vector<vector<pair<ll, ll>>> factors;
    vector<bool> is_p;
    vector<int> omega, big_omega, mu;
    vector<ll> max_prime, phi, div_cnt, div_sum;

    SegmentSieve(ll L, ll R, const vector<ll>& primes)
        : L(L), R(R), val(R - L + 1) {
        
        ll len = R - L + 1;
        for (ll i = 0; i < len; i++) val[i] = L + i;
        
        // 必要な配列のみメモリ確保
        if (ENABLE_FACTOR) factors.resize(len);
        if (ENABLE_IS_PRIME) is_p.assign(len, true);
        if (ENABLE_OMEGA) omega.assign(len, 0);
        if (ENABLE_BIG_OMEGA) big_omega.assign(len, 0);
        if (ENABLE_MAX_PRIME) max_prime.assign(len, 1);
        if (ENABLE_MOBIUS) mu.assign(len, 1);
        if (ENABLE_PHI) {
            phi.resize(len);
            for (ll i = 0; i < len; i++) phi[i] = L + i;
        }
        if (ENABLE_DIV_CNT) div_cnt.assign(len, 1);
        if (ENABLE_DIV_SUM) div_sum.assign(len, 1);

        // 0と1の例外処理
        if (ENABLE_IS_PRIME) {
            if (L == 0) { if (len > 0) is_p[0] = false; if (len > 1) is_p[1] = false; }
            if (L == 1) { if (len > 0) is_p[0] = false; }
        }

        for (ll p : primes) {
            if (p * p > R) break;
            ll start = (L + p - 1) / p * p;
            if (start == 0) start += p; // L=0 の場合の0除算等回避

            for (ll j = start; j <= R; j += p) {
                ll idx = j - L;
                ll cnt = 0;
                while (val[idx] % p == 0) {
                    val[idx] /= p;
                    cnt++;
                }
                
                if (cnt > 0) {
                    if (ENABLE_FACTOR) factors[idx].push_back({p, cnt});
                    if (ENABLE_IS_PRIME && j != p) is_p[idx] = false;
                    if (ENABLE_OMEGA) omega[idx]++;
                    if (ENABLE_BIG_OMEGA) big_omega[idx] += cnt;
                    if (ENABLE_MAX_PRIME) max_prime[idx] = p; // p は昇順なので常に最大で上書きされる
                    if (ENABLE_MOBIUS) {
                        if (cnt == 1) mu[idx] = -mu[idx];
                        else mu[idx] = 0;
                    }
                    if (ENABLE_PHI) phi[idx] = phi[idx] / p * (p - 1);
                    if (ENABLE_DIV_CNT) div_cnt[idx] *= (cnt + 1);
                    if (ENABLE_DIV_SUM) {
                        // オーバーフロー回避のためループで加算 (p^0 + p^1 + ... + p^cnt)
                        ll sum = 1, cur = 1;
                        for (int k = 0; k < cnt; k++) {
                            cur *= p;
                            sum += cur;
                        }
                        div_sum[idx] *= sum;
                    }
                }
            }
        }
        
        // sqrt(R) より大きい最後の素因数が残っている場合の処理
        for (ll i = 0; i < len; i++) {
            if (val[i] > 1) {
                ll p = val[i];
                if (ENABLE_FACTOR) factors[i].push_back({p, 1});
                if (ENABLE_IS_PRIME && (L + i) != p) is_p[i] = false;
                if (ENABLE_OMEGA) omega[i]++;
                if (ENABLE_BIG_OMEGA) big_omega[i]++;
                if (ENABLE_MAX_PRIME) max_prime[i] = p; // sqrt(R)より大きいので確実に最大
                if (ENABLE_MOBIUS) mu[i] = -mu[i];
                if (ENABLE_PHI) phi[i] = phi[i] / p * (p - 1);
                if (ENABLE_DIV_CNT) div_cnt[i] *= 2;
                if (ENABLE_DIV_SUM) div_sum[i] *= (p + 1);
            }
        }
    }
    
    // 値 x (L <= x <= R) の各種情報を取得するヘルパー
    bool is_prime(ll x) const { return is_p[x - L]; }
    int get_omega(ll x) const { return omega[x - L]; }
    int get_big_omega(ll x) const { return big_omega[x - L]; }
    ll get_max_prime(ll x) const { return max_prime[x - L]; }
    int get_mobius(ll x) const { return mu[x - L]; }
    ll get_phi(ll x) const { return phi[x - L]; }
    ll get_div_cnt(ll x) const { return div_cnt[x - L]; }
    ll get_div_sum(ll x) const { return div_sum[x - L]; }
    vector<pair<ll, ll>> get_factors(ll x) const { return factors[x - L]; }
};

// 拡張ユークリッド互除法: g = gcd(a, b), ax + by = g となる (g, x) を返す
pair<long long, long long> inv_gcd(long long a, long long b) {
    a = (a % b + b) % b;
    if (a == 0) return {b, 0};
    long long s = b, t = a;
    long long m0 = 0, m1 = 1;
    while (t) {
        long long u = s / t;
        s -= t * u;
        swap(s, t);
        m0 -= m1 * u;
        swap(m0, m1);
    }
    if (m0 < 0) m0 += b / s;
    return {s, m0};
}

// 複数条件 x ≡ r_i (mod m_i) を満たす x ≡ rem (mod mod) を求める
// 解が存在しない場合は {0, 0} を返す
pair<long long, long long> CRT(const vector<long long>& r, const vector<long long>& m) {
    assert(r.size() == m.size());
    int n = r.size();
    long long r0 = 0, m0 = 1;

    for (int i = 0; i < n; ++i) {
        assert(m[i] >= 1);
        long long r1 = (r[i] % m[i] + m[i]) % m[i];
        long long m1 = m[i];

        if (m0 < m1) {
            swap(r0, r1);
            swap(m0, m1);
        }
        if (m0 % m1 == 0) {
            if (r0 % m1 != r1) return {0, 0};
            continue;
        }

        auto [g, im] = inv_gcd(m0, m1);
        long long u1 = m1 / g;
        if ((r1 - r0) % g != 0) return {0, 0};

        long long x = (r1 - r0) / g % u1;
        if (x < 0) x += u1;
        x = (long long)((__int128_t)x * im % u1);

        r0 += x * m0;
        m0 *= u1;
        if (r0 < 0) r0 += m0;
    }
    return {r0, m0};
}

// RSK対応によって順列からヤング盤を構築し、また復元する構造体
struct RSK {
    vector<vector<int>> P; // 挿入盤 (Insertion Tableau)
    vector<vector<int>> Q; // 記録盤 (Recording Tableau)

    // 長さ N の順列 p から RSK対応を構築
    // p は要素の重複がない前提 (重複がある場合は半標準ヤング盤になる)
    RSK(const vector<int>& p) {
        for (int i = 0; i < (int)p.size(); i++) {
            int x = p[i];
            int r = 0;
            // Pの各行に対して行挿入 (Row Insertion) を行う
            while (r < (int)P.size()) {
                // 現在の行の中で x より大きい最初の要素を探す
                auto it = upper_bound(P[r].begin(), P[r].end(), x);
                if (it == P[r].end()) {
                    // 見つからなければ行の末尾に追加して終了
                    P[r].push_back(x);
                    Q[r].push_back(i + 1); // 記録盤にはステップ数(1-based)を記録
                    break;
                } else {
                    // 見つかった場合はその要素を追い出し、追い出された要素を次の行へ挿入
                    swap(x, *it);
                    r++;
                }
            }
            // 新しい行が必要になった場合
            if (r == (int)P.size()) {
                P.push_back({x});
                Q.push_back({i + 1});
            }
        }
    }

    // ヤング図形の「形」(各行の長さの配列) を返す (分割 λ を表す)
    vector<int> shape() const {
        vector<int> res;
        for (const auto& row : P) res.push_back(row.size());
        return res;
    }

    // ヤング図形の「共役な形」(各列の長さの配列) を返す (分割 λ' を表す)
    vector<int> conjugate_shape() const {
        if (P.empty()) return {};
        vector<int> res(P[0].size(), 0);
        for (int r = 0; r < (int)P.size(); r++) {
            for (int c = 0; c < (int)P[r].size(); c++) {
                res[c]++;
            }
        }
        return res;
    }

    // 最長増加部分列 (LIS) の長さを返す (ヤング盤の1行目の長さ = shape()[0])
    int lis_length() const {
        if (P.empty()) return 0;
        return P[0].size();
    }

    // 最長減少部分列 (LDS) の長さを返す (ヤング盤の1列目の長さ = 行数)
    int lds_length() const {
        return P.size();
    }

    // PとQの組から元の順列を復元する（逆RSK対応）
    static vector<int> restore_permutation(vector<vector<int>> P_tab, vector<vector<int>> Q_tab) {
        if (P_tab.empty()) return {};
        int N = 0;
        for (const auto& row : P_tab) N += row.size();
        
        vector<int> p(N);
        // Qの値(1〜N)から、追加された位置(r, c)を逆引きする配列
        vector<pair<int, int>> pos(N + 1);
        for (int r = 0; r < (int)Q_tab.size(); r++) {
            for (int c = 0; c < (int)Q_tab[r].size(); c++) {
                pos[Q_tab[r][c]] = {r, c};
            }
        }
        
        // 最後のステップ N から 1 に向かって逆算
        for (int k = N; k >= 1; k--) {
            int r = pos[k].first;
            int c = pos[k].second;
            
            int x = P_tab[r][c];
            P_tab[r].pop_back();
            if (P_tab[r].empty()) P_tab.pop_back(); // 最後の行が空になったら削除
            
            // 逆行挿入 (Reverse Row Insertion)
            for (int i = r - 1; i >= 0; i--) {
                // 上の行の中で x より小さい最大の要素を探す
                auto it = lower_bound(P_tab[i].begin(), P_tab[i].end(), x);
                --it; 
                swap(x, *it);
            }
            p[k - 1] = x;
        }
        return p;
    }
};

// フック長公式を用いて標準ヤング盤(SYT)の個数を計算する構造体・関数群
struct HookLength {
    // 各マスのフック長(右のマス数 + 下のマス数 + 1)のテーブルを返す
    static vector<vector<int>> get_hook_lengths(const vector<int>& lambda) {
        if (lambda.empty()) return {};
        int r = lambda.size();
        
        // 各列のマス数(共役分割 λ')を計算
        int max_c = lambda[0];
        vector<int> conj(max_c, 0);
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < lambda[i]; j++) {
                conj[j]++;
            }
        }
        
        // フック長の計算: h(i, j) = (lambda[i] - j) + (conj[j] - i) - 1
        vector<vector<int>> h(r);
        for (int i = 0; i < r; i++) {
            h[i].resize(lambda[i]);
            for (int j = 0; j < lambda[i]; j++) {
                h[i][j] = (lambda[i] - j) + (conj[j] - i) - 1;
            }
        }
        return h;
    }

    // 繰り返し二乗法による mod 逆元計算用のヘルパー
    static long long mod_pow(long long a, long long n, long long mod) {
        long long res = 1;
        a %= mod;
        while (n > 0) {
            if (n & 1) res = (res * a) % mod;
            a = (a * a) % mod;
            n >>= 1;
        }
        return res;
    }

    // 形 lambda を持つ標準ヤング盤 (SYT) の個数を mod で返す
    // f^λ = N! / Π h(i, j)
    static long long count_syt(const vector<int>& lambda, long long mod = 998244353) {
        if (lambda.empty()) return 0;
        int N = 0;
        for (int x : lambda) N += x;

        // 分子: N! % mod
        long long num = 1;
        for (int i = 1; i <= N; i++) {
            num = (num * i) % mod;
        }

        // 分母: フック長の積 % mod
        auto h = get_hook_lengths(lambda);
        long long den = 1;
        for (const auto& row : h) {
            for (int val : row) {
                den = (den * val) % mod;
            }
        }

        // num * den^(mod - 2) % mod
        return (num * mod_pow(den, mod - 2, mod)) % mod;
    }
};

using ll = long long;
using ld = long double;

// 汎用性のため、ld (long double) や modint (例: modint998244353) を T に指定できる
template<typename T>
struct TreeRandomWalk {
    struct Edge {
        ll to;
        T w;
    };
    ll n;
    vector<vector<Edge>> g;
    vector<T> weight_sum;
    T total_weight_sum;

    // 高速クエリ(LCA)用
    bool is_built_lca = false;
    ll logV;
    vector<vector<ll>> parent;
    vector<ll> depth;
    vector<T> dist_up;
    vector<T> dist_down;

    TreeRandomWalk(ll n) : n(n), g(n), weight_sum(n, T(0)), total_weight_sum(T(0)) {}
    
    // w: 遷移の重み（等分布なら省略で1になる。遷移確率は周囲の辺の重みの割合で決まる）
    void add_edge(ll u, ll v, T w = T(1)) {
        g[u].push_back({v, w});
        g[v].push_back({u, w});
        weight_sum[u] += w;
        weight_sum[v] += w;
        total_weight_sum += w * T(2);
    }
    
    // --- 1. 高速クエリ (任意の u から v への期待歩数) ---
    void build_fast_query(ll root = 0) {
        logV = 1;
        while ((1LL << logV) <= n) logV++;
        parent.assign(logV, vector<ll>(n, -1));
        depth.assign(n, 0);
        dist_up.assign(n, T(0));
        dist_down.assign(n, T(0));

        vector<T> sub_W(n, T(0));

        // 1回目のDFS: 各部分木の重み和を計算
        auto dfs1 = [&](auto& self, ll u, ll p, ll d) -> void {
            parent[0][u] = p;
            depth[u] = d;
            sub_W[u] = weight_sum[u];
            for (auto& edge : g[u]) {
                ll v = edge.to;
                if (v == p) continue;
                self(self, v, u, d + 1);
                sub_W[u] += sub_W[v];
            }
        };
        dfs1(dfs1, root, -1, 0);

        // 2回目のDFS: 木を切断した際の連結成分の重み和を用いてパスの期待値を累積
        auto dfs2 = [&](auto& self, ll u, ll p) -> void {
            for (auto& edge : g[u]) {
                ll v = edge.to;
                if (v == p) continue;
                T w = edge.w;
                // v から u への期待歩数
                T E_v_to_u = sub_W[v] / w;
                // u から v への期待歩数
                T E_u_to_v = (total_weight_sum - sub_W[v]) / w;

                dist_up[v] = dist_up[u] + E_v_to_u;
                dist_down[v] = dist_down[u] + E_u_to_v;
                
                self(self, v, u);
            }
        };
        dfs2(dfs2, root, -1);

        // ダブリングテーブル構築
        for (ll k = 0; k + 1 < logV; k++) {
            for (ll u = 0; u < n; u++) {
                if (parent[k][u] < 0) parent[k + 1][u] = -1;
                else parent[k + 1][u] = parent[k][parent[k][u]];
            }
        }
        is_built_lca = true;
    }

    ll get_lca(ll u, ll v) {
        if (!is_built_lca) build_fast_query();
        if (depth[u] > depth[v]) swap(u, v);
        for (ll k = 0; k < logV; k++) {
            if (((depth[v] - depth[u]) >> k) & 1) {
                v = parent[k][v];
            }
        }
        if (u == v) return u;
        for (ll k = logV - 1; k >= 0; k--) {
            if (parent[k][u] != parent[k][v]) {
                u = parent[k][u];
                v = parent[k][v];
            }
        }
        return parent[0][u];
    }

    // u から v に到達するまでの期待歩数
    T expected_steps_fast(ll u, ll v) {
        if (!is_built_lca) build_fast_query();
        ll lca = get_lca(u, v);
        T E_u_lca = dist_up[u] - dist_up[lca];
        T E_lca_v = dist_down[v] - dist_down[lca];
        return E_u_lca + E_lca_v;
    }

    // --- 2. 汎用DPソルバー (複数ゴールや確率、訪問回数など) ---
    // is_fixed[u]: 境界条件として固定されているか
    // fixed_val[u]: 固定値
    // C[u]: 1ステップごとの加算コスト
    vector<T> solve(const vector<bool>& is_fixed, const vector<T>& fixed_val, const vector<T>& C) {
        vector<T> A(n, T(0)), B(n, T(0));
        vector<T> ans(n, T(0));
        
        ll root = -1;
        for (ll i = 0; i < n; i++) {
            if (is_fixed[i]) { root = i; break; }
        }
        if (root == -1) return ans;
        
        auto dfs_bottom_up = [&](auto& self, ll u, ll p) -> void {
            T sum_A = T(0), sum_B = T(0);
            T p_weight = T(0);
            
            // 先にすべての子頂点を探索する
            for (auto& edge : g[u]) {
                ll v = edge.to;
                if (v == p) {
                    p_weight = edge.w;
                    continue;
                }
                self(self, v, u);
                sum_A += edge.w * A[v];
                sum_B += edge.w * B[v];
            }
            
            // 子の探索後に自分自身の係数を決定する
            if (is_fixed[u]) {
                A[u] = T(0);
                B[u] = fixed_val[u];
            } else {
                T den = weight_sum[u] - sum_A;
                if (p != -1) A[u] = p_weight / den;
                else A[u] = T(0);
                B[u] = (sum_B + weight_sum[u] * C[u]) / den;
            }
        };
        dfs_bottom_up(dfs_bottom_up, root, -1);
        
        auto dfs_top_down = [&](auto& self, ll u, ll p) -> void {
            if (p == -1) ans[u] = B[u];
            else ans[u] = A[u] * ans[p] + B[u];
            
            for (auto& edge : g[u]) {
                ll v = edge.to;
                if (v == p) continue;
                self(self, v, u);
            }
        };
        dfs_top_down(dfs_top_down, root, -1);
        return ans;
    }
    
    // DP: ゴールリストに到達するまでの期待歩数
    vector<T> expected_steps(const vector<ll>& goals) {
        vector<bool> is_fixed(n, false);
        vector<T> fixed_val(n, T(0));
        vector<T> C(n, T(1));
        for (ll g_node : goals) {
            is_fixed[g_node] = true;
        }
        return solve(is_fixed, fixed_val, C);
    }
    
    // DP: ターゲットのいずれかに到達する確率 (avoid_nodesは吸収されるが到達扱いしない)
    vector<T> hit_probability(const vector<ll>& targets, const vector<ll>& avoid_nodes) {
        vector<bool> is_fixed(n, false);
        vector<T> fixed_val(n, T(0));
        vector<T> C(n, T(0));
        for (ll t : targets) { is_fixed[t] = true; fixed_val[t] = T(1); }
        for (ll a : avoid_nodes) { is_fixed[a] = true; fixed_val[a] = T(0); }
        return solve(is_fixed, fixed_val, C);
    }
    
    // DP: ゴール到達までに特定の頂点を訪問する期待回数
    vector<T> expected_visits(const vector<ll>& goals, ll target_node) {
        vector<bool> is_fixed(n, false);
        vector<T> fixed_val(n, T(0));
        vector<T> C(n, T(0));
        C[target_node] = T(1);
        for (ll g_node : goals) { is_fixed[g_node] = true; }
        return solve(is_fixed, fixed_val, C);
    }
};

const double PI = acos(-1.0);

// degree → radian
double rad = deg * PI / 180.0;

// radian → degree
double deg = rad * 180.0 / PI;

double x = cos(rad);
double y = sin(rad);

double t = tan(rad);

// 点 (x, y) の偏角 (-pi ~ pi)
double angle = atan2(y, x);

double theta1 = acos(x);
double theta2 = asin(x);
double theta3 = atan(x);

// degree 表示
double deg = acos(x) * 180.0 / PI;

double dx = x2 - x1;
double dy = y2 - y1;

double dist = hypot(dx, dy);
// sqrt(dx * dx + dy * dy) と同等

const double EPS = 1e-9;

bool equal(double a, double b) {
    return fabs(a - b) < EPS;
}

struct Point {
    long long x, y;
};

// 座標の上下左右の半平面（領域）を判定する関数
// [ -pi, pi ) の範囲を扱い、下半平面を先行させる例
int get_zone(const Point& p) {
    if (p.x == 0 && p.y == 0) return 0;
    if (p.y < 0) return -1; // 下半平面 (y < 0)
    if (p.y > 0) return 1;  // 上半平面 (y > 0)
    if (p.x > 0) return -1; // 正のx軸 (y == 0, x > 0)
    return 1;               // 負のx軸 (y == 0, x < 0)
}

// 偏角ソート用の比較関数
bool compare_angle(const Point& a, const Point& b) {
    int zone_a = get_zone(a);
    int zone_b = get_zone(b);
    if (zone_a != zone_b) {
        return zone_a < zone_b;
    }
    // 同じ半平面内にある場合は外積で判定
    // 外積 (a.x * b.y - a.y * b.x) > 0 ならば、aから見てbが左側（反時計回り側）にある
    long long cross_product = a.x * b.y - a.y * b.x;
    if (cross_product != 0) {
        return cross_product > 0;
    }
    // 偏角が同じ場合は、原点からの距離（等、任意の基準）でタイブレーク
    return a.x * a.x + a.y * a.y < b.x * b.x + b.y * b.y;
}

// 使用例
    sort(points.begin(), points.end(), compare_angle);
    auto it = lower_bound(points.begin(), points.end(), target, compare_angle);

// 2D座標の構造体
struct Point {
    long long x, y;
};

// ベクトルの引き算
Point operator-(const Point& a, const Point& b) {
    return {a.x - b.x, a.y - b.y};
}

// 外積 (Cross Product)
long long cross(const Point& a, const Point& b) {
    return a.x * b.y - a.y * b.x;
}

// 内積 (Dot Product)
long long dot(const Point& a, const Point& b) {
    return a.x * b.x + a.y * b.y;
}

// CCW: 線分 ab に対する 点 c の位置関係を返す
// 戻り値:
//  1: a → b に対して c が反時計回り (左折)
// -1: a → b に対して c が時計回り (右折)
//  2: c - a - b の順で同一直線上
// -2: a - b - c の順で同一直線上
//  0: a - c - b の順で同一直線上 (線分 ab 上に c がある)
int ccw(Point a, Point b, Point c) {
    Point ab = b - a;
    Point ac = c - a;
    
    long long cr = cross(ab, ac);
    if (cr > 0) return 1;       // 反時計回り
    if (cr < 0) return -1;      // 時計回り
    
    // 以下は同一直線上 (cr == 0) の場合
    if (dot(ab, ac) < 0) return 2;  // cがaの反対側にある
    if (dot(ab, ab) < dot(ac, ac)) return -2; // cがbの先にある
    return 0; // cが線分ab上にある (a == c, b == c の場合も含む)
}

// GCD (最大公約数)
long long gcd(long long a, long long b) {
    if (a < 0) a = -a;
    if (b < 0) b = -b;
    return b == 0 ? a : gcd(b, a % b);
}

// 有理数 (分数) 構造体
struct Fraction {
    long long num, den; // 分子(numerator), 分母(denominator)

    Fraction(long long n = 0, long long d = 1) {
        if (d < 0) { n = -n; d = -d; } // 分母は常に正にする
        long long g = gcd(n, d);
        num = n / g;
        den = d / g;
    }

    // 比較演算子 (オーバーフロー防止のため __int128_t を使用)
    bool operator==(const Fraction& o) const { return num == o.num && den == o.den; }
    bool operator!=(const Fraction& o) const { return !(*this == o); }
    bool operator<(const Fraction& o) const {
        return (__int128_t)num * o.den < (__int128_t)o.num * den;
    }
    bool operator<=(const Fraction& o) const { return *this < o || *this == o; }
    bool operator>(const Fraction& o) const { return o < *this; }
    bool operator>=(const Fraction& o) const { return o <= *this; }
};

#include <cmath>

// CCW,Fractionを事前に導入しておく必要がある

struct Line {
    long long a, b, c; // ax + by + c = 0

    // a, b, c から直線を生成 (正規化)
    Line(long long a_, long long b_, long long c_) {
        long long g = gcd(gcd(a_, b_), c_);
        a = a_ / g; b = b_ / g; c = c_ / g;
        // 一意性を保つため、aが負、または「a=0かつbが負」の場合は符号を反転
        if (a < 0 || (a == 0 && b < 0)) {
            a = -a; b = -b; c = -c;
        }
    }

    // 2点 p1, p2 を通る直線
    Line(Point p1, Point p2) {
        long long a_ = p2.y - p1.y;
        long long b_ = p1.x - p2.x;
        long long c_ = p2.x * p1.y - p1.x * p2.y;
        *this = Line(a_, b_, c_);
    }

    bool operator<(const Line& o) const {
        if (a != o.a) return a < o.a;
        if (b != o.b) return b < o.b;
        return c < o.c;
    }
    bool operator==(const Line& o) const {
        return a == o.a && b == o.b && c == o.c;
    }
};

// ---------------- 作図・生成系 ----------------

// 2点の垂直二等分線を生成
Line perpendicular_bisector(Point p1, Point p2) {
    long long a = 2 * (p2.x - p1.x);
    long long b = 2 * (p2.y - p1.y);
    long long c = (p1.x * p1.x - p2.x * p2.x) + (p1.y * p1.y - p2.y * p2.y);
    return Line(a, b, c);
}

// 直線lと平行で、点pを通る直線を生成
Line parallel_line(const Line& l, Point p) {
    return Line(l.a, l.b, -(l.a * p.x + l.b * p.y));
}

// 直線lと垂直で、点pを通る直線を生成
Line perpendicular_line(const Line& l, Point p) {
    return Line(-l.b, l.a, l.b * p.x - l.a * p.y);
}

// ---------------- 判定系 ----------------

// 平行判定 (外積が0)
bool is_parallel(const Line& l1, const Line& l2) {
    return l1.a * l2.b - l1.b * l2.a == 0;
}

// 直交判定 (内積が0)
bool is_orthogonal(const Line& l1, const Line& l2) {
    return l1.a * l2.a + l1.b * l2.b == 0;
}

// 交差判定 (平行でない、または同一の直線である)
bool is_intersect(const Line& l1, const Line& l2) {
    return !is_parallel(l1, l2) || (l1 == l2);
}

// ---------------- 座標・距離計算系 ----------------

// 2直線の交点を Fraction (有理数) のペアで返す
// ※事前に is_parallel(l1, l2) が false であることを確認すること
pair<Fraction, Fraction> intersection(const Line& l1, const Line& l2) {
    long long det = l1.a * l2.b - l1.b * l2.a;
    long long x_num = l1.b * l2.c - l2.b * l1.c;
    long long y_num = l2.a * l1.c - l1.a * l2.c;
    return {Fraction(-x_num, det), Fraction(-y_num, det)};
}

// 点pから直線lに下ろした垂線の足 (Fraction のペア)
pair<Fraction, Fraction> foot_of_perpendicular(const Line& l, Point p) {
    Line perp = perpendicular_line(l, p);
    return intersection(l, perp);
}

// 点pと直線lの距離 (ここだけ double を返す)
double distance(const Line& l, Point p) {
    return abs(l.a * p.x + l.b * p.y + l.c) / sqrt(l.a * l.a + l.b * l.b);
}

#include <vector>
#include <algorithm>
#include <map>

// 直線の傾きを一意に表すキー (a, b を gcd(a,b) で割って最小約分したペア)
// ※平行な直線はすべて同じキーを返す
pair<long long, long long> get_slope_key(const Line& l) {
    long long g = gcd(l.a, l.b);
    return {l.a / g, l.b / g};
}

// 1. 数値としての傾き m = -a/b (-∞ < m <= +∞) でソートする比較関数
// 順序: 負の傾き (例: -2) < 水平(0) < 正の傾き (例: +3) < 垂直(+∞)
bool compare_by_slope(const Line& l1, const Line& l2) {
    // 垂直線 (b == 0) は傾き +∞ とみなす
    if (l1.b == 0 && l2.b == 0) return l1 < l2; // 傾きが同じなら Line の < 演算子で安定化
    if (l1.b == 0) return false; // l1 が +∞
    if (l2.b == 0) return true;  // l2 が +∞

    // -a1 / b1 < -a2 / b2 の比較 (分母を正にして分子×分母で比較)
    long long n1 = -l1.a, d1 = l1.b;
    if (d1 < 0) { n1 = -n1; d1 = -d1; }
    
    long long n2 = -l2.a, d2 = l2.b;
    if (d2 < 0) { n2 = -n2; d2 = -d2; }

    __int128_t val1 = (__int128_t)n1 * d2;
    __int128_t val2 = (__int128_t)n2 * d1;

    if (val1 != val2) return val1 < val2;
    return l1 < l2; // 傾きが同じ場合は定数項(切片)順でソート
}

// 2. 偏角 [0, π) 順でソートする比較関数 (x軸正の向きからの回転角)
// 順序: 水平(0°) -> 鋭角(例: 45°) -> 垂直(90°) -> 鈍角(例: 135°)
bool compare_by_angle(const Line& l1, const Line& l2) {
    auto get_zone = [](const Line& l) {
        if (l.b == 0) return 1; // 垂直 [90°]
        if (l.b < 0 || (l.a == 0 && l.b > 0)) return 0; // [0°, 90°) : 水平または正の傾き
        return 2; // (90°, 180°) : 負の傾き
    };

    int z1 = get_zone(l1);
    int z2 = get_zone(l2);
    if (z1 != z2) return z1 < z2;
    return compare_by_slope(l1, l2);
}

// 3. 平行な直線（同じ傾きを持つ直線）ごとにグループ化する
map<pair<long long, long long>, vector<Line>> group_by_slope(const vector<Line>& lines) {
    map<pair<long long, long long>, vector<Line>> res;
    for (const auto& l : lines) {
        res[get_slope_key(l)].push_back(l);
    }
    return res;
}

#include <cmath>
#include <vector>

// CCW,FractionとLineがあると動作する

// 浮動小数点で座標を扱うための構造体
struct PointF {
    long double x, y;
};

// 円の構造体
struct Circle {
    Point c;     // 中心座標 (整数)
    long long r; // 半径 (整数)
};

// 2円の位置関係 (共通接線の数を返す)
// 5: 同一の円, 4: 離れている, 3: 外接する, 2: 交わる, 1: 内接する, 0: 内包する
int circle_relation(Circle c1, Circle c2) {
    long long dx = c1.c.x - c2.c.x;
    long long dy = c1.c.y - c2.c.y;
    long long d2 = dx * dx + dy * dy; // 中心間の距離の2乗
    
    if (d2 == 0 && c1.r == c2.r) return 5;

    long long r_add = (c1.r + c2.r) * (c1.r + c2.r);
    long long r_sub = (c1.r - c2.r) * (c1.r - c2.r);
    
    if (d2 > r_add) return 4;
    if (d2 == r_add) return 3;
    if (d2 > r_sub) return 2;
    if (d2 == r_sub) return 1;
    return 0;
}

// 円と直線の交点 (0個, 1個(接点), または2個の PointF を返す)
vector<PointF> intersection(const Circle& c, const Line& l) {
    long double a = l.a, b = l.b, cc = l.c;
    long double cx = c.c.x, cy = c.c.y;
    long double d_den = a * a + b * b;
    
    // 中心から直線に下ろした垂線の足 (x0, y0)
    long double x0 = (b * (b * cx - a * cy) - a * cc) / d_den;
    long double y0 = (a * (a * cy - b * cx) - b * cc) / d_den;

    long double d2 = (cx - x0) * (cx - x0) + (cy - y0) * (cy - y0);
    long double r2 = (long double)c.r * c.r;

    // 誤差を考慮 (EPS = 1e-9)
    if (d2 > r2 + 1e-9) return {}; // 交点なし
    if (abs(d2 - r2) < 1e-9) return {{x0, y0}}; // 接する (1点)

    // 三平方の定理で交点までのオフセット距離を計算
    long double w = sqrt(max((long double)0.0, r2 - d2));
    long double len = sqrt(d_den);
    long double dx = (b / len) * w;
    long double dy = (-a / len) * w;
    
    return {{x0 + dx, y0 + dy}, {x0 - dx, y0 - dy}};
}

// 円と円の交点 (0個, 1個(接点), または2個の PointF を返す)
vector<PointF> intersection(Circle c1, Circle c2) {
    int rel = circle_relation(c1, c2);
    
    if (rel == 5 || rel == 4 || rel == 0) return {}; // 交点なし

    long double cx1 = c1.c.x, cy1 = c1.c.y;
    long double cx2 = c2.c.x, cy2 = c2.c.y;
    long double d = sqrt((cx1 - cx2) * (cx1 - cx2) + (cy1 - cy2) * (cy1 - cy2));
    
    // c1の中心から交線を結ぶ弦の中点までの距離 a
    long double a = (c1.r * c1.r - c2.r * c2.r + d * d) / (2.0 * d);
    long double h = sqrt(max((long double)0.0, (long double)c1.r * c1.r - a * a));
    
    // 弦の中点
    long double px = cx1 + a / d * (cx2 - cx1);
    long double py = cy1 + a / d * (cy2 - cy1);
    
    if (rel == 1 || rel == 3) return {{px, py}}; // 接する (1点)
    
    // 中点からのオフセットベクトル
    long double dx = -h / d * (cy2 - cy1);
    long double dy =  h / d * (cx2 - cx1);
    
    return {{px + dx, py + dy}, {px - dx, py - dy}};
}

#include <cmath>
#include <algorithm>

// CCW,Line,Fractionが必要

// 2点間の距離 (整数座標版)
long double dist(Point a, Point b) {
    return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
}

// 2点間の距離 (浮動小数点座標版)
long double distF(PointF a, PointF b) {
    return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
}

// 面積 (外積の半分なので、絶対値をとり2で割る)
long double triangle_area(Point a, Point b, Point c) {
    return abs(cross(b - a, c - a)) / 2.0;
}

// 重心 (Centroid) : 3頂点の平均
PointF centroid(Point a, Point b, Point c) {
    return {(a.x + b.x + c.x) / 3.0, (a.y + b.y + c.y) / 3.0};
}

// 内心 (Incenter) と 内接円の半径
// 戻り値: {内心の座標, 内接円の半径}
pair<PointF, long double> incircle(Point a, Point b, Point c) {
    long double la = dist(b, c), lb = dist(c, a), lc = dist(a, b);
    long double peri = la + lb + lc;
    PointF incenter = {
        (la * a.x + lb * b.x + lc * c.x) / peri,
        (la * a.y + lb * b.y + lc * c.y) / peri
    };
    long double r = 2.0 * triangle_area(a, b, c) / peri;
    return {incenter, r};
}

// 傍心 (Excenter) - 頂点Aの向かい側にある傍心のみ例示
// 用途は少ないが、内心の公式の la を -la に変えるだけで求まる
PointF excenterA(Point a, Point b, Point c) {
    long double la = dist(b, c), lb = dist(c, a), lc = dist(a, b);
    long double peri = -la + lb + lc;
    return {
        (-la * a.x + lb * b.x + lc * c.x) / peri,
        (-la * a.y + lb * b.y + lc * c.y) / peri
    };
}

// 外心 (Circumcenter) と 外接円の半径
// 戻り値: {外心の座標, 外接円の半径}
pair<PointF, long double> circumcircle(Point a, Point b, Point c) {
    long double d = 2.0 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
    long double a2 = a.x * a.x + a.y * a.y;
    long double b2 = b.x * b.x + b.y * b.y;
    long double c2 = c.x * c.x + c.y * c.y;
    
    PointF circumcenter = {
        (a2 * (b.y - c.y) + b2 * (c.y - a.y) + c2 * (a.y - b.y)) / d,
        (a2 * (c.x - b.x) + b2 * (a.x - c.x) + c2 * (b.x - a.x)) / d
    };
    long double r = distF({(long double)a.x, (long double)a.y}, circumcenter);
    return {circumcenter, r};
}

// 垂心 (Orthocenter)
// オイラー線 (H = 3G - 2O) を利用して高速計算
PointF orthocenter(Point a, Point b, Point c) {
    PointF g = centroid(a, b, c);
    PointF o = circumcircle(a, b, c).first;
    return {3.0 * g.x - 2.0 * o.x, 3.0 * g.y - 2.0 * o.y};
}

// Fermat点 (3頂点からの距離の和が最小になる点) と その距離の和
// 幾何的解法ではなく Weiszfeld のアルゴリズム(反復法)で解く実戦的実装
pair<PointF, long double> fermat_point(Point a, Point b, Point c) {
    PointF p = centroid(a, b, c); // 重心を初期値とする
    PointF pa = {(long double)a.x, (long double)a.y};
    PointF pb = {(long double)b.x, (long double)b.y};
    PointF pc = {(long double)c.x, (long double)c.y};
    
    // 100回程度反復すれば long double の精度上限付近まで収束する
    for (int i = 0; i < 100; ++i) {
        long double da = max((long double)1e-12, distF(p, pa));
        long double db = max((long double)1e-12, distF(p, pb));
        long double dc = max((long double)1e-12, distF(p, pc));
        p.x = (pa.x/da + pb.x/db + pc.x/dc) / (1.0/da + 1.0/db + 1.0/dc);
        p.y = (pa.y/da + pb.y/db + pc.y/dc) / (1.0/da + 1.0/db + 1.0/dc);
    }
    
    long double sum_dist = distF(p, pa) + distF(p, pb) + distF(p, pc);
    return {p, sum_dist};
}

#include <vector>
#include <algorithm>

// CCW,Fractionが必要

// Point構造体にソート用の比較演算子を追加 (x優先、次にy)
bool operator<(const Point& a, const Point& b) {
    if (a.x != b.x) return a.x < b.x;
    return a.y < b.y;
}

// 凸包を求める (反時計回りに頂点のリストを返す)
vector<Point> convex_hull(vector<Point> p) {
    int n = p.size();
    if (n <= 2) return p;
    
    sort(p.begin(), p.end()); // 辞書順ソート
    vector<Point> qs;
    
    // 下側凸包の構築
    for (int i = 0; i < n; i++) {
        // 直進 (ccw == 2, -2, 0) や右折 (ccw == -1) の場合はスタックから取り除く
        // ※辺上の点を含めたい場合は != 1 ではなく == -1 に変更する
        while (qs.size() > 1 && ccw(qs[qs.size()-2], qs.back(), p[i]) != 1) {
            qs.pop_back();
        }
        qs.push_back(p[i]);
    }
    
    int t = qs.size();
    // 上側凸包の構築 (右端から左端へ戻る)
    for (int i = n - 2; i >= 0; i--) {
        while (qs.size() > t && ccw(qs[qs.size()-2], qs.back(), p[i]) != 1) {
            qs.pop_back();
        }
        qs.push_back(p[i]);
    }
    
    qs.pop_back(); // 始点と終点が重複するため最後の1つを削除
    return qs;
}

#include <vector>
#include <random>
#include <algorithm>

// Triangle , CCW, Fraction, Line などが必要

// 2点を直径の対向とする円を生成
pair<PointF, long double> circle2(Point a, Point b) {
    PointF c = {(a.x + b.x) / 2.0, (a.y + b.y) / 2.0};
    return {c, distF(c, {(long double)a.x, (long double)a.y})};
}

// 最小包含円 (Welzl's Algorithm)
// 戻り値: {中心座標, 半径}
pair<PointF, long double> min_enclosing_circle(vector<Point> p) {
    if (p.empty()) return {{0.0, 0.0}, 0.0};
    if (p.size() == 1) return {{(long double)p[0].x, (long double)p[0].y}, 0.0};

    // 乱数で頂点順序をシャッフル (期待値O(N)にするための肝)
    mt19937 mt(1333); // 再現性のために固定シードを使用
    shuffle(p.begin(), p.end(), mt);

    // 初期円を最初の1点とする (半径0)
    pair<PointF, long double> c = {{(long double)p[0].x, (long double)p[0].y}, 0.0};

    for (int i = 1; i < p.size(); i++) {
        // 点 p[i] が現在の円の外側にある場合、円を更新
        if (distF(c.first, {(long double)p[i].x, (long double)p[i].y}) > c.second + 1e-9) {
            c = {{(long double)p[i].x, (long double)p[i].y}, 0.0}; // p[i] を中心とする半径0の円
            for (int j = 0; j < i; j++) {
                // 点 p[j] も外側にある場合、p[i] と p[j] を直径とする円に更新
                if (distF(c.first, {(long double)p[j].x, (long double)p[j].y}) > c.second + 1e-9) {
                    c = circle2(p[i], p[j]);
                    for (int k = 0; k < j; k++) {
                        // 点 p[k] も外側にある場合、3点を通る外接円に更新
                        if (distF(c.first, {(long double)p[k].x, (long double)p[k].y}) > c.second + 1e-9) {
                            c = circumcircle(p[i], p[j], p[k]);
                        }
                    }
                }
            }
        }
    }
    return c;
}

long long ng = -1;
long long ok = 1e18; // 条件を満たす十分大きな値

while (abs(ok - ng) > 1) { // ok - ng > 1 でも可
    long long mid = ng + (ok - ng) / 2;

    if (check(mid))
        ok = mid;
    else
        ng = mid;
}

long long ok = -1; // 条件を満たす十分小さな値
long long ng = 1e18;

while (abs(ok - ng) > 1) { // ng - ok > 1 でも可
    long long mid = ok + (ng - ok) / 2;

    if (check(mid))
        ok = mid;
    else
        ng = mid;
}

ll low = 0;
ll high = 1e18; // 探索範囲

while (high - low > 2) {
    ll m1 = low + (high - low) / 3;
    ll m2 = high - (high - low) / 3;

    if (f(m1) < f(m2)) // 上に凸（最大値探索）の場合は不等号を逆にする
        high = m2;
    else
        low = m1;
}

ll ans = low;
for (ll i = low + 1; i <= high; i++) {
    if (f(i) < f(ans)) ans = i; // 絞り込んだ範囲から全探索で最小を探す
}

ld low = 0.0;
ld high = 1e18; // 探索範囲
ll cnt = 100; // 許容誤差に応じた十分なループ回数

while (cnt--) {
    ld m1 = low + (high - low) / 3.0;
    ld m2 = high - (high - low) / 3.0;

    if (f(m1) < f(m2)) // 上に凸（最大値探索）の場合は不等号を逆にする
        high = m2;
    else
        low = m1;
}
// low または high が極値のx座標（必要なら f(low) が極値）

for (ll mask = 0; mask < (1LL << N); mask++) {

    for (ll i = 0; i < N; i++) {
        if (mask & (1LL << i)) {
            // 判定・計算をする
        }
    }
}

for (ll sub = S; ; sub = (sub - 1) & S) {
    // sub に対する判定・計算

    if (sub == 0) break; // 空集合(0)の処理を終えたら終了
}

for (ll sup = T; sup < (1LL << N); sup = (sup + 1) | T) {
    // sup に対する判定・計算
}

struct FixedBitEnumeration {
    ll N, K;

    FixedBitEnumeration(ll n, ll k) : N(n), K(k) {}

    // Nビットのうち1がK個立っているビットパターンを昇順列挙（Gosper's Hack）
    vector<ll> enumerate_masks() const {
        vector<ll> res;
        if (K < 0 || K > N) return res;
        if (K == 0) {
            res.push_back(0);
            return res;
        }

        ll cur = (1LL << K) - 1;
        while (cur < (1LL << N)) {
            res.push_back(cur);
            ll x = cur & -cur;
            ll y = cur + x;
            cur = (((cur ^ y) / x) >> 2) | y;
        }
        return res;
    }

    // 各パターンにおいて立っているビットのインデックス(0-indexed)のリストとして取得する
    vvl enumerate_indices() const {
        vl masks = enumerate_masks();
        vvl res;
        res.reserve(masks.size());
        for (ll mask : masks) {
            vl indices;
            for (ll i = 0; i < N; i++) {
                if ((mask >> i) & 1) indices.push_back(i);
            }
            res.push_back(indices);
        }
        return res;
    }
};

struct GrayCode {
    ll N;

    GrayCode(ll n) : N(n) {}

    // i 番目の Gray Code (i ^ (i >> 1)) を返す
    static ll get(ll i) {
        return i ^ (i >> 1);
    }

    // 2^N 通りの Gray Code の数値列挙を返す
    vector<ll> enumerate_masks() const {
        vector<ll> res(1LL << N);
        for (ll i = 0; i < (1LL << N); i++) {
            res[i] = get(i);
        }
        return res;
    }

    // 差分更新（1要素の追加/削除）を行いながら全探索を走査するコールバック駆動関数
    // add_fn(idx): idx番目の要素を追加
    // remove_fn(idx): idx番目の要素を削除
    // process_fn(): 現在の集合状態で判定・更新処理を行う
    template <typename AddFn, typename RemoveFn, typename ProcessFn>
    void run(AddFn add_fn, RemoveFn remove_fn, ProcessFn process_fn) const {
        ll cur_code = 0;
        process_fn(); // 初期状態 (空集合) の処理

        for (ll i = 1; i < (1LL << N); i++) {
            ll next_code = get(i);
            ll diff = cur_code ^ next_code;
            // 変化したビットの位置（下位から何ビット目か）を特定
            ll bit_idx = __builtin_ctzll(diff);

            if ((next_code >> bit_idx) & 1) {
                add_fn(bit_idx);
            } else {
                remove_fn(bit_idx);
            }
            process_fn();
            cur_code = next_code;
        }
    }
};

struct VectorEnumeration {
    ll N, K;

    VectorEnumeration(ll n, ll k) : N(n), K(k) {}

    // ベクトルの全列挙・昇順列挙を行う関数 (1 <= A_i <= N)
    // is_ascending: true の場合、広義単調増加 (A[i] <= A[i+1])
    // strict      : true の場合、狭義単調増加 (A[i] < A[i+1]) ※is_ascending=true 前提
    vector<vector<ll>> enumerate(bool is_ascending = false, bool strict = false) const {
        vector<vector<ll>> res;
        vector<ll> cur;

        auto dfs = [&](auto self, ll min_val) -> void {
            if ((ll)cur.size() == K) {
                res.push_back(cur);
                return;
            }
            ll start = is_ascending ? min_val : 1;
            for (ll i = start; i <= N; i++) {
                cur.push_back(i);
                ll next_min = strict ? i + 1 : i;
                self(self, next_min);
                cur.pop_back();
            }
        };

        dfs(dfs, 1);
        return res;
    }
};

template <typename T>
struct CartesianProduct {
    vector<vector<T>> groups;

    CartesianProduct(const vector<vector<T>>& g) : groups(g) {}

    // 複数ベクトルの直積（すべての組み合わせ）を全列挙する関数
    vector<vector<T>> enumerate() const {
        vector<vector<T>> res;
        vector<T> cur;

        auto dfs = [&](auto self, size_t depth) -> void {
            if (depth == groups.size()) {
                res.push_back(cur);
                return;
            }
            for (const auto& item : groups[depth]) {
                cur.push_back(item);
                self(self, depth + 1);
                cur.pop_back();
            }
        };

        dfs(dfs, 0);
        return res;
    }
};

sort(v.begin(), v.end());
do {
    // v を1通り処理
} while (next_permutation(v.begin(), v.end()));

struct IntegerPartition {
    ll N;

    IntegerPartition(ll n) : N(n) {}

    // Nの整数分割を降順/昇順形式で全列挙する関数
    // max_parts: 最大分割数（0の場合は制限なし）
    vector<vector<ll>> enumerate(ll max_parts = 0) const {
        vector<vector<ll>> res;
        vector<ll> cur;

        auto dfs = [&](auto self, ll rem, ll last_val) -> void {
            if (rem == 0) {
                res.push_back(cur);
                return;
            }
            if (max_parts > 0 && (ll)cur.size() == max_parts) return;

            // 重複を除外するため、前の値以下の整数のみを次に採用する（降順構成）
            ll upper = min(rem, last_val);
            for (ll i = upper; i >= 1; i--) {
                cur.push_back(i);
                self(self, rem - i, i);
                cur.pop_back();
            }
        };

        dfs(dfs, N, N);
        return res;
    }
};

struct SetPartition {
    ll N;

    SetPartition(ll n) : N(n) {}

    // 集合 {0, 1, ..., N-1} の分割全列挙
    // min_size   : 各グループの最小要素数 (デフォルト 1)
    // max_size   : 各グループの最大要素数 (-1 の場合は制限なし)
    // min_groups : 分割後の最小グループ数 (デフォルト 1)
    // max_groups : 分割後の最大グループ数 (-1 の場合は制限なし)
    vector<vector<vector<ll>>> enumerate(ll min_size = 1, ll max_size = -1, ll min_groups = 1, ll max_groups = -1) const {
        if (max_size == -1) max_size = N;
        if (max_groups == -1) max_groups = N;

        vector<vector<vector<ll>>> res;
        vector<vector<ll>> current_partition;

        auto dfs = [&](auto self, ll i) -> void {
            ll c = current_partition.size();
            
            // 枝刈り: 既存グループが最小サイズ(min_size)を満たすために必要な追加要素数
            ll needed_for_existing = 0;
            for (const auto& g : current_partition) {
                if ((ll)g.size() < min_size) {
                    needed_for_existing += min_size - (ll)g.size();
                }
            }
            
            // 枝刈り: グループ数の下限(min_groups)を満たすために新規作成すべきグループに必要な要素数
            ll needed_for_new = max(0LL, min_groups - c) * min_size;
            
            // 残りの全要素を使っても条件を満たせない場合は探索打ち切り
            if (needed_for_existing + needed_for_new > N - i) return;

            if (i == N) {
                res.push_back(current_partition);
                return;
            }

            // 1. 既存のグループのいずれかに追加する
            for (size_t g = 0; g < c; g++) {
                if ((ll)current_partition[g].size() < max_size) {
                    current_partition[g].push_back(i);
                    self(self, i + 1);
                    current_partition[g].pop_back();
                }
            }

            // 2. 新しいグループを作成して追加する
            // 現在のグループ数が上限(max_groups)に達していない場合のみ作成可能
            if (c < max_groups) {
                current_partition.push_back({i});
                self(self, i + 1);
                current_partition.pop_back();
            }
        };

        dfs(dfs, 0);
        return res;
    }
};

struct Mo {
    ll n;
    vector<pair<ll, ll>> lr;

    Mo(ll n) : n(n) {}

    // クエリを半開区間 [l, r) で追加
    void add_query(ll l, ll r) {
        lr.push_back({l, r});
    }

    // ヒルベルト曲線の順序を計算 (最大N, Qが10^6程度まで対応)
    static inline int64_t hilbert_order(ll x, ll y) {
        int64_t d = 0;
        for (ll s = 1 << 20; s > 0; s >>= 1) {
            ll rx = (x & s) > 0, ry = (y & s) > 0;
            d += (int64_t)(3 * rx ^ ry) * s * s;
            if (ry == 0) {
                if (rx == 1) {
                    x = (1 << 21) - 1 - x;
                    y = (1 << 21) - 1 - y;
                }
                swap(x, y);
            }
        }
        return d;
    }

    // 左端追加、右端追加、左端削除、右端削除、クエリ回答の関数を受け取る
    template<typename AL, typename AR, typename DL, typename DR, typename O>
    void build(AL add_left, AR add_right, DL del_left, DR del_right, O out) {
        ll q = lr.size();
        vector<int64_t> h_ord(q);
        for (ll i = 0; i < q; ++i) {
            h_ord[i] = hilbert_order(lr[i].first, lr[i].second);
        }

        vector<ll> ord(q);
        iota(ord.begin(), ord.end(), 0);
        sort(ord.begin(), ord.end(), [&](ll a, ll b) {
            return h_ord[a] < h_ord[b];
        });

        ll l = 0, r = 0;
        for (auto idx : ord) {
            // ※区間が反転しないよう「追加（区間を広げる）」を先に実行する
            while (l > lr[idx].first) add_left(--l);
            while (r < lr[idx].second) add_right(r++);
            while (l < lr[idx].first) del_left(l++);
            while (r > lr[idx].second) del_right(--r);
            out(idx);
        }
    }
};

struct TreeMo {
    Mo mo;
    vector<ll> node_at; // 括弧列の各時刻に対応する頂点番号
    struct Query {
        ll u, v, lca;
    };
    vector<Query> queries;

    // EulerTourのサイズ 2N を用いてMoを初期化
    TreeMo(const EulerTour& et) : mo(2 * et.n) {
        node_at.resize(2 * et.n);
        for (ll i = 0; i < et.n; ++i) {
            node_at[et.path_in[i]] = i;
            node_at[et.path_out[i]] = i;
        }
    }

    // パスクエリの追加 (uからvへのパス。LCAを外部で計算して渡す)
    void add_query(ll u, ll v, ll lca, const EulerTour& et) {
        if (et.path_in[u] > et.path_in[v]) swap(u, v);
        queries.push_back({u, v, lca});
        
        // LCAがuの場合（uがvの祖先）、パス上の頂点は [path_in[u], path_in[v]] に1回だけ出現する
        if (lca == u) {
            mo.add_query(et.path_in[u], et.path_in[v] + 1);
        } 
        // 異なる枝にある場合、パス上の頂点は [path_out[u], path_in[v]] に1回だけ出現する
        // ただしLCAはこの区間に含まれないため、実行時に別途足す必要がある
        else {
            mo.add_query(et.path_out[u], et.path_in[v] + 1);
        }
    }

    // flip: 頂点の有効/無効を切り替える関数, out: クエリ回答の関数
    template<typename F, typename O>
    void build(F flip, O out) {
        auto toggle = [&](ll idx) {
            flip(node_at[idx]); // 区間の端が動くたびに頂点の状態を反転
        };
        auto wrap_out = [&](ll q_idx) {
            ll lca = queries[q_idx].lca;
            // 異なる枝の場合、LCAが含まれていないので一時的に反転してパスに含める
            bool need_lca = (lca != queries[q_idx].u);
            if (need_lca) flip(lca);
            
            out(q_idx);
            
            // クエリ回答後、LCAの状態を元に戻す
            if (need_lca) flip(lca);
        };
        
        // 木上のMoは偶数回出現した頂点を無効化するため、追加・削除が全く同じ「反転(flip)操作」になる
        mo.build(toggle, toggle, toggle, toggle, wrap_out);
    }
};

struct HilbertOrder {
    ll lg;

    // 座標の取りうる範囲を [0, 2^lg) とする
    explicit HilbertOrder(ll n) {
        lg = 0;
        while ((1LL << lg) < n) ++lg;
    }

    // (x, y) をヒルベルト順序へ変換
    ll operator()(ll x, ll y) const {
        ll d = 0;

        for (ll s = 1LL << (lg - 1); s > 0; s >>= 1) {
            ll rx = (x & s) ? 1 : 0;
            ll ry = (y & s) ? 1 : 0;

            d += s * s * ((3 * rx) ^ ry);

            if (ry == 0) {
                if (rx == 1) {
                    x = (1LL << lg) - 1 - x;
                    y = (1LL << lg) - 1 - y;
                }
                swap(x, y);
            }
        }

        return d;
    }

    // 静的関数として直接使いたい場合
    static ll order(ll x, ll y, ll lg) {
        ll d = 0;

        for (ll s = 1LL << (lg - 1); s > 0; s >>= 1) {
            ll rx = (x & s) ? 1 : 0;
            ll ry = (y & s) ? 1 : 0;

            d += s * s * ((3 * rx) ^ ry);

            if (ry == 0) {
                if (rx == 1) {
                    x = (1LL << lg) - 1 - x;
                    y = (1LL << lg) - 1 - y;
                }
                swap(x, y);
            }
        }

        return d;
    }
};

// Union-Find の構造体
struct UnionFind {
    vector<ll> parent; // parent[i] は i の親要素。i が根（リーダー）の場合は -1
    vector<ll> siz;    // siz[i] は i を根とするグループの要素数

    // 構造体の初期化（要素数 N で作成）
    UnionFind(ll n) {
        parent.assign(n, -1); // 最初はみんな自分が根（-1）
        siz.assign(n, 1);     // 最初はみんなサイズ 1
    }

    // 1. Find: 要素 x の根（リーダー）を返す
    ll find(ll x) {
        if (parent[x] == -1) return x; // 自分が根なら自分を返す
        // 経路圧縮：親を「根」に直接繋ぎ変えながら再帰的に探す
        return parent[x] = find(parent[x]);
    }

    // 2. Union: 要素 x と要素 y のグループを合体させる
    bool unite(ll x, ll y) {
        // それぞれのリーダーを探す
        ll root_x = find(x);
        ll root_y = find(y);

        // すでに同じグループなら何もしない
        if (root_x == root_y) return false;

        // Union by Size: 小さい方を大きい方の下に合体させる
        if (siz[root_x] < siz[root_y]) {
            swap(root_x, root_y); // 常に root_x の方がサイズが大きくなるようにする
        }

        // root_y の親を root_x にする（root_x が新しいボス）
        parent[root_y] = root_x;
        siz[root_x] += siz[root_y]; // サイズを合算する
        return true;
    }

    // 3. Same: 要素 x と要素 y が同じグループに属するか判定
    bool same(ll x, ll y) {
        return find(x) == find(y);
    }

    // 4. Size: 要素 x が属するグループのサイズ（要素数）を返す
    ll size(ll x) {
        return siz[find(x)];
    }
};

// 重み付きUnion-Find の構造体
struct WeightedUnionFind {
    vector<ll> parent;      // parent[i] は i の親要素。i が根の場合は -1
    vector<ll> siz;         // siz[i] は i を根とするグループの要素数
    vector<ll> diff_weight; // 根からの距離（重み）

    // 構造体の初期化（要素数 N で作成）
    WeightedUnionFind(ll n) {
        parent.assign(n, -1);
        siz.assign(n, 1);
        diff_weight.assign(n, 0);
    }

    // 1. Find: 要素 x の根を返しつつ、経路圧縮で重みを更新
    ll find(ll x) {
        if (parent[x] == -1) return x;
        ll r = find(parent[x]);
        // 親の重みを足し合わせて根からの重みに更新
        diff_weight[x] += diff_weight[parent[x]];
        return parent[x] = r;
    }

    // 要素 x の根からの重みを返す
    ll weight(ll x) {
        find(x); // 経路圧縮を実行
        return diff_weight[x];
    }

    // 2. Relate: 要素 y が 要素 x より w 大きい (a_y - a_x = w) という情報で結合
    bool relate(ll x, ll y, ll w) {
        w += weight(x);
        w -= weight(y);
        ll root_x = find(x);
        ll root_y = find(y);

        if (root_x == root_y) return false;

        // Union by Size: 小さい方を大きい方に繋ぐ
        if (siz[root_x] < siz[root_y]) {
            swap(root_x, root_y);
            w = -w; // 繋ぐ方向が逆になるので重みも反転
        }

        parent[root_y] = root_x;
        siz[root_x] += siz[root_y];
        diff_weight[root_y] = w;
        return true;
    }

    // 3. Diff: 要素 x と 要素 y の差分 (a_y - a_x) を返す
    // ※事前に same(x, y) が true であるか確認すること
    ll diff(ll x, ll y) {
        return weight(y) - weight(x);
    }

    // 4. Same: 要素 x と要素 y が同じグループに属するか判定
    bool same(ll x, ll y) {
        return find(x) == find(y);
    }

    // 5. Size: 要素 x が属するグループのサイズ（要素数）を返す
    ll size(ll x) {
        return siz[find(x)];
    }
};

// Undo 付き Union-Find の構造体
struct UndoUnionFind {
    vector<ll> parent; // parent[i] は i の親要素。i が根（リーダー）の場合は -1
    vector<ll> siz;    // siz[i] は i を根とするグループの要素数
    stack<pair<ll, ll>> history; // 履歴を保存するスタック {子になったノード, 親の変更前のサイズ}

    // 構造体の初期化（要素数 N で作成）
    UndoUnionFind(ll n) {
        parent.assign(n, -1); // 最初はみんな自分が根（-1）
        siz.assign(n, 1);     // 最初はみんなサイズ 1
    }

    // 1. Find: 要素 x の根（リーダー）を返す
    ll find(ll x) {
        if (parent[x] == -1) return x; // 自分が根なら自分を返す
        // ※Undoができるように、経路圧縮は行わずに再帰（またはループ）で根を探す
        return find(parent[x]);
    }

    // 2. Union: 要素 x と要素 y のグループを合体させる
    bool unite(ll x, ll y) {
        // それぞれのリーダーを探す
        ll root_x = find(x);
        ll root_y = find(y);

        // すでに同じグループの場合
        if (root_x == root_y) {
            // 変化しなかった場合も、あとで undo() された際に回数を合わせるためダミーの履歴を積む
            history.push({-1, -1});
            return false;
        }

        // Union by Size: 小さい方を大きい方の下に合体させる
        if (siz[root_x] < siz[root_y]) {
            swap(root_x, root_y); // 常に root_x の方がサイズが大きくなるようにする
        }

        // 変更前の状態を履歴に保存: {子になる root_y, 親になる root_x の元のサイズ}
        history.push({root_y, siz[root_x]});

        // root_y の親を root_x にする（root_x が新しいボス）
        parent[root_y] = root_x;
        siz[root_x] += siz[root_y]; // サイズを合算する
        return true;
    }

    // 3. Undo: 直近の unite 操作を1つ取り消す
    void undo() {
        if (history.empty()) return; // 履歴がなければ何もしない
        auto [child, old_siz] = history.top();
        history.pop();

        // ダミー履歴（合体が発生しなかった unite の取り消し）の場合は何もしない
        if (child == -1) return;

        ll root = parent[child]; // 子の親（統合時の root_x）を取得
        parent[child] = -1;      // 子を根に戻す（木を切り離す）
        siz[root] = old_siz;     // 親のサイズを統合前の状態に戻す
    }

    // 4. Same: 要素 x と要素 y が同じグループに属するか判定
    bool same(ll x, ll y) {
        return find(x) == find(y);
    }

    // 5. Size: 要素 x が属するグループのサイズ（要素数）を返す
    ll size(ll x) {
        return siz[find(x)];
    }
};

// 部分永続 Union-Find の構造体
struct PartiallyPersistentUnionFind {
    vector<ll> parent; // 親要素
    vector<ll> time;   // 親が変更された時刻
    vector<vector<pair<ll, ll>>> siz; // siz[i] = { {時刻, サイズ}, ... } の履歴
    ll now; // 現在の時刻

    // 構造体の初期化（要素数 N で作成）
    PartiallyPersistentUnionFind(ll n) {
        parent.assign(n, -1);
        time.assign(n, 1e18); // 初期状態では親は変更されないため無限大
        siz.assign(n, {{0, 1}}); // 時刻 0 におけるサイズは 1
        now = 0;
    }

    // 1. Find: 時刻 t における要素 x の根を返す
    ll find(ll t, ll x) {
        if (time[x] > t) return x; // 時刻 t 時点では自分が根（あるいは親変更前）
        return find(t, parent[x]); // 経路圧縮は行わずに親を辿る
    }

    // 2. Union: 現在の時刻を進めつつ、要素 x と y を合体させる
    bool unite(ll x, ll y) {
        ++now; // 時刻を進める
        ll root_x = find(now, x);
        ll root_y = find(now, y);

        if (root_x == root_y) return false;

        // Union by Size
        if (siz[root_x].back().second < siz[root_y].back().second) {
            swap(root_x, root_y);
        }

        // root_y の親を root_x に変更し、その時刻を記録
        parent[root_y] = root_x;
        time[root_y] = now;

        // サイズの更新履歴を追加
        ll new_size = siz[root_x].back().second + siz[root_y].back().second;
        siz[root_x].push_back({now, new_size});
        
        return true;
    }

    // 3. Same: 時刻 t において要素 x と y が同じグループか判定
    bool same(ll t, ll x, ll y) {
        return find(t, x) == find(t, y);
    }

    // 4. Size: 時刻 t において要素 x が属するグループのサイズを返す
    ll size(ll t, ll x) {
        ll root_x = find(t, x);
        // 時刻 t 以下の最大の履歴を二分探索で探す
        auto it = prev(upper_bound(siz[root_x].begin(), siz[root_x].end(), make_pair(t, (ll)1e18)));
        return it->second;
    }

    // 5. TimeToConnect: 二分探索を用いて、要素 x と y が連結になった時刻を返す
    // 最終的に連結にならない場合は -1 を返す。計算量 O(log T log N)
    ll time_to_connect(ll x, ll y) {
        if (!same(now, x, y)) return -1;
        ll ok = now, ng = -1;
        while (abs(ok - ng) > 1) {
            ll mid = (ok + ng) / 2;
            if (same(mid, x, y)) {
                ok = mid;
            } else {
                ng = mid;
            }
        }
        return ok;
    }

};

// 前提 : 永続セグメント木

// 永続セグ木に渡すためのダミー関数 (演算は使用せず、配列アクセスとしてのみ利用)
ll op_uf(ll a, ll b) { return 0; }
ll e_uf() { return 0; }

// 完全永続 Union-Find の構造体
struct FullyPersistentUnionFind {
    PersistentSegmentTree<ll, op_uf, e_uf> seg;

    // 構造体の初期化（要素数 N で作成）
    // 値が負の場合は根であり、その絶対値がサイズを表す（初期値は全て -1）
    FullyPersistentUnionFind(ll n) : seg(n) {}

    // 初期状態のバージョン (root) を生成して返す
    ll build() {
        vector<ll> init_vec(seg.n, -1);
        return seg.build(init_vec);
    }

    // 内部用：バージョン root における配列の p 番目の値を取得
    // ※セグ木に get(root, p) が実装されていればそちらを使うと高速です
    ll get_val(ll root, ll p) {
        return seg.prod(root, p, p + 1);
    }

    // 1. Find: バージョン root における要素 x の根を返す
    ll find(ll root, ll x) {
        ll p = get_val(root, x);
        if (p < 0) return x; // 負の値なら自身が根
        return find(root, p); // 経路圧縮は行えない
    }

    // 2. Union: バージョン root の状態から要素 x と y を合体させた新しいバージョンを返す
    ll unite(ll root, ll x, ll y) {
        ll root_x = find(root, x);
        ll root_y = find(root, y);

        if (root_x == root_y) return root; // すでに同じグループならバージョンはそのまま

        ll size_x = -get_val(root, root_x);
        ll size_y = -get_val(root, root_y);

        // Union by Size
        if (size_x < size_y) {
            swap(root_x, root_y);
            swap(size_x, size_y);
        }

        // root_y の親を root_x に変更した新しい木を作成
        ll nroot = seg.update(root, root_y, root_x);
        // root_x のサイズを合算して更新
        nroot = seg.update(nroot, root_x, -(size_x + size_y));

        return nroot;
    }

    // 3. Same: バージョン root において要素 x と y が同じグループか判定
    bool same(ll root, ll x, ll y) {
        return find(root, x) == find(root, y);
    }

    // 4. Size: バージョン root において要素 x が属するグループのサイズを返す
    ll size(ll root, ll x) {
        return -get_val(root, find(root, x));
    }
};

template <typename T>
struct SequenceTree {
    struct Node {
        T val;
        unsigned int pri;
        int cnt;
        Node *l, *r;
        Node(T v, unsigned int p) : val(v), pri(p), cnt(1), l(nullptr), r(nullptr) {}
    };

    Node* root;
    mt19937 mt;

    SequenceTree() : root(nullptr), mt(random_device{}()) {}

    int count(Node* t) { return t ? t->cnt : 0; }

    Node* update(Node* t) {
        if (t) t->cnt = count(t->l) + count(t->r) + 1;
        return t;
    }

    void split(Node* t, int k, Node*& l, Node*& r) {
        if (!t) { l = r = nullptr; return; }
        int c = count(t->l);
        if (k <= c) {
            split(t->l, k, l, t->l);
            r = update(t);
        } else {
            split(t->r, k - c - 1, t->r, r);
            l = update(t);
        }
    }

    Node* merge(Node* l, Node* r) {
        if (!l || !r) return l ? l : r;
        if (l->pri > r->pri) {
            l->r = merge(l->r, r);
            return update(l);
        } else {
            r->l = merge(l, r->l);
            return update(r);
        }
    }

    // pos番目に val を挿入 (0-indexed)
    void insert(int pos, T val) {
        Node *l, *r;
        split(root, pos, l, r);
        root = merge(merge(l, new Node(val, mt())), r);
    }

    // pos番目の要素を削除 (0-indexed)
    void erase(int pos) {
        Node *l, *m, *r;
        split(root, pos, l, r);
        split(r, 1, m, r);
        delete m;
        root = merge(l, r);
    }

    // pos番目の要素にアクセス (0-indexed)
    T get(int pos) {
        Node* t = root;
        while (t) {
            int c = count(t->l);
            if (pos == c) return t->val;
            if (pos < c) t = t->l;
            else { pos -= c + 1; t = t->r; }
        }
        throw out_of_range("Index out of bounds");
    }
    
    // 現在の要素数を返す
    int size() { return count(root); }
};

template <class S, S (*op)(S, S), S (*e)(), S (*inv)(S)>
struct SqrtDecomp {
    ll N, B;
    vector<S> A, bucket;

    SqrtDecomp(ll n) : N(n) {
        B = max(1LL, (ll)sqrt(N));
        A.assign(N, e());
        bucket.assign((N + B - 1) / B, e());
    }
    
    SqrtDecomp(const vector<S>& v) : N(v.size()) {
        B = max(1LL, (ll)sqrt(N));
        A = v;
        bucket.assign((N + B - 1) / B, e());
        for (ll i = 0; i < N; i++) {
            bucket[i / B] = op(bucket[i / B], A[i]);
        }
    }

    // 点更新 O(1): p番目の要素を x に変更 (要 逆元)
    void set(ll p, S x) {
        bucket[p / B] = op(bucket[p / B], inv(A[p]));
        A[p] = x;
        bucket[p / B] = op(bucket[p / B], A[p]);
    }

    // 点加算 O(1): p番目の要素に x を作用させる (逆元不要)
    void add(ll p, S x) {
        A[p] = op(A[p], x);
        bucket[p / B] = op(bucket[p / B], x);
    }

    // 取得 O(1)
    S get(ll p) {
        return A[p];
    }

    // 区間クエリ O(√N): [l, r) の演算結果を取得
    S prod(ll l, ll r) {
        S res = e();
        while (l < r && l % B != 0) res = op(res, A[l++]);
        while (l < r && r % B != 0) res = op(res, A[--r]);
        for (ll i = l / B; i < r / B; i++) res = op(res, bucket[i]);
        return res;
    }
};

struct BIT {
    ll n;
    vector<long long> bit;
    BIT(ll n): n(n), bit(n + 1, 0) {}

    void add(ll idx, long long val) {
        for (++idx; idx <= n; idx += idx & -idx) bit[idx] += val;
    }

    long long sum(ll idx) { // [0, idx)
        long long s = 0;
        for (; idx > 0; idx -= idx & -idx) s += bit[idx];
        return s;
    }

    // 最小の idx (0-index) で sum(idx + 1) >= k を満たすものを返す
    // ※ bit に格納される値は非負であることが前提
    ll lower_bound(long long k) {
        if (k <= 0) return 0;

        ll idx = 0;
        ll pw = 1;
        while ((pw << 1) <= n) pw <<= 1;

        for (; pw > 0; pw >>= 1) {
            if (idx + pw <= n && bit[idx + pw] < k) {
                k -= bit[idx + pw];
                idx += pw;
            }
        }
        return idx;
    }
};

// 1. 型 S と、二項演算 op、単位元 e を定義する
ll op(ll a, ll b) { return max(a, b); }
ll e() { return -1e18; }

int main() {
    int N = 100000;
    
    // 2. 宣言 (初期値は全て e() になる)
    segtree<ll, op, e> seg(N);
    // vectorから構築する場合 O(N): segtree<ll, op, e> seg(vec);

    // 3. 点更新: p番目(0-indexed)の要素を x に更新
    seg.set(2, 15);

    // 4. 1点取得: p番目の要素を取得
    ll val = seg.get(2);

    // 5. 区間クエリ: [l, r) の演算結果を取得
    ll ans = seg.prod(0, 5);
    
    // 6. 全区間クエリ: [0, N) の演算結果を取得
    ll all_ans = seg.all_prod();
}

// 例：区間加算・区間最小値
using S = ll;
using F = ll;
const ll INF = 1e18;

S op(S a, S b) { return min(a, b); }
S e() { return INF; }
S mapping(F f, S x) { return f + x; }
F composition(F f, F g) { return f + g; } // 既存のgの上に新しいfを適用
F id() { return 0; }

int main() {
    int N = 100000;
    
    // 宣言
    lazy_segtree<S, op, e, F, mapping, composition, id> seg(N);
    // vectorから構築する場合 O(N): lazy_segtree<...> seg(vec);

    // 区間更新: [l, r) に作用素 x を適用
    seg.apply(0, 5, 10); // [0, 5) に 10 を加算
    
    // 1点更新: p番目に作用素 x を適用
    seg.apply(2, 5);

    // 区間クエリ: [l, r) の演算結果を取得
    ll ans = seg.prod(0, 5); // [0, 5) の最小値
}

template <class S, S (*op)(S, S), S (*e)()>
struct PersistentSegmentTree {
    struct Node {
        S val;
        ll l_ch, r_ch;
    };
    vector<Node> nodes;
    ll n;

    PersistentSegmentTree(ll n_) : n(n_) {}

    ll make_node(S val, ll l_ch = -1, ll r_ch = -1) {
        nodes.push_back({val, l_ch, r_ch});
        return (ll)nodes.size() - 1;
    }

    // [初期化用] 単位元 e() でサイズ n の完全二分木を構築 O(N)
    ll build(ll l, ll r) {
        if (r - l == 1) return make_node(e());
        ll mid = (l + r) / 2;
        ll nl = build(l, mid);
        ll nr = build(mid, r);
        return make_node(op(nodes[nl].val, nodes[nr].val), nl, nr);
    }
    ll build() { return build(0, n); }

    // [初期化用] 配列から初期木を構築 O(N)
    ll build(const vector<S>& v, ll l, ll r) {
        if (r - l == 1) return make_node(v[l]);
        ll mid = (l + r) / 2;
        ll nl = build(v, l, mid);
        ll nr = build(v, mid, r);
        return make_node(op(nodes[nl].val, nodes[nr].val), nl, nr);
    }
    ll build(const vector<S>& v) { return build(v, 0, n); }

    // [更新] バージョン root をベースに、p 番目を x に更新した新バージョンを返す O(log N)
    ll update(ll root, ll p, S x, ll l, ll r) {
        if (r - l == 1) return make_node(x);
        ll mid = (l + r) / 2;
        ll nl = nodes[root].l_ch, nr = nodes[root].r_ch;
        if (p < mid) nl = update(nl, p, x, l, mid);
        else         nr = update(nr, p, x, mid, r);
        return make_node(op(nodes[nl].val, nodes[nr].val), nl, nr);
    }
    ll update(ll root, ll p, S x) { return update(root, p, x, 0, n); }

    // [区間コピー] バージョン root_dst の区間 [ql, qr) を、バージョン root_src の区間 [ql, qr) の状態で上書きした新バージョンを返す O(log N)
    ll copy_range(ll root_src, ll root_dst, ll ql, ll qr, ll l, ll r) {
        if (qr <= l || r <= ql) return root_dst;
        if (ql <= l && r <= qr) return root_src;
        ll mid = (l + r) / 2;
        ll nl = copy_range(nodes[root_src].l_ch, nodes[root_dst].l_ch, ql, qr, l, mid);
        ll nr = copy_range(nodes[root_src].r_ch, nodes[root_dst].r_ch, ql, qr, mid, r);
        return make_node(op(nodes[nl].val, nodes[nr].val), nl, nr);
    }
    ll copy_range(ll root_src, ll root_dst, ll ql, ll qr) { 
        return copy_range(root_src, root_dst, ql, qr, 0, n); 
    }

    // [取得] バージョン root における区間 [ql, qr) の演算結果を返す O(log N)
    S prod(ll root, ll ql, ll qr, ll l, ll r) {
        if (qr <= l || r <= ql) return e();
        if (ql <= l && r <= qr) return nodes[root].val;
        ll mid = (l + r) / 2;
        S vl = prod(nodes[root].l_ch, ql, qr, l, mid);
        S vr = prod(nodes[root].r_ch, ql, qr, mid, r);
        return op(vl, vr);
    }
    S prod(ll root, ll ql, ll qr) { return prod(root, ql, qr, 0, n); }

    // [二分探索] バージョン root において、f(op(a[ql], ..., a[r-1])) が true となる最大の r を返す O(log N)
    template <class F>
    ll max_right(ll root, ll ql, F f, ll l, ll r, S& sm) {
        if (r <= ql) return r;
        if (ql <= l && f(op(sm, nodes[root].val))) {
            sm = op(sm, nodes[root].val);
            return r;
        }
        if (r - l == 1) return l;
        ll mid = (l + r) / 2;
        ll res_l = max_right(nodes[root].l_ch, ql, f, l, mid, sm);
        if (res_l < mid) return res_l;
        return max_right(nodes[root].r_ch, ql, f, mid, r, sm);
    }
    template <class F>
    ll max_right(ll root, ll ql, F f) {
        S sm = e();
        return max_right(root, ql, f, 0, n, sm);
    }

    // [二分探索] バージョン root において、f(op(a[l], ..., a[qr-1])) が true となる最小の l を返す O(log N)
    template <class F>
    ll min_left(ll root, ll qr, F f, ll l, ll r, S& sm) {
        if (qr <= l) return l;
        if (r <= qr && f(op(nodes[root].val, sm))) {
            sm = op(nodes[root].val, sm);
            return l;
        }
        if (r - l == 1) return r;
        ll mid = (l + r) / 2;
        ll res_r = min_left(nodes[root].r_ch, qr, f, mid, r, sm);
        if (res_r > mid) return res_r;
        return min_left(nodes[root].l_ch, qr, f, l, mid, sm);
    }
    template <class F>
    ll min_left(ll root, ll qr, F f) {
        S sm = e();
        return min_left(root, qr, f, 0, n, sm);
    }

    // [応用・二分探索] 2つのバージョン (root_l, root_r) の差分木上で、左から k 番目(0-indexed)の要素の位置を返す O(log N)
    // ※ S が整数型で、op が加算(+)として定義されている（頻度配列として使っている）場合のみ有効
    ll kth_smallest(ll root_l, ll root_r, ll k, ll l, ll r) {
        if (r - l == 1) return l;
        ll mid = (l + r) / 2;
        ll count_l = nodes[nodes[root_r].l_ch].val - nodes[nodes[root_l].l_ch].val;
        if (k < count_l) {
            return kth_smallest(nodes[root_l].l_ch, nodes[root_r].l_ch, k, l, mid);
        } else {
            return kth_smallest(nodes[root_l].r_ch, nodes[root_r].r_ch, k - count_l, mid, r);
        }
    }
    ll kth_smallest(ll root_l, ll root_r, ll k) {
        return kth_smallest(root_l, root_r, k, 0, n);
    }
};

template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S), F (*composition)(F, F), F (*id)()>
struct PersistentLazySegmentTree {
    struct Node {
        S val;
        F lazy;
        ll l_ch, r_ch;
    };
    vector<Node> nodes;
    ll n;

    PersistentLazySegmentTree(ll n_) : n(n_) {}

    ll make_node(S val, F lazy, ll l_ch = -1, ll r_ch = -1) {
        nodes.push_back({val, lazy, l_ch, r_ch});
        return (ll)nodes.size() - 1;
    }

    // [初期化用] 完全二分木の構築
    ll build(ll l, ll r) {
        if (r - l == 1) return make_node(e(), id());
        ll mid = (l + r) / 2;
        ll nl = build(l, mid);
        ll nr = build(mid, r);
        return make_node(op(nodes[nl].val, nodes[nr].val), id(), nl, nr);
    }
    ll build() { return build(0, n); }

    ll build(const vector<S>& v, ll l, ll r) {
        if (r - l == 1) return make_node(v[l], id());
        ll mid = (l + r) / 2;
        ll nl = build(v, l, mid);
        ll nr = build(v, mid, r);
        return make_node(op(nodes[nl].val, nodes[nr].val), id(), nl, nr);
    }
    ll build(const vector<S>& v) { return build(v, 0, n); }

    // [内部処理] 遅延タグを子に押し出し、新しい子ノードを生成する（update時のみ使用）
    ll push(ll root, ll l, ll r) {
        if (nodes[root].lazy == id() || r - l == 1) return root;
        ll nl = nodes[root].l_ch;
        ll nr = nodes[root].r_ch;

        S l_val = mapping(nodes[root].lazy, nodes[nl].val);
        F l_lazy = composition(nodes[root].lazy, nodes[nl].lazy);
        nl = make_node(l_val, l_lazy, nodes[nl].l_ch, nodes[nl].r_ch);

        S r_val = mapping(nodes[root].lazy, nodes[nr].val);
        F r_lazy = composition(nodes[root].lazy, nodes[nr].lazy);
        nr = make_node(r_val, r_lazy, nodes[nr].l_ch, nodes[nr].r_ch);

        // 親ノードの遅延タグは消化されたので id() にして再構成
        return make_node(nodes[root].val, id(), nl, nr);
    }

    // [更新] バージョン root をベースに、区間 [ql, qr) に操作 f を適用
    ll update(ll root, ll ql, ll qr, F f, ll l, ll r) {
        if (qr <= l || r <= ql) return root;
        if (ql <= l && r <= qr) {
            S new_val = mapping(f, nodes[root].val);
            F new_lazy = composition(f, nodes[root].lazy);
            return make_node(new_val, new_lazy, nodes[root].l_ch, nodes[root].r_ch);
        }
        // 既存のタグを子に押し出してから分岐する
        ll pushed_root = push(root, l, r);
        ll mid = (l + r) / 2;
        ll nl = update(nodes[pushed_root].l_ch, ql, qr, f, l, mid);
        ll nr = update(nodes[pushed_root].r_ch, ql, qr, f, mid, r);
        return make_node(op(nodes[nl].val, nodes[nr].val), id(), nl, nr);
    }
    ll update(ll root, ll ql, ll qr, F f) { return update(root, ql, qr, f, 0, n); }

    // [取得] バージョン root における区間 [ql, qr) の演算結果
    // ※ メモリ爆発を防ぐため、pushは行わずタグを lazy_acc として「持ち下げる」
    S prod(ll root, ll ql, ll qr, ll l, ll r, F lazy_acc) {
        if (qr <= l || r <= ql) return e();
        // 親から持ち下ろしてきたタグと、現在のノードのタグを合成
        F cur_lazy = composition(lazy_acc, nodes[root].lazy);
        
        if (ql <= l && r <= qr) {
            return mapping(cur_lazy, nodes[root].val);
        }
        ll mid = (l + r) / 2;
        S vl = prod(nodes[root].l_ch, ql, qr, l, mid, cur_lazy);
        S vr = prod(nodes[root].r_ch, ql, qr, mid, r, cur_lazy);
        return op(vl, vr);
    }
    S prod(ll root, ll ql, ll qr) { return prod(root, ql, qr, 0, n, id()); }
};

class SegmentTreeBeats {
    static const long long INF = 1e18;
    int n, sz;
    vector max_v, smax_v, max_c;
    vector min_v, smin_v, min_c;
    vector sum, len, lazy_add;

    void update_node_max(int k, long long x) {
        sum[k] += (x - max_v[k]) * max_c[k];
        if (max_v[k] == min_v[k]) { max_v[k] = min_v[k] = x; }
        else if (max_v[k] == smin_v[k]) { max_v[k] = smin_v[k] = x; }
        else { max_v[k] = x; }
    }
    void update_node_min(int k, long long x) {
        sum[k] += (x - min_v[k]) * min_c[k];
        if (max_v[k] == min_v[k]) { max_v[k] = min_v[k] = x; }
        else if (smax_v[k] == min_v[k]) { min_v[k] = smax_v[k] = x; }
        else { min_v[k] = x; }
    }
    void update_node_add(int k, long long x) {
        max_v[k] += x; if (smax_v[k] != -INF) smax_v[k] += x;
        min_v[k] += x; if (smin_v[k] != INF) smin_v[k] += x;
        sum[k] += x * len[k]; lazy_add[k] += x;
    }
    void push(int k) {
        if (lazy_add[k] != 0) {
            update_node_add(2 * k + 1, lazy_add[k]);
            update_node_add(2 * k + 2, lazy_add[k]);
            lazy_add[k] = 0;
        }
        if (max_v[k] < max_v[2 * k + 1]) update_node_max(2 * k + 1, max_v[k]);
        if (max_v[k] < max_v[2 * k + 2]) update_node_max(2 * k + 2, max_v[k]);
        if (min_v[k] > min_v[2 * k + 1]) update_node_min(2 * k + 1, min_v[k]);
        if (min_v[k] > min_v[2 * k + 2]) update_node_min(2 * k + 2, min_v[k]);
    }
    void update(int k) {
        sum[k] = sum[2 * k + 1] + sum[2 * k + 2];
        if (max_v[2 * k + 1] < max_v[2 * k + 2]) {
            max_v[k] = max_v[2 * k + 2];
            max_c[k] = max_c[2 * k + 2];
            smax_v[k] = max(max_v[2 * k + 1], smax_v[2 * k + 2]);
        } else if (max_v[2 * k + 1] > max_v[2 * k + 2]) {
            max_v[k] = max_v[2 * k + 1];
            max_c[k] = max_c[2 * k + 1];
            smax_v[k] = max(smax_v[2 * k + 1], max_v[2 * k + 2]);
        } else {
            max_v[k] = max_v[2 * k + 1];
            max_c[k] = max_c[2 * k + 1] + max_c[2 * k + 2];
            smax_v[k] = max(smax_v[2 * k + 1], smax_v[2 * k + 2]);
        }
        if (min_v[2 * k + 1] < min_v[2 * k + 2]) {
            min_v[k] = min_v[2 * k + 1];
            min_c[k] = min_c[2 * k + 1];
            smin_v[k] = min(smin_v[2 * k + 1], min_v[2 * k + 2]);
        } else if (min_v[2 * k + 1] > min_v[2 * k + 2]) {
            min_v[k] = min_v[2 * k + 2];
            min_c[k] = min_c[2 * k + 2];
            smin_v[k] = min(min_v[2 * k + 1], smin_v[2 * k + 2]);
        } else {
            min_v[k] = min_v[2 * k + 1];
            min_c[k] = min_c[2 * k + 1] + min_c[2 * k + 2];
            smin_v[k] = min(smin_v[2 * k + 1], smin_v[2 * k + 2]);
        }
    }

    void _update_chmin(int a, int b, long long x, int k, int l, int r) {
        if (b <= l || r <= a || max_v[k] <= x) return;
        if (a <= l && r <= b && smax_v[k] < x) { update_node_max(k, x); return; }
        push(k);
        _update_chmin(a, b, x, 2 * k + 1, l, (l + r) / 2);
        _update_chmin(a, b, x, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }
    void _update_chmax(int a, int b, long long x, int k, int l, int r) {
        if (b <= l || r <= a || min_v[k] >= x) return;
        if (a <= l && r <= b && smin_v[k] > x) { update_node_min(k, x); return; }
        push(k);
        _update_chmax(a, b, x, 2 * k + 1, l, (l + r) / 2);
        _update_chmax(a, b, x, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }
    void _update_add(int a, int b, long long x, int k, int l, int r) {
        if (b <= l || r <= a) return;
        if (a <= l && r <= b) { update_node_add(k, x); return; }
        push(k);
        _update_add(a, b, x, 2 * k + 1, l, (l + r) / 2);
        _update_add(a, b, x, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }
    void _update_modulo(int a, int b, long long x, int k, int l, int r) {
        if (b <= l || r <= a || max_v[k] < x) return;
        if (l + 1 == r) {
            long long val = max_v[k] % x;
            max_v[k] = min_v[k] = sum[k] = val;
            return;
        }
        push(k);
        _update_modulo(a, b, x, 2 * k + 1, l, (l + r) / 2);
        _update_modulo(a, b, x, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }
    void _update_divide(int a, int b, long long x, int k, int l, int r) {
        if (b <= l || r <= a) return;
        long long diff_max = max_v[k] - (long long)floor((double)max_v[k] / x);
        long long diff_min = min_v[k] - (long long)floor((double)min_v[k] / x);
        if (a <= l && r <= b && diff_max == diff_min) { update_node_add(k, -diff_max); return; }
        push(k);
        _update_divide(a, b, x, 2 * k + 1, l, (l + r) / 2);
        _update_divide(a, b, x, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }
    long long _query_sum(int a, int b, int k, int l, int r) {
        if (b <= l || r <= a) return 0;
        if (a <= l && r <= b) return sum[k];
        push(k);
        long long vl = _query_sum(a, b, 2 * k + 1, l, (l + r) / 2);
        long long vr = _query_sum(a, b, 2 * k + 2, (l + r) / 2, r);
        return vl + vr;
    }

public:
    SegmentTreeBeats(int n_) {
        n = n_; sz = 1; while (sz < n) sz *= 2;
        max_v.assign(2 * sz - 1, -INF); smax_v.assign(2 * sz - 1, -INF); max_c.assign(2 * sz - 1, 0);
        min_v.assign(2 * sz - 1, INF); smin_v.assign(2 * sz - 1, INF); min_c.assign(2 * sz - 1, 0);
        sum.assign(2 * sz - 1, 0); len.assign(2 * sz - 1, 0); lazy_add.assign(2 * sz - 1, 0);
    }
    void build(const vector& v) {
        for (int i = 0; i < n; i++) {
            max_v[sz - 1 + i] = min_v[sz - 1 + i] = sum[sz - 1 + i] = v[i];
            max_c[sz - 1 + i] = min_c[sz - 1 + i] = len[sz - 1 + i] = 1;
        }
        for (int i = sz - 2; i >= 0; i--) {
            len[i] = len[2 * i + 1] + len[2 * i + 2];
            update(i);
        }
    }
    void update_chmin(int a, int b, long long x) { _update_chmin(a, b, x, 0, 0, sz); }
    void update_chmax(int a, int b, long long x) { _update_chmax(a, b, x, 0, 0, sz); }
    void update_add(int a, int b, long long x) { _update_add(a, b, x, 0, 0, sz); }
    void update_modulo(int a, int b, long long x) { _update_modulo(a, b, x, 0, 0, sz); }
    void update_divide(int a, int b, long long x) { _update_divide(a, b, x, 0, 0, sz); }
    long long query_sum(int a, int b) { return _query_sum(a, b, 0, 0, sz); }
};

// 共通の直線構造体
const long long LCT_INF = 4e18; // 最小値クエリの初期値（十分大きい値）

struct Line {
    long long a, b;
    Line(long long a = 0, long long b = LCT_INF) : a(a), b(b) {}
    long long get(long long x) const { return a * x + b; }
};

// ====================================================================
// 1. 動的 Li Chao Tree (値域が広くてもそのまま使える。線分追加も可能)
// ====================================================================
struct DynamicLiChaoTree {
    struct Node {
        Line line;
        int left, right; // 子ノードの配列インデックス
        Node() : line(Line()), left(-1), right(-1) {}
    };
    
    vector<Node> nodes;
    long long min_x, max_x;

    // xの定義域 [min_x, max_x) を指定して初期化
    DynamicLiChaoTree(long long min_x = -1e9, long long max_x = 1e9 + 1) : min_x(min_x), max_x(max_x) {
        nodes.emplace_back();
    }

    // 直線の追加: y = ax + b
    void add_line(long long a, long long b) {
        update_line(0, min_x, max_x, Line(a, b));
    }

    // 線分の追加: x が [l, r) の範囲でのみ有効な y = ax + b
    void add_segment(long long a, long long b, long long l, long long r) {
        update_segment(0, min_x, max_x, l, r, Line(a, b));
    }

    // x における最小値の取得
    long long query(long long x) {
        long long res = LCT_INF;
        int idx = 0;
        long long l = min_x, r = max_x;
        while (idx != -1) {
            long long m = l + (r - l) / 2;
            res = min(res, nodes[idx].line.get(x));
            if (x < m) {
                idx = nodes[idx].left;
                r = m;
            } else {
                idx = nodes[idx].right;
                l = m;
            }
        }
        return res;
    }

private:
    void update_line(int idx, long long l, long long r, Line new_line) {
        long long m = l + (r - l) / 2;
        bool left_lower = new_line.get(l) < nodes[idx].line.get(l);
        bool mid_lower = new_line.get(m) < nodes[idx].line.get(m);
        bool right_lower = new_line.get(r - 1) < nodes[idx].line.get(r - 1);

        if (mid_lower) swap(nodes[idx].line, new_line);
        if (r - l <= 1) return;

        if (left_lower != mid_lower) {
            if (nodes[idx].left == -1) {
                nodes[idx].left = nodes.size();
                nodes.emplace_back();
            }
            update_line(nodes[idx].left, l, m, new_line);
        } else if (right_lower != mid_lower) {
            if (nodes[idx].right == -1) {
                nodes[idx].right = nodes.size();
                nodes.emplace_back();
            }
            update_line(nodes[idx].right, m, r, new_line);
        }
    }

    void update_segment(int idx, long long l, long long r, long long a, long long b, Line new_line) {
        if (b <= l || r <= a) return;
        if (a <= l && r <= b) {
            update_line(idx, l, r, new_line);
            return;
        }
        long long m = l + (r - l) / 2;
        if (a < m) {
            if (nodes[idx].left == -1) {
                nodes[idx].left = nodes.size();
                nodes.emplace_back();
            }
            update_segment(nodes[idx].left, l, m, a, b, new_line);
        }
        if (m < b) {
            if (nodes[idx].right == -1) {
                nodes[idx].right = nodes.size();
                nodes.emplace_back();
            }
            update_segment(nodes[idx].right, m, r, a, b, new_line);
        }
    }
};

// ====================================================================
// 2. 静的 Li Chao Tree (事前座標圧縮版・メモリ節約・定数倍高速)
// ====================================================================
struct StaticLiChaoTree {
    int n;
    vector<long long> xs;
    vector<Line> nodes;

    // クエリで飛んでくる可能性のある全ての x 座標リスト(未ソートでOK)を渡す
    StaticLiChaoTree(const vector<long long>& xs_in) {
        xs = xs_in;
        sort(xs.begin(), xs.end());
        xs.erase(unique(xs.begin(), xs.end()), xs.end());
        n = 1;
        while (n < (int)xs.size()) n *= 2;
        while ((int)xs.size() < n) xs.push_back(xs.back() + 1); // 2の冪乗になるようダミー追加
        nodes.assign(2 * n, Line());
    }

    // 直線の追加: y = ax + b
    void add_line(long long a, long long b) {
        update_line(1, 0, n, Line(a, b));
    }

    // 線分の追加: 実際の x 座標 [l_x, r_x) で有効な y = ax + b
    void add_segment(long long a, long long b, long long l_x, long long r_x) {
        int l = lower_bound(xs.begin(), xs.end(), l_x) - xs.begin();
        int r = lower_bound(xs.begin(), xs.end(), r_x) - xs.begin();
        update_segment(1, 0, n, l, r, Line(a, b));
    }

    // x における最小値の取得
    long long query(long long x) {
        int idx = lower_bound(xs.begin(), xs.end(), x) - xs.begin();
        idx += n;
        long long res = LCT_INF;
        while (idx > 0) {
            res = min(res, nodes[idx].get(x)); // 計算時のみリアルの x 座標を使用
            idx /= 2;
        }
        return res;
    }

private:
    void update_line(int k, int l, int r, Line new_line) {
        int m = (l + r) / 2;
        long long x_m = xs[m], x_l = xs[l], x_r = xs[r - 1];
        bool left_lower = new_line.get(x_l) < nodes[k].get(x_l);
        bool mid_lower = new_line.get(x_m) < nodes[k].get(x_m);
        bool right_lower = new_line.get(x_r) < nodes[k].get(x_r);

        if (mid_lower) swap(nodes[k], new_line);
        if (r - l <= 1) return;

        if (left_lower != mid_lower) {
            update_line(2 * k, l, m, new_line);
        } else if (right_lower != mid_lower) {
            update_line(2 * k + 1, m, r, new_line);
        }
    }

    void update_segment(int k, int l, int r, int a, int b, Line new_line) {
        if (b <= l || r <= a) return;
        if (a <= l && r <= b) {
            update_line(k, l, r, new_line);
            return;
        }
        int m = (l + r) / 2;
        update_segment(2 * k, l, m, a, b, new_line);
        update_segment(2 * k + 1, m, r, a, b, new_line);
    }
};

// ===== BFS =====
// start から各頂点への最短距離(辺数)を求める
vector<ll> bfs(const vector<vector<ll>>& graph, ll start) {
    ll n = graph.size();

    vector<ll> dist(n, -1);
    queue<ll> q;

    dist[start] = 0;
    q.push(start);

    while (!q.empty()) {
        ll v = q.front();
        q.pop();

        for (ll next : graph[v]) {
            if (dist[next] != -1) continue;

            dist[next] = dist[v] + 1;
            q.push(next);
        }
    }

    return dist;
}

// ===== DFS (再帰) =====
void dfs(const vector<vector<ll>>& graph,
         vector<bool>& seen,
         ll v) {

    seen[v] = true;

    for (ll next : graph[v]) {
        if (seen[next]) continue;
        dfs(graph, seen, next);
    }
}

// 呼び出し例
int main() {
    vector<vector<ll>> graph = {
        {1, 2},     // 0
        {0, 3},     // 1
        {0, 3},     // 2
        {1, 2, 4},  // 3
        {3}         // 4
    };

    // BFS
    vector<ll> dist = bfs(graph, 0);

    // DFS
    vector<bool> seen(graph.size(), false);
    dfs(graph, seen, 0);
}

// 閉路が存在すればその頂点列 (例: {u, v, w, u}) を返す。存在しなければ空配列を返す。
// restore = false にすると復元を行わず高速に判定のみを行う (閉路ありなら要素数1の配列を返す)。
vector<ll> find_cycle(const vector<vector<ll>> &graph, bool restore = true) {
    ll n = graph.size();
    vector<int> state(n, 0); // 0: 未訪問, 1: 訪問中, 2: 訪問済
    vector<ll> parent(n, -1);
    vector<ll> cycle;

    auto dfs = [&](auto self, ll v) -> bool {
        state[v] = 1;
        for (ll next : graph[v]) {
            if (state[next] == 1) { // バックエッジ検出（閉路存在）
                if (restore) {
                    ll curr = v;
                    while (curr != next) {
                        cycle.push_back(curr);
                        curr = parent[curr];
                    }
                    cycle.push_back(next);
                    reverse(cycle.begin(), cycle.end());
                    cycle.push_back(next); // 始点と終点を合わせる
                } else {
                    cycle.push_back(-1); // 検出判定用のダミー値
                }
                return true;
            } else if (state[next] == 0) {
                parent[next] = v;
                if (self(self, next)) return true;
            }
        }
        state[v] = 2;
        return false;
    };

    for (ll i = 0; i < n; i++) {
        if (state[i] == 0) {
            if (dfs(dfs, i)) return cycle;
        }
    }
    return {};
}

vector<ll> zero_one_BFS(ll N, ll start, vector<vector<pair<ll, ll>>> G) {
  // 隣接リストGは{頂点番号,重み(0または1)}で与えている
  vector<ll> dist(N, INF);
  deque<ll> todo;
  todo.push_back(start);
  dist[start] = 0;

  while (todo.empty() == false) {
    ll m = todo.front();
    todo.pop_front();

    rep(i, G[m].size()) {
      ll to = G[m][i].first;
      ll cost = G[m][i].second;

      if (dist[m] + cost < dist[to]) {
        dist[to] = dist[m] + cost;
        if (cost == 0) {
          todo.push_front(to);
        } else {
          todo.push_back(to);
        }
      }
    }
  }
  return dist;
}

vector<ll> Dijkstra(ll N, ll start, vector<vector<pair<ll, ll>>>& G) {
  // 隣接リストGは{頂点番号,重み}で与えている
  vector<ll> dist(N, INF);
  priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> todo;
  todo.push({0, start});
  dist[start] = 0;

  while (todo.empty() == false) {
    ll d = todo.top().first;
    ll m = todo.top().second;
    todo.pop();

    // 古い状態を無視（必須）
    if (d > dist[m]) {
      continue;
    }

    rep(i, G[m].size()) {
      ll next_v = G[m][i].first;
      ll cost = G[m][i].second;
      if (d + cost < dist[next_v]) {
        dist[next_v] = d + cost;
        todo.push({dist[next_v], next_v});
      }
    }
  }
  return dist;
}

struct Edge {
  ll from;
  ll to;
  ll cost;
};

// 戻り値: 最短距離の配列。ただし負の閉路から到達可能な頂点の距離は -INF とする
// グラフ全体に負の閉路があるかどうかは、返った後に dist の変化やフラグ等で判定可能
vector<ll> BellmanFord(ll N, ll start, vector<Edge> edges, bool &has_negative_cycle) {
  vector<ll> dist(N, INF);
  dist[start] = 0;
  has_negative_cycle = false;

  // 1. 最大 N-1 回の緩和処理で最短路を確定させる
  rep(i, N - 1) {
    for (const auto& e : edges) {
      if (dist[e.from] != INF && dist[e.from] + e.cost < dist[e.to]) {
        dist[e.to] = dist[e.from] + e.cost;
      }
    }
  }

  // 2. 負の閉路の検出と、閉路から到達可能な頂点のマーク
  // さらに N 回ループを回すことで、負の閉路の影響を受ける頂点を確実に -INF に落とす
  rep(i, N) {
    for (const auto& e : edges) {
      if (dist[e.from] != INF && dist[e.from] + e.cost < dist[e.to]) {
        dist[e.to] = -INF;
        has_negative_cycle = true;
      }
    }
  }

  return dist;
}

void WarshallFloyd(ll N, vector<vector<ll>> &dist) {
  // dist[i][j] は頂点iからjへの辺の重み。初期値は dist[i][i] = 0、経路がない場合は INF
  rep(k, N) {
    rep(i, N) {
      rep(j, N) {
        if (dist[i][k] != INF && dist[k][j] != INF) {
          dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
        }
      }
    }
  }
}

template<typename T = long long>
struct UshiGame {
    int n;
    struct Edge { int to; T cost; };
    // 最短経路用と最長経路用でグラフを分ける
    vector<vector<Edge>> g_max, g_min;
    const T INF = numeric_limits<T>::max() / 2;

    UshiGame(int n) : n(n), g_max(n), g_min(n) {}

    // x_v - x_u <= w (上限制約) を追加
    void add_leq(int u, int v, T w) {
        // max化(最短経路): x_v <= x_u + w
        g_max[u].push_back({v, w});
        // min化(最長経路): x_u >= x_v - w
        g_min[v].push_back({u, -w});
    }

    // x_v - x_u >= w (下限制約) を追加
    void add_geq(int u, int v, T w) {
        // max化(最短経路): x_u <= x_v - w
        g_max[v].push_back({u, -w});
        // min化(最長経路): x_v >= x_u + w
        g_min[u].push_back({v, w});
    }

    // x_v - x_u == w (等号制約) を追加
    void add_eq(int u, int v, T w) {
        add_leq(u, v, w);
        add_geq(u, v, w);
    }

    // ==========================================
    // SPFAモード (負の辺・負閉路検出に対応)
    // ==========================================
    
    // max化(最短経路): x_s を 0 としたときの各変数の最大値(上限)を求める
    // 戻り値: {矛盾がないか(負閉路なし), 距離配列}
    pair<bool, vector<T>> build_max(int s) {
        vector<T> dist(n, INF);
        dist[s] = 0;
        vector<int> count(n, 0);
        vector<bool> in_queue(n, false);
        queue<int> q;
        q.push(s);
        in_queue[s] = true;
        
        while (!q.empty()) {
            int u = q.front(); q.pop();
            in_queue[u] = false;
            for (auto& edge : g_max[u]) {
                if (dist[u] != INF && dist[edge.to] > dist[u] + edge.cost) {
                    dist[edge.to] = dist[u] + edge.cost;
                    if (!in_queue[edge.to]) {
                        q.push(edge.to);
                        in_queue[edge.to] = true;
                        if (++count[edge.to] >= n) return {false, {}}; // 負閉路
                    }
                }
            }
        }
        return {true, dist};
    }

    // min化(最長経路): x_s を 0 としたときの各変数の最小値(下限)を求める
    // 戻り値: {矛盾がないか(正閉路なし), 距離配列}
    pair<bool, vector<T>> build_min(int s) {
        vector<T> dist(n, -INF);
        dist[s] = 0;
        vector<int> count(n, 0);
        vector<bool> in_queue(n, false);
        queue<int> q;
        q.push(s);
        in_queue[s] = true;
        
        while (!q.empty()) {
            int u = q.front(); q.pop();
            in_queue[u] = false;
            for (auto& edge : g_min[u]) {
                if (dist[u] != -INF && dist[edge.to] < dist[u] + edge.cost) {
                    dist[edge.to] = dist[u] + edge.cost;
                    if (!in_queue[edge.to]) {
                        q.push(edge.to);
                        in_queue[edge.to] = true;
                        if (++count[edge.to] >= n) return {false, {}}; // 正閉路
                    }
                }
            }
        }
        return {true, dist};
    }

    // ==========================================
    // Dijkstraモード (高速だが、コストの条件あり)
    // ==========================================
    
    // max化(最短経路): O(E log V) 
    // ※条件: g_maxの全ての辺の重みが 0 以上であること
    vector<T> build_max_dijkstra(int s) {
        vector<T> dist(n, INF);
        dist[s] = 0;
        priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> pq;
        pq.push({0, s});
        
        while (!pq.empty()) {
            auto [d, u] = pq.top(); pq.pop();
            if (dist[u] < d) continue;
            for (auto& edge : g_max[u]) {
                if (dist[edge.to] > dist[u] + edge.cost) {
                    dist[edge.to] = dist[u] + edge.cost;
                    pq.push({dist[edge.to], edge.to});
                }
            }
        }
        return dist;
    }

    // min化(最長経路): O(E log V)
    // ※条件: g_minの全ての辺の重みが 0 以下であること (内部で符号反転して計算)
    vector<T> build_min_dijkstra(int s) {
        vector<T> dist(n, INF); // 内部では最短経路として扱う
        dist[s] = 0;
        priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> pq;
        pq.push({0, s});
        
        while (!pq.empty()) {
            auto [d, u] = pq.top(); pq.pop();
            if (dist[u] < d) continue;
            for (auto& edge : g_min[u]) {
                T w = -edge.cost; // コストが0以下前提なので反転して0以上にする
                if (dist[edge.to] > dist[u] + w) {
                    dist[edge.to] = dist[u] + w;
                    pq.push({dist[edge.to], edge.to});
                }
            }
        }
        
        vector<T> res(n, -INF);
        for (int i = 0; i < n; ++i) {
            if (dist[i] != INF) res[i] = -dist[i];
        }
        return res;
    }
};

// 2回BFSを行うことで木の直径を求める
pair<ll, ll> bfs_tree_diameter(ll start, ll n, const vector<vector<ll>> &graph) {
  vector<ll> dist(n, -1);
  queue<ll> que;
  dist[start] = 0;
  que.push(start);
  ll far_node = start;
  while (!que.empty()) {
    ll v = que.front();
    que.pop();
    if (dist[v] > dist[far_node]) {
      far_node = v;
    }
    for (ll next : graph[v]) {
      if (dist[next] == -1) {
        dist[next] = dist[v] + 1;
        que.push(next);
      }
    }
  }
  return {dist[far_node], far_node};
}

ll get_tree_diameter(ll n, const vector<vector<ll>> &graph) {
  if (n <= 1) return 0;
  auto p1 = bfs_tree_diameter(0, n, graph);
  auto p2 = bfs_tree_diameter(p1.second, n, graph);
  return p2.first;
}

// 各連結成分に対して木の直径を求め、その最大値を返す
ll get_forest_diameter(ll n, const vector<vector<ll>> &graph) {
  vector<bool> visited(n, false);
  vector<ll> dist(n, -1);
  ll max_diameter = 0;

  auto bfs = [&](ll start, vector<ll> &component) {
    queue<ll> que;
    dist[start] = 0;
    que.push(start);
    ll far_node = start;
    while (!que.empty()) {
      ll v = que.front();
      que.pop();
      component.push_back(v);
      if (dist[v] > dist[far_node]) {
        far_node = v;
      }
      for (ll next : graph[v]) {
        if (dist[next] == -1) {
          dist[next] = dist[v] + 1;
          que.push(next);
        }
      }
    }
    return far_node;
  };

  auto bfs_fixed = [&](ll start) {
    queue<ll> que;
    dist[start] = 0;
    que.push(start);
    ll max_d = 0;
    while (!que.empty()) {
      ll v = que.front();
      que.pop();
      if (dist[v] > max_d) {
        max_d = dist[v];
      }
      for (ll next : graph[v]) {
        if (dist[next] == -1) {
          dist[next] = dist[v] + 1;
          que.push(next);
        }
      }
    }
    return max_d;
  };

  for (ll i = 0; i < n; ++i) {
    if (visited[i]) continue;
    if (graph[i].empty()) {
      visited[i] = true;
      continue;
    }
    vector<ll> component;
    ll u = bfs(i, component);
    for (ll node : component) {
      visited[node] = true;
      dist[node] = -1;
    }
    ll d = bfs_fixed(u);
    for (ll node : component) {
      dist[node] = -1;
    }
    if (d > max_diameter) {
      max_diameter = d;
    }
  }
  return max_diameter;
}

// 木の中心を求める（戻り値は1つまたは2つの頂点）
vector<ll> get_tree_center(ll n, const vector<vector<ll>> &graph) {
  if (n <= 1) return {0};

  // 1回目のBFS（適当な頂点0から最も遠い頂点uを探す）
  vector<ll> dist1(n, -1);
  queue<ll> que;
  dist1[0] = 0;
  que.push(0);
  ll u = 0;
  while (!que.empty()) {
    ll v = que.front();
    que.pop();
    if (dist1[v] > dist1[u]) u = v;
    for (ll next_v : graph[v]) {
      if (dist1[next_v] == -1) {
        dist1[next_v] = dist1[v] + 1;
        que.push(next_v);
      }
    }
  }

  // 2回目のBFS（uから最も遠い頂点wを探しつつ、親を記録してパスを復元可能にする）
  vector<ll> dist2(n, -1);
  vector<ll> parent(n, -1);
  dist2[u] = 0;
  que.push(u);
  ll w = u;
  while (!que.empty()) {
    ll v = que.front();
    que.pop();
    if (dist2[v] > dist2[w]) w = v;
    for (ll next_v : graph[v]) {
      if (dist2[next_v] == -1) {
        dist2[next_v] = dist2[v] + 1;
        parent[next_v] = v;
        que.push(next_v);
      }
    }
  }

  // u から w へのパス（直径）を復元
  vector<ll> path;
  ll curr = w;
  while (curr != -1) {
    path.push_back(curr);
    curr = parent[curr];
  }

  // パスの中点が中心となる
  vector<ll> centers;
  ll len = path.size();
  if (len % 2 == 1) {
    centers.push_back(path[len / 2]);
  } else {
    centers.push_back(path[len / 2 - 1]);
    centers.push_back(path[len / 2]);
  }
  return centers;
}

// 木の重心を求める（戻り値は1つまたは2つの頂点）
vector<ll> get_tree_centroid(ll n, const vector<vector<ll>> &graph) {
  vector<ll> centroid;
  vector<ll> subtree_size(n, 0);

  // 再帰ラムダを用いたDFS
  auto dfs = [&](auto self, ll v, ll p) -> void {
    subtree_size[v] = 1;
    bool is_centroid = true;

    for (ll next_v : graph[v]) {
      if (next_v == p) continue;
      
      self(self, next_v, v);
      subtree_size[v] += subtree_size[next_v];
      
      // 子側の部分木サイズが全体の半分より大きい場合、重心ではない
      if (subtree_size[next_v] > n / 2) {
        is_centroid = false;
      }
    }

    // 親側の部分木サイズが全体の半分より大きい場合、重心ではない
    if (n - subtree_size[v] > n / 2) {
      is_centroid = false;
    }

    if (is_centroid) {
      centroid.push_back(v);
    }
  };

  dfs(dfs, 0, -1);
  return centroid;
}

// 前提：木の重心
// （※この構造体内部で重心を求める処理を完結して実装しています）
struct CentroidDecomposition {
    ll n;
    vector<vector<ll>> graph;
    vector<bool> removed;
    vector<ll> subtree_size;
    
    // 取得できる情報群
    vector<ll> centroid_parent;       // 重心分解木における親（根の場合は -1）
    vector<vector<ll>> centroid_tree; // 重心分解木における子リスト（有向辺）
    ll centroid_root;                 // 重心分解木の根（一番最初の重心）

    // 構築 O(N log N)
    CentroidDecomposition(ll n, const vector<vector<ll>>& g) : n(n), graph(g) {
        removed.assign(n, false);
        subtree_size.assign(n, 0);
        centroid_parent.assign(n, -1);
        centroid_tree.assign(n, vector<ll>());
        centroid_root = -1;
        build(0, -1);
    }

    // DFSで現在の有効な部分木のサイズを計算
    void calc_size(ll v, ll p) {
        subtree_size[v] = 1;
        for (ll next_v : graph[v]) {
            if (next_v == p || removed[next_v]) continue;
            calc_size(next_v, v);
            subtree_size[v] += subtree_size[next_v];
        }
    }

    // 現在の部分木の重心を見つける
    ll get_centroid(ll v, ll p, ll total_size) {
        for (ll next_v : graph[v]) {
            if (next_v == p || removed[next_v]) continue;
            // 子のサイズが全体の半分より大きければ、そっちに重心がある
            if (subtree_size[next_v] > total_size / 2) {
                return get_centroid(next_v, v, total_size);
            }
        }
        return v;
    }

    // 重心分解木を再帰的に構築
    void build(ll v, ll p_centroid) {
        calc_size(v, -1);
        ll c = get_centroid(v, -1, subtree_size[v]);
        
        centroid_parent[c] = p_centroid;
        if (p_centroid == -1) {
            centroid_root = c; // 親がいないならそこが大元の根
        } else {
            centroid_tree[p_centroid].push_back(c); // 親の子リストに自分を追加
        }
        
        removed[c] = true;

        for (ll next_v : graph[c]) {
            if (!removed[next_v]) {
                build(next_v, c);
            }
        }
    }
};

// 補グラフ（与えられた辺「以外」に辺があるグラフ）を効率的に扱うライブラリ
// 前提: typedef long long ll; および graph は vector<vector<ll>> 型
struct ComplementGraph {
  ll n;
  vector<vector<ll>> adj;

  // コンストラクタ: 元グラフを渡し、内部で二分探索用にソートする
  ComplementGraph(ll n, const vector<vector<ll>>& graph) : n(n), adj(graph) {
    for (ll i = 0; i < n; ++i) {
      sort(adj[i].begin(), adj[i].end());
    }
  }

  // 1. 補グラフ上での始点(複数可)からの最短距離を求める
  vector<ll> get_distances(const vector<ll>& start_nodes) {
    vector<ll> dist(n, -1);
    set<ll> unvisited;
    for (ll i = 0; i < n; ++i) unvisited.insert(i);

    queue<ll> q;
    for (ll s : start_nodes) {
      dist[s] = 0;
      q.push(s);
      unvisited.erase(s);
    }

    while (!q.empty()) {
      ll u = q.front();
      q.pop();

      auto it = unvisited.begin();
      while (it != unvisited.end()) {
        ll v = *it;
        // 元グラフに辺があれば補グラフには辺がない
        if (binary_search(adj[u].begin(), adj[u].end(), v)) {
          ++it;
        } else {
          dist[v] = dist[u] + 1;
          q.push(v);
          it = unvisited.erase(it); // 訪問したら即座に候補から消す
        }
      }
    }
    return dist;
  }

  // 2. 補グラフにおける連結成分分解
  // 戻り値: 各連結成分に含まれる頂点リストのリスト
  vector<vector<ll>> get_connected_components() {
    vector<vector<ll>> comps;
    set<ll> unvisited;
    for (ll i = 0; i < n; ++i) unvisited.insert(i);

    while (!unvisited.empty()) {
      ll start = *unvisited.begin();
      unvisited.erase(unvisited.begin());

      vector<ll> comp;
      queue<ll> q;
      q.push(start);
      comp.push_back(start);

      while (!q.empty()) {
        ll u = q.front();
        q.pop();

        auto it = unvisited.begin();
        while (it != unvisited.end()) {
          ll v = *it;
          if (binary_search(adj[u].begin(), adj[u].end(), v)) {
            ++it;
          } else {
            comp.push_back(v);
            q.push(v);
            it = unvisited.erase(it);
          }
        }
      }
      comps.push_back(comp);
    }
    return comps;
  }

  // 3. 補グラフの二部グラフ判定（元グラフを2つのクリークに分割可能か等に使用）
  // 戻り値: 二部グラフなら各成分の {色0の頂点群, 色1の頂点群} のリスト。不可なら空配列
  vector<pair<vector<ll>, vector<ll>>> get_bipartite_components() {
    vector<pair<vector<ll>, vector<ll>>> comps;
    set<ll> unvisited;
    for (ll i = 0; i < n; ++i) unvisited.insert(i);
    
    vector<ll> color(n, -1);

    while (!unvisited.empty()) {
      ll start = *unvisited.begin();
      unvisited.erase(unvisited.begin());

      vector<ll> color0, color1;
      queue<ll> q;
      q.push(start);
      color[start] = 0;
      color0.push_back(start);

      vector<ll> current_comp = {start};

      while (!q.empty()) {
        ll u = q.front();
        q.pop();

        auto it = unvisited.begin();
        while (it != unvisited.end()) {
          ll v = *it;
          if (binary_search(adj[u].begin(), adj[u].end(), v)) {
            ++it;
          } else {
            color[v] = 1 - color[u];
            if (color[v] == 0) color0.push_back(v);
            else color1.push_back(v);
            
            current_comp.push_back(v);
            q.push(v);
            it = unvisited.erase(it);
          }
        }
      }

      // 矛盾チェック：同色同士に「補グラフの辺」がないか（＝元グラフで全て辺が張られているか）
      for (ll u : current_comp) {
        ll same_color_count = 0;
        for (ll v : adj[u]) {
          if (color[u] == color[v]) same_color_count++;
        }
        // 自分以外の同色の頂点すべてと元グラフで繋がっていなければならない
        ll expected = (color[u] == 0 ? color0.size() : color1.size()) - 1;
        if (same_color_count < expected) return {}; // 矛盾発見（二部グラフではない）
      }
      comps.push_back({color0, color1});
    }
    return comps;
  }
};

// DAG のトポロジカルソートを行う
// 戻り値: ソートされた頂点配列（閉路がある場合は空の配列を返す）
vector<ll> topological_sort(const vector<vector<ll>>& G) {
    ll n = G.size();
    vector<ll> indeg(n, 0);
    for (ll i = 0; i < n; i++) {
        for (ll to : G[i]) indeg[to]++;
    }

    queue<ll> q;
    for (ll i = 0; i < n; i++) {
        if (indeg[i] == 0) q.push(i);
    }

    vector<ll> ord;
    while (!q.empty()) {
        ll v = q.front(); q.pop();
        ord.push_back(v);
        for (ll to : G[v]) {
            if (--indeg[to] == 0) q.push(to);
        }
    }
    
    // 閉路がある場合は要素数が n にならない
    if (ord.size() != n) return {};
    return ord;
}

// graph の連結成分を求める
// 戻り値 V[i] が i 番目の連結成分に含まれる頂点集合
vector<vector<ll>> connected_components(
    const vector<vector<ll>>& graph) {

    ll n = graph.size();

    vector<bool> seen(n, false);
    vector<vector<ll>> V;

    auto dfs = [&](auto&& self,
                   ll v,
                   vector<ll>& comp) -> void {

        seen[v] = true;
        comp.push_back(v);

        for (ll next : graph[v]) {
            if (seen[next]) continue;
            self(self, next, comp);
        }
    };

    for (ll v = 0; v < n; v++) {
        if (seen[v]) continue;

        vector<ll> comp;
        dfs(dfs, v, comp);

        V.push_back(comp);
    }

    return V;
}

// SCC (強連結成分分解) の構造体
struct SCC {
    ll n;
    vector<vector<ll>> g, rg;
    
    // 構築後に利用可能なデータ
    vector<ll> comp;          // comp[i]: 頂点 i が属するSCCのグループID (0-indexed, トポロジカル順)
    vector<vector<ll>> scc;   // scc[i]: グループ i に含まれる頂点のリスト
    vector<vector<ll>> dag;   // dag[i]: グループ i から遷移可能なグループIDのリスト (縮約後のDAG)

    vector<ll> order;
    vector<bool> used;

    // 初期化
    SCC(ll n) : n(n), g(n), rg(n), comp(n, -1), used(n, false) {}

    // 有向辺の追加 (u -> v)
    void add_edge(ll u, ll v) {
        g[u].push_back(v);
        rg[v].push_back(u);
    }

    // 1回目のDFS
    void dfs1(ll v) {
        used[v] = true;
        for (ll next : g[v]) {
            if (!used[next]) dfs1(next);
        }
        order.push_back(v);
    }

    // 2回目のDFS
    void dfs2(ll v, ll k) {
        used[v] = true;
        comp[v] = k;
        scc.back().push_back(v);
        for (ll next : rg[v]) {
            if (!used[next]) dfs2(next, k);
        }
    }

    // SCCの構築・DAGの生成 (すべての辺を追加し終えた後に呼ぶ)
    void build() {
        for (ll i = 0; i < n; i++) {
            if (!used[i]) dfs1(i);
        }
        
        used.assign(n, false);
        ll k = 0;
        for (ll i = (ll)order.size() - 1; i >= 0; i--) {
            ll v = order[i];
            if (!used[v]) {
                scc.push_back({});
                dfs2(v, k++);
            }
        }

        // DAGの構築 (SCCで縮約した後のグラフ)
        dag.resize(k);
        for (ll u = 0; u < n; u++) {
            for (ll v : g[u]) {
                ll x = comp[u];
                ll y = comp[v];
                if (x != y) {
                    dag[x].push_back(y);
                }
            }
        }
        
        // DAGの重複辺を削除
        for (ll i = 0; i < k; i++) {
            sort(dag[i].begin(), dag[i].end());
            dag[i].erase(unique(dag[i].begin(), dag[i].end()), dag[i].end());
        }
    }

    // Union-Find的な機能: 頂点 u と v が同じ強連結成分に属するか判定
    bool same(ll u, ll v) {
        return comp[u] == comp[v];
    }
};

// 強連結な向き付けの判定と構築
struct StronglyConnectedOrientation {
    ll V;
    vector<vector<ll>> adj;
    vector<pair<ll, ll>> directed_edges; // 構築された有向辺のリスト
    bool possible;

    StronglyConnectedOrientation(ll n) : V(n), adj(n), possible(true) {}

    // 無向辺の追加
    void add_edge(ll u, ll v) {
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    // 判定と構築の実行
    bool build() {
        vector<ll> ord(V, -1), low(V, -1);
        vector<bool> visited(V, false);
        ll time = 0;
        directed_edges.clear();
        possible = true;

        // DFS
        auto dfs = [&](auto self, ll u, ll p) -> void {
            visited[u] = true;
            ord[u] = low[u] = time++;
            bool parent_skipped = false; // 多重辺対策

            for (ll v : adj[u]) {
                if (v == p && !parent_skipped) {
                    parent_skipped = true;
                    continue;
                }
                if (!visited[v]) { // 木辺
                    directed_edges.push_back({u, v});
                    self(self, v, u);
                    low[u] = min(low[u], low[v]);
                    if (low[v] > ord[u]) {
                        possible = false; // 橋が存在するため不可能
                    }
                } else if (ord[v] < ord[u]) { // 後退辺
                    directed_edges.push_back({u, v});
                    low[u] = min(low[u], ord[v]);
                }
            }
        };

        ll connected_components = 0;
        for (ll i = 0; i < V; ++i) {
            if (!visited[i]) {
                if (connected_components > 0) {
                    possible = false; // グラフが非連結の場合は全体を強連結にできない
                }
                dfs(dfs, i, -1);
                connected_components++;
            }
        }
        
        if (V <= 1) possible = true; // 頂点数1以下の場合は常に可能
        return possible;
    }
};

struct EulerTour {
    ll n;
    // [1] 部分木クエリ用：頂点vの部分木は半開区間 [ in_time[v], out_time[v] ) に対応 (サイズ N)
    vector<ll> in_time, out_time;
    ll timer_inout;

    // [2] パスクエリ用（括弧列）：頂点vに入る時刻 path_in[v] と出る時刻 path_out[v] (サイズ 2N)
    vector<ll> path_in, path_out;
    ll timer_path;

    // [3] LCA用：訪問順の頂点(tour), その深さ(depth), 頂点vがtourに最初に現れるインデックス(first_visit) (サイズ 2N-1)
    vector<ll> tour, depth, first_visit;
    
    // 距離用：根からの距離（重みなし木ならdepthと同じ。重み付きならパスの重み和）
    vector<long long> dist;

    EulerTour(const vector<vector<ll>>& graph, ll root = 0) {
        n = graph.size();
        in_time.assign(n, -1);
        out_time.assign(n, -1);
        path_in.assign(n, -1);
        path_out.assign(n, -1);
        first_visit.assign(n, -1);
        dist.assign(n, 0);
        timer_inout = 0;
        timer_path = 0;
        build(graph, root, -1, 0, 0);
    }

    void build(const vector<vector<ll>>& graph, ll v, ll p, ll d, long long dist_from_root) {
        // 部分木用 (入)
        in_time[v] = timer_inout++;
        
        // パスクエリ用 (入)
        path_in[v] = timer_path++;

        // LCA用 (入)
        first_visit[v] = tour.size();
        tour.push_back(v);
        depth.push_back(d);
        
        dist[v] = dist_from_root;

        for (ll next : graph[v]) {
            if (next == p) continue;
            // ※辺に重みがあるグラフの場合は、引数を変えて dist_from_root + cost にする
            build(graph, next, v, d + 1, dist_from_root + 1);
            
            // LCA用 (戻り)
            tour.push_back(v);
            depth.push_back(d);
        }
        
        // 部分木用 (出) ※時間は進めない
        out_time[v] = timer_inout;
        
        // パスクエリ用 (出) ※時間は進める
        path_out[v] = timer_path++;
    }
};

// XOR MST 本体
// 戻り値: {MSTの重みの総和, 使用した辺(u, v)のリスト}
// ※ a[i] >= 0 を想定しています
pair<ll, vector<pair<int, int>>> xor_mst(const vector<ll>& a) {
    int n = a.size();
    if (n <= 1) return {0, {}};
    
    // 元のインデックスを保持したままソート
    vector<pair<ll, int>> val_idx(n);
    for (int i = 0; i < n; i++) val_idx[i] = {a[i], i};
    sort(val_idx.begin(), val_idx.end());
    
    struct TrieNode {
        int ch[2];
        int l, r; // このノードを通過する値の val_idx におけるインデックスの範囲 [l, r]
        TrieNode() { ch[0] = ch[1] = -1; l = r = -1; }
    };
    vector<TrieNode> trie(1);
    
    // 値の最大値から必要なビット数を判定
    int max_bit = 29;
    for (int i = 0; i < n; i++) {
        if (a[i] >= (1LL << 30)) max_bit = 59;
    }
    
    // Trie木の構築
    for (int i = 0; i < n; i++) {
        int u = 0;
        if (trie[u].l == -1) trie[u].l = i;
        trie[u].r = i;
        for (int bit = max_bit; bit >= 0; bit--) {
            int b = (val_idx[i].first >> bit) & 1;
            if (trie[u].ch[b] == -1) {
                trie[u].ch[b] = trie.size();
                trie.emplace_back();
                trie.back().l = i;
            }
            u = trie[u].ch[b];
            trie[u].r = i;
        }
    }
    
    ll total_weight = 0;
    vector<pair<int, int>> mst_edges;
    
    // 分割統治でMSTの辺を決定
    auto dfs = [&](auto& self, int u, int bit) -> void {
        if (bit < 0) {
            // 完全一致する重複要素同士はコスト0で結ぶ
            for (int i = trie[u].l; i < trie[u].r; i++) {
                mst_edges.push_back({val_idx[i].second, val_idx[i+1].second});
            }
            return;
        }
        
        int lc = trie[u].ch[0];
        int rc = trie[u].ch[1];
        
        // 子ノードの再帰処理
        if (lc != -1) self(self, lc, bit - 1);
        if (rc != -1) self(self, rc, bit - 1);
        
        // 両方の子ノードが存在する場合、2つのグループを繋ぐ最小の辺を探す
        if (lc != -1 && rc != -1) {
            ll min_w = 4e18; // 十分大きな値
            pair<int, int> best_edge = {-1, -1};
            
            int len_l = trie[lc].r - trie[lc].l + 1;
            int len_r = trie[rc].r - trie[rc].l + 1;
            
            // Trie木を辿って val との XOR が最小になる要素を探索
            auto find_min = [&](int search_u, ll val) -> pair<ll, int> {
                int curr = search_u;
                for (int b = bit - 1; b >= 0; b--) {
                    int v_bit = (val >> b) & 1;
                    if (trie[curr].ch[v_bit] != -1) {
                        curr = trie[curr].ch[v_bit];
                    } else {
                        curr = trie[curr].ch[v_bit ^ 1];
                    }
                }
                return {val ^ val_idx[trie[curr].l].first, val_idx[trie[curr].l].second};
            };
            
            // 要素数が少ない方のグループを全探索 (マージテク・Borůvka法の応用)
            if (len_l <= len_r) {
                for (int i = trie[lc].l; i <= trie[lc].r; i++) {
                    auto best = find_min(rc, val_idx[i].first);
                    if (best.first < min_w) {
                        min_w = best.first;
                        best_edge = {val_idx[i].second, best.second};
                    }
                }
            } else {
                for (int i = trie[rc].l; i <= trie[rc].r; i++) {
                    auto best = find_min(lc, val_idx[i].first);
                    if (best.first < min_w) {
                        min_w = best.first;
                        best_edge = {val_idx[i].second, best.second};
                    }
                }
            }
            
            total_weight += min_w;
            mst_edges.push_back(best_edge);
        }
    };
    
    dfs(dfs, 0, max_bit);
    return {total_weight, mst_edges};
}

// Triangle Count 本体
// 戻り値: グラフに含まれる三角形(長さ3の閉路)の総数
long long triangle_count(int n, const vector<pair<int, int>>& edges) {
    // 1. 各頂点の次数を計算
    vector<int> deg(n, 0);
    for (auto [u, v] : edges) {
        deg[u]++;
        deg[v]++;
    }

    // 2. 次数小 → 次数大 (同じなら頂点番号小 → 大) へと向き付けした隣接リストを構築
    vector<vector<int>> adj(n);
    for (auto [u, v] : edges) {
        bool dir_u_to_v = false;
        if (deg[u] < deg[v]) {
            dir_u_to_v = true;
        } else if (deg[u] == deg[v] && u < v) {
            dir_u_to_v = true;
        }

        if (dir_u_to_v) {
            adj[u].push_back(v);
        } else {
            adj[v].push_back(u);
        }
    }

    long long count = 0;
    // 頂点uの隣接頂点を O(1) で判定するための配列
    vector<bool> is_adj(n, false); 

    // 3. 各頂点を始点として三角形を探索
    for (int u = 0; u < n; u++) {
        // u の行き先をマーク
        for (int v : adj[u]) is_adj[v] = true;
        
        // u → v → w と辿り、u → w の辺があるか確認
        for (int v : adj[u]) {
            for (int w : adj[v]) {
                if (is_adj[w]) {
                    count++;
                }
            }
        }
        
        // 次の頂点に備えてマークをリセット（毎回配列を初期化するより高速）
        for (int v : adj[u]) is_adj[v] = false;
    }

    return count;
}

using ll = long long;

int main() {
    int N = 5;
    
    // 1. 宣言: 頂点数 N を指定。容量の型に ll を指定します。
    mf_graph<ll> graph(N);

    // 2. 辺の追加: add_edge(from, to, capacity)
    // 頂点は 0-indexed で指定します。戻り値として辺のID(int)が返ります。
    graph.add_edge(0, 1, 10);
    graph.add_edge(0, 2, 2);
    graph.add_edge(1, 2, 6);
    graph.add_edge(1, 3, 6);
    graph.add_edge(2, 4, 5);
    graph.add_edge(3, 4, 8);

    // 3. 最大流 (Max Flow): flow(s, t)
    // 頂点 0 から 4 への最大流量を計算して返します。
    ll max_flow = graph.flow(0, 4);

    // 4. 最小カット (Min Cut): min_cut(s)
    // 必ず flow(s, t) を実行した「後」に呼び出します。
    // 残余グラフ上で始点 s から到達可能な頂点が true (S側)、そうでない頂点が false (T側) となる配列を返します。
    vector<bool> is_S = graph.min_cut(0);

    // 5. 各辺の状態取得: edges() や get_edge(i) (任意)
    // auto edges = graph.edges();
    // for (auto e : edges) {
    //     // e.from, e.to, e.cap, e.flow にアクセスして復元等に利用できます。
    // }
}

// ===== Bipartite Matching (ACL mf_graph) =====
struct BipartiteMatching {
    ll L_size, R_size;
    ll S, T;
    mf_graph<ll> graph;

    // L側の頂点は 0 ~ L-1, R側の頂点は L ~ L+R-1 に割り当て、SとTを追加
    BipartiteMatching(ll L, ll R) : L_size(L), R_size(R), S(L + R), T(L + R + 1), graph(L + R + 2) {
        // S から L 側へ容量 1 の辺を張る
        for (ll i = 0; i < L; ++i) graph.add_edge(S, i, 1);
        // R 側から T へ容量 1 の辺を張る
        for (ll j = 0; j < R; ++j) graph.add_edge(L_size + j, T, 1);
    }

    void add_edge(ll u, ll v) {
        // L側の u から R側の v へ容量 1 の辺を張る
        graph.add_edge(u, L_size + v, 1);
    }

    // 最大マッチングのサイズを返す
    ll solve() {
        return graph.flow(S, T);
    }

    // 復元処理: (最大マッチングの辺, 左の最小頂点被覆, 右の最小頂点被覆, 左の最大独立集合, 右の最大独立集合)
    // ※必ず solve() を実行した後に呼ぶこと
    tuple<vector<pair<ll, ll>>, vector<ll>, vector<ll>, vector<ll>, vector<ll>> restore() {
        vector<pair<ll, ll>> edges;
        for (auto e : graph.edges()) {
            // SやTが絡まない辺で、流量が1になっているものがマッチングに使われた辺
            if (e.from != S && e.to != T && e.flow == 1) {
                edges.push_back({e.from, e.to - L_size});
            }
        }

        // 最小カット (min_cut) を用いて頂点被覆と独立集合を復元
        vector<bool> is_S = graph.min_cut(S);
        vector<ll> mvc_l, mvc_r, mis_l, mis_r;

        for (ll i = 0; i < L_size; ++i) {
            if (!is_S[i]) mvc_l.push_back(i); // L側: 最小カットでT側に属していれば被覆
            else mis_l.push_back(i);          // L側: 最小カットでS側に属していれば独立集合
        }
        for (ll i = 0; i < R_size; ++i) {
            if (is_S[L_size + i]) mvc_r.push_back(i); // R側: 最小カットでS側に属していれば被覆
            else mis_r.push_back(i);                  // R側: 最小カットでT側に属していれば独立集合
        }
        return {edges, mvc_l, mvc_r, mis_l, mis_r};
    }
};

// ===== 最大反鎖 / 最小パス被覆 (Dilworthの定理) =====
// 前提: BipartiteMatching
struct Dilworth {
    ll N;
    vector<vector<bool>> reachable;
    BipartiteMatching bm;

    // 頂点数 N のDAGを指定して初期化
    Dilworth(ll n) : N(n), reachable(n, vector<bool>(n, false)), bm(n, n) {}

    // u から v への有向辺（直接の遷移）を追加する
    void add_edge(ll u, ll v) {
        reachable[u][v] = true;
    }

    // 最大反鎖のサイズ（＝最小パス被覆の数）を返す
    ll solve() {
        // 1. Warshall-Floyd法で推移的閉包（到達可能性）を計算
        for (ll k = 0; k < N; ++k) {
            for (ll i = 0; i < N; ++i) {
                for (ll j = 0; j < N; ++j) {
                    if (reachable[i][k] && reachable[k][j]) {
                        reachable[i][j] = true;
                    }
                }
            }
        }

        // 2. 到達可能なすべての頂点対について、二部マッチング用の辺を追加
        for (ll i = 0; i < N; ++i) {
            for (ll j = 0; j < N; ++j) {
                if (reachable[i][j]) {
                    bm.add_edge(i, j);
                }
            }
        }

        // 3. 最大マッチングを計算し、Dilworthの定理より最大反鎖サイズを求める
        return N - bm.solve();
    }

    // 最大反鎖の復元: (反鎖を構成する頂点番号のリスト)
    // ※必ず solve() を実行した後に呼ぶこと
    vector<ll> restore() {
        auto [edges, mvc_l, mvc_r, mis_l, mis_r] = bm.restore();
        
        vector<bool> in_mis_l(N, false), in_mis_r(N, false);
        for (ll u : mis_l) in_mis_l[u] = true;
        for (ll v : mis_r) in_mis_r[v] = true;

        vector<ll> antichain;
        // L側の最大独立集合 と R側の最大独立集合 の両方に含まれる頂点が、最大反鎖の要素となる
        for (ll i = 0; i < N; ++i) {
            if (in_mis_l[i] && in_mis_r[i]) {
                antichain.push_back(i);
            }
        }
        return antichain;
    }
};

// ===== General Graph Matching (Edmonds' Blossom Algorithm) =====
// 前提: using ll = long long; が定義されていること
struct GeneralGraphMatching {
    ll N;
    vector<vector<ll>> adj;
    vector<ll> match;
    vector<ll> p, base, q;
    vector<bool> used, blossom;

    // 頂点数 n で初期化 (0-indexed)
    GeneralGraphMatching(ll n) : N(n), adj(n), match(n, -1) {}

    // 無向辺を追加
    void add_edge(ll u, ll v) {
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    // 共通祖先(LCA)を見つける内部関数
    ll lca(ll a, ll b) {
        bool match_a = false;
        vector<bool> trace(N, false);
        while (true) {
            a = base[a];
            trace[a] = true;
            if (match[a] == -1) break;
            a = p[match[a]];
        }
        while (true) {
            b = base[b];
            if (trace[b]) return b;
            b = p[match[b]];
        }
    }

    // 奇数長の閉路(花)をマークして縮約する内部関数
    void mark_path(ll v, ll b, ll children) {
        while (base[v] != b) {
            blossom[base[v]] = blossom[base[match[v]]] = true;
            p[v] = children;
            children = match[v];
            v = p[match[v]];
        }
    }

    // 増大道を探索する内部関数
    ll find_path(ll root) {
        used.assign(N, false);
        p.assign(N, -1);
        base.resize(N);
        for (ll i = 0; i < N; ++i) base[i] = i;
        used[root] = true;
        
        ll qh = 0, qt = 0;
        q.resize(N);
        q[qt++] = root;

        while (qh < qt) {
            ll v = q[qh++];
            for (ll to : adj[v]) {
                if (base[v] == base[to] || match[v] == to) continue;
                if (to == root || (match[to] != -1 && p[match[to]] != -1)) {
                    ll curbase = lca(v, to);
                    blossom.assign(N, false);
                    mark_path(v, curbase, to);
                    mark_path(to, curbase, v);
                    for (ll i = 0; i < N; ++i) {
                        if (blossom[base[i]]) {
                            base[i] = curbase;
                            if (!used[i]) {
                                used[i] = true;
                                q[qt++] = i;
                            }
                        }
                    }
                } else if (p[to] == -1) {
                    p[to] = v;
                    if (match[to] == -1) return to;
                    to = match[to];
                    used[to] = true;
                    q[qt++] = to;
                }
            }
        }
        return -1;
    }

    // 最大マッチングのペア数を返す
    ll solve() {
        ll ans = 0;
        for (ll i = 0; i < N; ++i) {
            if (match[i] == -1) {
                ll v = find_path(i);
                if (v != -1) {
                    ans++;
                    while (v != -1) {
                        ll pv = p[v], ppv = match[pv];
                        match[v] = pv;
                        match[pv] = v;
                        v = ppv;
                    }
                }
            }
        }
        return ans;
    }

    // マッチングに使われた辺のリストを返す
    // ※必ず solve() を実行した後に呼ぶこと
    vector<pair<ll, ll>> restore() {
        vector<pair<ll, ll>> edges;
        for (ll i = 0; i < N; ++i) {
            if (i < match[i]) {
                edges.push_back({i, match[i]});
            }
        }
        return edges;
    }
};

// 前提: UnionFind

// 辺を表す構造体
struct Edge {
    ll u, v, cost;
};

// クラスカル法 (最小/最大全域木)
// 引数 get_max を true にすると最大全域木を構築する
// 戻り値: {MSTの重みの総和, MSTを構成する隣接リスト}
pair<ll, vector<vector<pair<ll, ll>>>> kruskal(ll V, vector<Edge>& edges, bool get_max = false) {
    // 1. 辺をコスト順にソート
    sort(edges.begin(), edges.end(), [&](const Edge& a, const Edge& b) {
        if (get_max) return a.cost > b.cost; // 最大全域木: 降順
        return a.cost < b.cost;              // 最小全域木: 昇順
    });

    UnionFind uf(V);
    ll total_cost = 0;
    vector<vector<pair<ll, ll>>> mst_adj(V); // MSTの隣接リスト (to, cost)

    // 2. コストの条件に合う辺から順に確認
    for (const auto& e : edges) {
        // 閉路ができない場合のみ辺を採用 (異なるグループなら繋ぐ)
        if (uf.unite(e.u, e.v)) {
            total_cost += e.cost;
            // 無向グラフとして隣接リストに辺を追加
            mst_adj[e.u].push_back({e.v, e.cost});
            mst_adj[e.v].push_back({e.u, e.cost});
        }
    }

    return {total_cost, mst_adj};
}

template <typename T = long long>
struct Doubling {
    ll n;
    ll max_log;
    vector<vector<ll>> next;
    vector<vector<T>> sum;
    T identity;
    using F = function<T(T, T)>;
    F op;
    bool has_value;

    // 移動のみ（値の累積なし）の場合のコンストラクタ
    Doubling(ll n, long long max_k) : n(n), has_value(false) {
        max_log = (max_k <= 0) ? 1 : 64 - __builtin_clzll(max_k);
        next.assign(max_log, vector<ll>(n, -1));
    }

    // 値の累積を行う場合のコンストラクタ (単位元 id と 二項演算 op を指定)
    Doubling(ll n, long long max_k, T id, F op)
        : n(n), identity(id), op(op), has_value(true) {
        max_log = (max_k <= 0) ? 1 : 64 - __builtin_clzll(max_k);
        next.assign(max_log, vector<ll>(n, -1));
        sum.assign(max_log, vector<T>(n, id));
    }

    // 1ステップの遷移を設定 (u から v へ、重み/値 w)
    void set_next(ll u, ll v, T w = T()) {
        next[0][u] = v;
        if (has_value) sum[0][u] = w;
    }

    // テーブル構築 (すべての遷移を設定した後に呼び出す)
    void build() {
        for (ll k = 0; k < max_log - 1; k++) {
            for (ll i = 0; i < n; i++) {
                if (next[k][i] != -1) {
                    next[k + 1][i] = next[k][next[k][i]];
                    if (has_value) {
                        sum[k + 1][i] = op(sum[k][i], sum[k][next[k][i]]);
                    }
                }
            }
        }
    }

    // start から k 回移動した後の {行き先, 累積値} を取得
    pair<ll, T> query(ll start, long long k) const {
        ll cur = start;
        T res = identity;
        for (ll i = 0; i < max_log; i++) {
            if ((k >> i) & 1) {
                if (cur == -1) break;
                if (has_value) res = op(res, sum[i][cur]);
                cur = next[i][cur];
            }
        }
        return {cur, res};
    }
};

template <typename T>
struct MatrixTreeTheorem {
    int n;
    vector<vector<T>> laplacian;

    MatrixTreeTheorem(int n) : n(n), laplacian(n, vector<T>(n, 0)) {}

    // 無向辺 u-v を追加 (重み w、デフォルトは 1)
    // 多重辺の場合は w に追加する辺の本数を指定する
    void add_edge(int u, int v, T w = 1) {
        laplacian[u][u] += w;
        laplacian[v][v] += w;
        laplacian[u][v] -= w;
        laplacian[v][u] -= w;
    }

    // 全域木の数を計算（0行目と0列目を取り除いた余因子を計算）
    T build() {
        if (n <= 1) return 1;
        int m = n - 1;
        vector<vector<T>> mat(m, vector<T>(m));
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < m; ++j) {
                mat[i][j] = laplacian[i + 1][j + 1];
            }
        }

        T res = 1;
        for (int i = 0; i < m; ++i) {
            int pivot = -1;
            for (int j = i; j < m; ++j) {
                if (mat[j][i] != 0) { // 浮動小数の場合は abs(mat[j][i]) > 1e-9 などで判定
                    pivot = j;
                    break;
                }
            }
            if (pivot == -1) return 0; // 行列式が0 = 全域木が存在しない
            
            if (i != pivot) {
                swap(mat[i], mat[pivot]);
                res = -res; // 行の入れ替えで符号反転
            }
            
            // 掃き出し法
            T inv = (T)1 / mat[i][i];
            for (int j = i + 1; j < m; ++j) {
                T factor = mat[j][i] * inv;
                for (int k = i; k < m; ++k) {
                    mat[j][k] -= mat[i][k] * factor;
                }
            }
            res *= mat[i][i];
        }
        return res;
    }
};

ll res = 0;
ll right = 0;
// sumやcountなどの区間の状態を管理する変数をここに用意

for (ll left = 0; left < n; ++left) {
    // rightを進めても条件を満たす間（または満たすまで）、rightを伸ばす
    while (right < n && /* 条件を満たすか判定 */) {
        // 状態の更新 (例: sum += a[right])
        ++right;
    }

    // この時点で [left, right) が確定。必要な処理を行う
    res += (right - left); // 例: 条件を満たす部分列の数を足す

    // 次のループ（left++）に向けて状態を正しく保つ
    if (right == left) {
        // 区間が空の場合は right も一緒に進める（状態は更新しない）
        ++right;
    } else {
        // 左端の要素を区間から除外 (例: sum -= a[left])
    }
}

ll res = 0;
ll left = 0;
// sumやcountなどの区間の状態を管理する変数をここに用意

for (ll right = 0; right < n; ++right) {
    // まず右端の要素を問答無用で追加する
    // 状態の更新 (例: sum += a[right])

    // 条件を破ってしまったら、満たすようになるまで左端を縮める
    while (left <= right && /* 条件を満たしていないか判定 */) {
        // 左端の要素を除外 (例: sum -= a[left])
        ++left;
    }

    // この時点で閉区間 [left, right] は確実に条件を満たしている
    res += (right - left + 1); // 例: 閉区間の長さを足す
}

// 区間 {始点, 終点} の配列が与えられたとする
// vector<pair<ll, ll>> intervals(N);

// 終端位置が早い順にソートしたいので、{終点, 始点} のペアにする
vector<pair<ll, ll>> sorted_intervals(N);
rep(i, N) {
    sorted_intervals[i] = {intervals[i].second, intervals[i].first};
}
sort(sorted_intervals.begin(), sorted_intervals.end());

ll ans = 0;
ll current_end_time = 0;

rep(i, N) {
    // 最後に選んだ区間の終端よりも、次の区間の始点が後（または同じ）なら選べる
    if (sorted_intervals[i].second >= current_end_time) {
        ans++;
        current_end_time = sorted_intervals[i].first; // 新しい終端時間を記録
    }
}

// 転倒数 (Fenwick Tree + 座標圧縮ベース)
// 配列内の要素がどれだけ大きくても、負の値を含んでいても動作します

#include <vector>
#include <algorithm>

template<typename T>
long long inversion_number(const std::vector<T>& A) {
    int n = A.size();
    if (n == 0) return 0;

    // 1. 座標圧縮 (配列の値を 0-indexed のランクに変換)
    std::vector<T> sorted_A = A;
    std::sort(sorted_A.begin(), sorted_A.end());
    sorted_A.erase(std::unique(sorted_A.begin(), sorted_A.end()), sorted_A.end());
    int m = sorted_A.size();

    // 2. Fenwick Tree (BIT) の実装 (内部は 1-indexed)
    std::vector<int> bit(m + 1, 0);
    auto add = [&](int i, int x) {
        for (++i; i <= m; i += i & -i) bit[i] += x;
    };
    auto sum = [&](int i) {
        int s = 0;
        for (; i > 0; i -= i & -i) s += bit[i];
        return s;
    };

    // 3. 転倒数のカウント
    long long inv = 0;
    for (int i = 0; i < n; ++i) {
        // 圧縮後のランクを取得 (0-indexed)
        int rank = std::lower_bound(sorted_A.begin(), sorted_A.end(), A[i]) - sorted_A.begin();
        
        // これまでに出現した要素のうち、自分以下の要素の数を取得
        int count_less_equal = sum(rank + 1);
        
        // (これまでに出現した全要素数 i) - (自分以下の要素数) = (自分より真に大きい要素数)
        inv += i - count_less_equal;
        
        // 自分のランクを BIT に登録
        add(rank, 1);
    }
    return inv;
}

// 前提：Fenwick Tree(BIT), using ll = long long;
                
ll calc_intersections(const vector<ll>& A, const vector<ll>& B) {
    // Bの各要素が「Bの何番目にあるか」を記録
    // ※重複要素が含まれる場合、前から順に対応させる（交差を防ぐ）ために queue を使用
    unordered_map<ll, queue<ll>> pos_B;
    for (ll i = 0; i < (ll)B.size(); ++i) {
        pos_B[B[i]].push(i);
    }

    // Aの要素のうち、Bにも存在するものを結ぶ（向かうべきBのインデックス配列 C を作成）
    vector<ll> C;
    for (ll i = 0; i < (ll)A.size(); ++i) {
        if (!pos_B[A[i]].empty()) {
            C.push_back(pos_B[A[i]].front());
            pos_B[A[i]].pop();
        }
    }

    // 配列 C の転倒数を BIT を用いて求める
    BIT bit(B.size());
    ll intersections = 0;
    for (ll i = 0; i < (ll)C.size(); ++i) {
        // i は現在までに追加した要素の総数
        // bit.sum(C[i] + 1) は、これまでに追加した要素のうち C[i] 以下のものの個数
        // その差分が C[i] より大きい要素の個数 = 交差する線の数（転倒数）
        intersections += i - bit.sum(C[i] + 1);
        bit.add(C[i], 1);
    }

    return intersections;
}

// 元の配列 a (サイズ N)
// vector<ll> a(N);

// 累積和配列 S を構築 (サイズは N + 1)
vector<ll> s(N + 1, 0);
rep(i, N) {
    s[i + 1] = s[i] + a[i];
}

// 区間 [left, right) の和を O(1) で求める関数
// 例: a[1] + a[2] + a[3] なら left = 1, right = 4
auto query = [&](ll left, ll right) {
    return s[right] - s[left];
};

// 各次元のサイズ D を指定する N 次元累積和 / 逆変換 (差分)
template <typename T>
void n_dimensional_prefix_sum(vector<T>& a, const vector<ll>& D, bool invert = false) {
    ll n = a.size();
    ll N_dim = D.size();
    // ストライド (D_0, D_0*D_1, ...) を前計算
    vector<ll> stride(N_dim + 1, 1);
    for (ll d = 0; d < N_dim; d++) {
        stride[d + 1] = stride[d] * D[d];
    }
    
    if (!invert) {
        for (ll d = 0; d < N_dim; d++) {
            for (ll i = 0; i < n; i++) {
                if ((i / stride[d]) % D[d] > 0) {
                    a[i] += a[i - stride[d]];
                }
            }
        }
    } else {
        for (ll d = 0; d < N_dim; d++) {
            for (ll i = n - 1; i >= 0; i--) {
                if ((i / stride[d]) % D[d] > 0) {
                    a[i] -= a[i - stride[d]];
                }
            }
        }
    }
}

// 累積和済みの配列 a に対して、各次元で X[i] <= p[i] <= Y[i] を満たす超立方体領域の和を求める
template <typename T>
T get_nd_range_sum(const vector<T>& a, const vector<ll>& D, const vector<ll>& X, const vector<ll>& Y) {
    ll N_dim = D.size();
    vector<ll> stride(N_dim + 1, 1);
    for (ll d = 0; d < N_dim; d++) {
        stride[d + 1] = stride[d] * D[d];
    }

    T ans = 0;
    // 包除原理: 2^N_dim 個の状態 (各次元について上限 Y[i] か 下限 X[i]-1 を選ぶか) を探索
    for (ll mask = 0; mask < (1LL << N_dim); mask++) {
        ll idx = 0;
        bool out_of_bounds = false;
        ll lower_count = 0; // 下限 (X[i]-1) を採用した次元の数

        for (ll i = 0; i < N_dim; i++) {
            ll p = 0;
            if ((mask >> i) & 1) {
                p = Y[i];
            } else {
                p = X[i] - 1;
                lower_count++;
            }

            // 下限が 0 未満になった場合は、その領域の和は 0 なのでスキップ
            if (p < 0) {
                out_of_bounds = true;
                break;
            }
            if (p >= D[i]) p = D[i] - 1;
            
            idx += p * stride[i];
        }

        if (out_of_bounds) continue;

        // 下限を採用した回数が奇数なら引き、偶数なら足す
        if (lower_count % 2 == 1) {
            ans -= a[idx];
        } else {
            ans += a[idx];
        }
    }
    return ans;
}

// 長さ M のタイムラインや配列を想定
vector<ll> table(M + 1, 0);

// Q回の区間加算: 区間 [l, r) に +1 をする
rep(i, Q) {
    ll l, r;
    cin >> l >> r;
    table[l]++;     // 始点に +1
    table[r]--;     // 終点の直後（半開区間の終端）に -1
}

// 最後に累積和をとることで、各点の実際の値を復元
rep(i, M) {
    table[i + 1] += table[i];
}

// 最終的に table[i] にはインデックス i に重なっている区間の数が格納される

template <typename T, typename F>
struct SparseTable {
    ll n;
    vector<vector<T>> table;
    vector<ll> log_table;
    F op; // 適用する二項演算 (min, max, gcd など)

    SparseTable() {}
    SparseTable(const vector<T>& v, F op) : op(op) {
        init(v);
    }

    // テーブルの初期化・構築
    void init(const vector<T>& v) {
        n = v.size();
        ll log_n = 0;
        while ((1LL << log_n) <= n) {
            log_n++;
        }
        
        table.assign(log_n, vector<T>(n));
        for (ll i = 0; i < n; i++) {
            table[0][i] = v[i];
        }
        
        for (ll i = 1; i < log_n; i++) {
            ll len = 1LL << (i - 1);
            for (ll j = 0; j + len * 2 <= n; j++) {
                table[i][j] = op(table[i - 1][j], table[i - 1][j + len]);
            }
        }
        
        log_table.assign(n + 1, 0);
        for (ll i = 2; i <= n; i++) {
            log_table[i] = log_table[i >> 1] + 1;
        }
    }

    // 半開区間 [l, r) に対するクエリ処理
    T query(ll l, ll r) {
        ll len = r - l;
        ll k = log_table[len];
        return op(table[k][l], table[k][r - (1LL << k)]);
    }
};

struct RangeSet {
    set<pair<ll, ll>> st; // {右端, 左端} で保持
    ll black_count = 0;   // 全体で黒く塗られているマスの総数

    // イテレータ (range-based for ループ用)
    auto begin() const { return st.begin(); }
    auto end() const { return st.end(); }
    auto rbegin() const { return st.rbegin(); }
    auto rend() const { return st.rend(); }

    // 閉区間 [l, r] を追加し、重なる・隣接する区間をマージする
    void insert(ll l, ll r) {
        auto it = st.lower_bound({l - 1, -1});
        while (it != st.end() && it->second <= r + 1) {
            ll prev_r = it->first;
            ll prev_l = it->second;
            l = min(l, prev_l);
            r = max(r, prev_r);
            black_count -= (prev_r - prev_l + 1);
            it = st.erase(it);
        }
        st.insert({r, l});
        black_count += (r - l + 1);
    }

    // 閉区間 [l, r] の範囲内で黒く塗られているマスの個数を返す
    ll query(ll l, ll r) const {
        ll res = 0;
        // l以上の右端を持つ最初の区間を検索
        auto it = st.lower_bound({l, -1});
        // 区間の左端が r 以下である限りループ
        while (it != st.end() && it->second <= r) {
            ll cur_r = min(r, it->first);
            ll cur_l = max(l, it->second);
            res += (cur_r - cur_l + 1);
            it++;
        }
        return res;
    }
};

struct RectangleUnion {
    struct Rect { long long l, r, d, u; };
    vector<Rect> rects;

    // 半開区間 [l, r) × [d, u) として長方形を追加 (l <= x < r, d <= y < u)
    void add_rectangle(long long l, long long r, long long d, long long u) {
        if (l < r && d < u) {
            rects.push_back({l, r, d, u});
        }
    }

    struct Result {
        long long area;
        long long perimeter;
        int max_overlap;
    };

    // 追加された長方形群の和集合の面積、周長、最大重なり数を計算する
    Result calculate() const {
        if (rects.empty()) return {0, 0, 0};

        // 平面走査を実行するラムダ式 (X方向・Y方向を切り替えて再利用)
        auto solve_scan = [](const vector<Rect>& rs, bool is_x) -> Result {
            struct Event {
                long long pos, l, r;
                int val;
                bool operator<(const Event& other) const {
                    return pos < other.pos;
                }
            };
            vector<Event> events;
            vector<long long> coords;
            for (const auto& r : rs) {
                long long pos1 = is_x ? r.l : r.d;
                long long pos2 = is_x ? r.r : r.u;
                long long range1 = is_x ? r.d : r.l;
                long long range2 = is_x ? r.u : r.r;
                events.push_back({pos1, range1, range2, 1});
                events.push_back({pos2, range1, range2, -1});
                coords.push_back(range1);
                coords.push_back(range2);
            }

            sort(coords.begin(), coords.end());
            coords.erase(unique(coords.begin(), coords.end()), coords.end());
            int n = coords.size() - 1;
            if (n <= 0) return {0, 0, 0};

            // セグメント木のデータ構造
            vector<int> count(4 * n, 0);       // 区間全体の被覆回数
            vector<long long> length(4 * n, 0); // 被覆されている長さ
            vector<int> comp(4 * n, 0);        // 被覆されている連結成分数
            vector<bool> l_act(4 * n, false);  // 左端が被覆されているか
            vector<bool> r_act(4 * n, false);  // 右端が被覆されているか
            vector<int> max_val(4 * n, 0);     // 区間内の最大被覆数

            auto update_node = [&](int node, int nl, int nr) {
                if (count[node] > 0) {
                    length[node] = coords[nr] - coords[nl];
                    comp[node] = 1;
                    l_act[node] = true;
                    r_act[node] = true;
                    max_val[node] = count[node];
                    if (nr - nl > 1) {
                        max_val[node] += max(max_val[2 * node + 1], max_val[2 * node + 2]);
                    }
                } else {
                    if (nr - nl == 1) {
                        length[node] = 0;
                        comp[node] = 0;
                        l_act[node] = false;
                        r_act[node] = false;
                        max_val[node] = 0;
                    } else {
                        length[node] = length[2 * node + 1] + length[2 * node + 2];
                        comp[node] = comp[2 * node + 1] + comp[2 * node + 2];
                        if (r_act[2 * node + 1] && l_act[2 * node + 2]) {
                            comp[node]--; // 境界で連結成分が繋がる場合
                        }
                        l_act[node] = l_act[2 * node + 1];
                        r_act[node] = r_act[2 * node + 2];
                        max_val[node] = max(max_val[2 * node + 1], max_val[2 * node + 2]);
                    }
                }
            };

            auto apply = [&](auto& self, int l, int r, int val, int node, int nl, int nr) -> void {
                if (l >= nr || r <= nl) return;
                if (l <= nl && nr <= r) {
                    count[node] += val;
                } else {
                    int mid = nl + (nr - nl) / 2;
                    self(self, l, r, val, 2 * node + 1, nl, mid);
                    self(self, l, r, val, 2 * node + 2, mid, nr);
                }
                update_node(node, nl, nr);
            };

            sort(events.begin(), events.end());
            auto get_idx = [&](long long v) {
                return lower_bound(coords.begin(), coords.end(), v) - coords.begin();
            };

            long long area = 0;
            long long perimeter_part = 0;
            int max_overlap = 0;
            long long prev_pos = events[0].pos;

            for (size_t i = 0; i < events.size(); ) {
                long long curr_pos = events[i].pos;
                long long delta = curr_pos - prev_pos;
                
                area += length[0] * delta;
                perimeter_part += (long long)comp[0] * 2LL * delta; // 進行方向と平行な境界線の長さ
                
                while (i < events.size() && events[i].pos == curr_pos) {
                    int l_idx = get_idx(events[i].l);
                    int r_idx = get_idx(events[i].r);
                    if (l_idx < r_idx) {
                        apply(apply, l_idx, r_idx, events[i].val, 0, 0, n);
                    }
                    i++;
                }
                max_overlap = max(max_overlap, max_val[0]);
                prev_pos = curr_pos;
            }
            return Result{area, perimeter_part, max_overlap};
        };

        Result res_x = solve_scan(rects, true);  // X軸方向走査 (面積, 横枠の周長, 最大重なり)
        Result res_y = solve_scan(rects, false); // Y軸方向走査 (面積, 縦枠の周長, 最大重なり)

        return Result{
            res_x.area, 
            res_x.perimeter + res_y.perimeter, // 縦横の境界線の和が全体の周長
            res_x.max_overlap
        };
    }
};

// Cartesian Tree の構造体
struct CartesianTree {
    ll root;             // 根となるインデックス
    vector<ll> p;        // p[i] は i の親（親がない場合は -1）
    vector<ll> l, r;     // l[i], r[i] はそれぞれ i の左の子、右の子（ない場合は -1）

    // 構造体の初期化 O(N)
    // is_min = true の場合: 区間の最小値が根になる（Min-Cartesian Tree）
    // is_min = false の場合: 区間の最大値が根になる（Max-Cartesian Tree）
    CartesianTree(const vector<ll>& a, bool is_min = true) {
        ll n = a.size();
        p.assign(n, -1);
        l.assign(n, -1);
        r.assign(n, -1);
        
        vector<ll> st; // 右側のスパイン（根から右の子を辿ったパス）を管理するスタック
        for (ll i = 0; i < n; ++i) {
            ll last = -1;
            // Min木なら a[st.back()] > a[i] の間ポップ
            // Max木なら a[st.back()] < a[i] の間ポップ
            while (!st.empty() && (is_min ? a[st.back()] > a[i] : a[st.back()] < a[i])) {
                last = st.back();
                st.pop_back();
            }
            if (!st.empty()) {
                r[st.back()] = i;
                p[i] = st.back();
            }
            if (last != -1) {
                l[i] = last;
                p[last] = i;
            }
            st.push_back(i);
        }
        root = st.empty() ? -1 : st[0];
    }
};

#include <vector>
#include <optional>
#include <algorithm>

using namespace std;

struct Point {
    long long x, y;
};

class AdvancedHistogramConvexHull {
private:
    vector<Point> upper_hull;

    // 3点の外積。負なら右回り(時計回り)、正なら左回り(反時計回り)
    long long cross_product(Point p1, Point p2, Point p3) const {
        return (p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x);
    }

public:
    // 点を追加し、直結した（削除されずに残った最も右の）点を返す
    // 最初の点の追加時など、直結点がない場合は std::nullopt を返す
    std::optional<Point> add_point(long long x, long long h) {
        Point p = {x, h};
        
        while (upper_hull.size() >= 2) {
            Point p1 = upper_hull[upper_hull.size() - 2];
            Point p2 = upper_hull[upper_hull.size() - 1];
            if (cross_product(p1, p2, p) >= 0) {
                upper_hull.pop_back(); // 凹んでいるので削除
            } else {
                break;
            }
        }
        
        std::optional<Point> connected_point = std::nullopt;
        if (!upper_hull.empty()) {
            connected_point = upper_hull.back(); // 削除されずに残った最も右の点
        }
        
        upper_hull.push_back(p);
        return connected_point;
    }

    // 上側凸包を構成する点の一覧（左から右への順序）を取得
    const vector<Point>& get_upper_hull() const {
        return upper_hull;
    }

    // 全体の凸包を構成する点の一覧を反時計回り(CCW)で取得
    vector<Point> get_full_hull() const {
        if (upper_hull.empty()) return {};
        
        vector<Point> hull;
        // 内部では上側の点しか管理していないので、底面 (y=0) をここで補完する
        hull.push_back({upper_hull.front().x, 0}); // 左下の点
        if (upper_hull.back().x != upper_hull.front().x) {
            hull.push_back({upper_hull.back().x, 0}); // 右下の点
        }
        
        // 上側凸包を右から左へ辿ることで、反時計回りに閉じる
        for (int i = upper_hull.size() - 1; i >= 0; --i) {
            hull.push_back(upper_hull[i]);
        }
        return hull;
    }

    // 便利機能1: 現在の凸包の面積の 2倍 を返す (整数のまま計算するため)
    // 実面積が必要な場合は 2.0 で割る
    long long get_area_x2() const {
        vector<Point> hull = get_full_hull();
        long long area = 0;
        int n = hull.size();
        for (int i = 0; i < n; ++i) {
            area += (hull[i].x * hull[(i + 1) % n].y - hull[(i + 1) % n].x * hull[i].y);
        }
        return abs(area);
    }

    // 便利機能2: 傾き `slope` の直線 y = slope * x + b が凸包と接するときの最大切片 b を求める
    // Convex Hull Trick (CHT) における最大値検索 (二分探索により O(log N))
    long long get_max_intercept(long long slope) const {
        if (upper_hull.empty()) return 0;
        
        int left = 0, right = upper_hull.size() - 1;
        while (right - left >= 3) {
            int m1 = left + (right - left) / 3;
            int m2 = right - (right - left) / 3;
            long long v1 = upper_hull[m1].y - slope * upper_hull[m1].x;
            long long v2 = upper_hull[m2].y - slope * upper_hull[m2].x;
            if (v1 < v2) {
                left = m1;
            } else {
                right = m2;
            }
        }
        
        long long max_val = upper_hull[left].y - slope * upper_hull[left].x;
        for (int i = left + 1; i <= right; ++i) {
            max_val = max(max_val, upper_hull[i].y - slope * upper_hull[i].x);
        }
        return max_val;
    }
};

long long largestRectangleArea(const vector<long long>& h) {
    int n = h.size();
    stack<pair<long long, int>> st; // {高さ, 左端の位置}
    long long max_area = 0;

    for (int i = 0; i < n; ++i) {
        int left_pos = i;
        // スタックのトップにある長方形の高さが現在の高さ以上なら、それ以上右に伸ばせない
        while (!st.empty() && st.top().first >= h[i]) {
            auto [ph, pos] = st.top();
            st.pop();
            max_area = max(max_area, ph * (i - pos));
            left_pos = pos;
        }
        st.push({h[i], left_pos});
    }

    // スタックに残っている要素（右端まで伸ばせる要素）の処理
    while (!st.empty()) {
        auto [ph, pos] = st.top();
        st.pop();
        max_area = max(max_area, ph * (n - pos));
    }

    return max_area;
}

long long maximalRectangle(const vector<string>& grid) {
    if (grid.empty() || grid[0].empty()) return 0;
    int h = grid.size();
    int w = grid[0].size();

    // 1次元ヒストグラムの最大長方形を求めるヘルパー関数 (O(W))
    auto largestRectangleArea = [](const vector<long long>& height) {
        int n = height.size();
        stack<pair<long long, int>> st; // {高さ, 左端の位置}
        long long max_area = 0;

        for (int i = 0; i < n; ++i) {
            int left_pos = i;
            while (!st.empty() && st.top().first >= height[i]) {
                auto [ph, pos] = st.top();
                st.pop();
                max_area = max(max_area, ph * (i - pos));
                left_pos = pos;
            }
            st.push({height[i], left_pos});
        }
        while (!st.empty()) {
            auto [ph, pos] = st.top();
            st.pop();
            max_area = max(max_area, ph * (n - pos));
        }
        return max_area;
    };

    vector<long long> hist(w, 0);
    long long max_area = 0;

    // 行ごとにヒストグラムを更新しながら最大値を求める
    for (int r = 0; r < h; ++r) {
        for (int c = 0; c < w; ++c) {
            if (grid[r][c] == '.') {
                hist[c]++;
            } else {
                hist[c] = 0; // 障害物でリセット
            }
        }
        max_area = max(max_area, largestRectangleArea(hist));
    }

    return max_area;
}

// 前提 : UnionFind, atcoder::segtree

// セグメント木に乗せる型：{値(x+y), 頂点番号}
using S = pair<ll, int>;
S op(S a, S b) { return min(a, b); }
S e() { return {4e18, -1}; } // 無限大と無効な頂点番号

// Manhattan MST の辺の候補 (O(N)本) を列挙する関数
vector<pair<ll, pair<int, int>>> manhattan_mst_edges(vector<pair<ll, ll>> ps) {
    int n = ps.size();
    vector<int> id(n);
    iota(id.begin(), id.end(), 0);
    vector<pair<ll, pair<int, int>>> edges;

    // 対称性を利用して4方向の最隣接点を探索
    for (int s = 0; s < 2; s++) {
        for (int t = 0; t < 2; t++) {
            auto cmp = [&](int i, int j) {
                return ps[i] > ps[j];
            };
            sort(id.begin(), id.end(), cmp);

            // y - x で座標圧縮
            vector<ll> ys(n);
            for (int i = 0; i < n; i++) ys[i] = ps[i].second - ps[i].first;
            sort(ys.begin(), ys.end());
            ys.erase(unique(ys.begin(), ys.end()), ys.end());

            atcoder::segtree<S, op, e> seg(ys.size());
            for (int i : id) {
                int y_idx = lower_bound(ys.begin(), ys.end(), ps[i].second - ps[i].first) - ys.begin();
                S res = seg.prod(y_idx, ys.size());
                if (res.second != -1) {
                    ll w = abs(ps[i].first - ps[res.second].first) + abs(ps[i].second - ps[res.second].second);
                    edges.push_back({w, {i, res.second}});
                }
                seg.set(y_idx, min(seg.get(y_idx), {ps[i].first + ps[i].second, i}));
            }
            // y軸反転
            for (int i = 0; i < n; i++) ps[i].second = -ps[i].second;
        }
        // x軸とy軸を入れ替え
        for (int i = 0; i < n; i++) swap(ps[i].first, ps[i].second);
    }
    return edges;
}

// Manhattan MST本体
// 返り値: {MSTの重みの総和, 使用した辺(u, v)のリスト}
pair<ll, vector<pair<int, int>>> manhattan_mst(const vector<pair<ll, ll>>& ps) {
    auto edges = manhattan_mst_edges(ps);
    // 重みの昇順にソート (Kruskal法)
    sort(edges.begin(), edges.end());
    
    int n = ps.size();
    UnionFind uf(n); // 前提としているUnionFindを使用
    ll total_weight = 0;
    vector<pair<int, int>> mst_edges;
    
    for (auto& edge : edges) {
        ll w = edge.first;
        int u = edge.second.first;
        int v = edge.second.second;
        // 異なるグループなら繋ぐ
        if (uf.unite(u, v)) {
            total_weight += w;
            mst_edges.push_back({u, v});
        }
    }
    return {total_weight, mst_edges};
}

// 前提 : UnionFind (uf.unite(u, v) などが実装されていること)
// 前提 : 座標はすべて相異なるものとします (重複がある場合は事前に取り除く)

namespace Delaunay {
    using lll = __int128_t; // オーバーフロー防止用の128bit整数

    struct Point {
        ll x, y;
        int id;
    };

    lll cross(Point a, Point b, Point c) {
        return (lll)(b.x - a.x) * (c.y - a.y) - (lll)(b.y - a.y) * (c.x - a.x);
    }

    // pがa,b,cの外接円の内部にあるか判定
    bool inCircle(Point a, Point b, Point c, Point p) {
        lll adx = a.x - p.x, ady = a.y - p.y;
        lll bdx = b.x - p.x, bdy = b.y - p.y;
        lll cdx = c.x - p.x, cdy = c.y - p.y;
        lll abdet = adx * bdy - bdx * ady;
        lll bcdet = bdx * cdy - cdx * bdy;
        lll cadet = cdx * ady - adx * cdy;
        lll alift = adx * adx + ady * ady;
        lll blift = bdx * bdx + bdy * bdy;
        lll clift = cdx * cdx + cdy * cdy;
        return alift * bcdet + blift * cadet + clift * abdet > 0;
    }

    struct Triangle {
        int p[3];
        int adj[3]; // adj[i] は p[i] の対辺を共有する三角形のID
        vector<int> children;
        bool dead;
        Triangle() {}
        Triangle(int a, int b, int c) {
            p[0] = a; p[1] = b; p[2] = c;
            adj[0] = adj[1] = adj[2] = -1;
            dead = false;
        }
    };

    vector<Point> pts;
    vector<Triangle> tr;

    bool contains(int tid, int pid) {
        for (int i = 0; i < 3; ++i) {
            if (cross(pts[tr[tid].p[i]], pts[tr[tid].p[(i + 1) % 3]], pts[pid]) < 0) return false;
        }
        return true;
    }

    vector<pair<int, int>> build_delaunay(const vector<pair<ll, ll>>& points) {
        int n = points.size();
        if (n <= 1) return {};
        pts.clear();
        for (int i = 0; i < n; ++i) pts.push_back({points[i].first, points[i].second, i});
        
        // 全点を包含する巨大なスーパー三角形を配置
        ll INF = 3e9; // 座標の最大値が10^9程度であることを想定
        pts.push_back({0, INF, n});
        pts.push_back({-INF, -INF, n + 1});
        pts.push_back({INF, -INF, n + 2});
        
        tr.clear();
        tr.push_back(Triangle(n, n + 1, n + 2));
        
        vector<int> perm(n);
        iota(perm.begin(), perm.end(), 0);
        mt19937 rand_engine(42);
        shuffle(perm.begin(), perm.end(), rand_engine);

        vector<int> visited_gen;
        
        for (int i = 0; i < n; ++i) {
            int pid = perm[i];
            
            // 1. History DAG を用いて包含する葉三角形を検索 (期待値 O(log N))
            int curr = 0;
            while (tr[curr].children.size() > 0) {
                bool found = false;
                for (int child : tr[curr].children) {
                    if (!tr[child].dead && contains(child, pid)) {
                        curr = child; found = true; break;
                    }
                }
                // 丸め誤差等へのフォールバック
                if (!found) {
                    for (int child : tr[curr].children) {
                        if (contains(child, pid)) { curr = child; found = true; break; }
                    }
                    if (!found) curr = tr[curr].children[0];
                }
            }
            
            // 2. 新たな点が外接円に含まれる三角形 (bad triangles) をBFSで探索
            vector<int> bad;
            vector<int> q;
            q.push_back(curr);
            
            if (visited_gen.size() < tr.size() + 100) {
                visited_gen.resize(max((int)tr.size() + 1000, 100000), 0);
            }
            int gen = i + 1;
            visited_gen[curr] = gen;
            
            int head = 0;
            while (head < (int)q.size()) {
                int t = q[head++];
                bad.push_back(t);
                for (int j = 0; j < 3; ++j) {
                    int nxt = tr[t].adj[j];
                    if (nxt != -1 && visited_gen[nxt] != gen) {
                        visited_gen[nxt] = gen;
                        if (inCircle(pts[tr[nxt].p[0]], pts[tr[nxt].p[1]], pts[tr[nxt].p[2]], pts[pid])) {
                            q.push_back(nxt);
                        } else {
                            visited_gen[nxt] = 0; // 条件外なら訪問フラグをリセット
                        }
                    }
                }
            }
            
            // 3. 空洞の境界エッジを抽出
            struct BoundaryEdge { int u, v, out_tri, old_bad; };
            vector<BoundaryEdge> bnd;
            for (int t : bad) {
                for (int j = 0; j < 3; ++j) {
                    int nxt = tr[t].adj[j];
                    if (nxt == -1 || visited_gen[nxt] != gen) {
                        bnd.push_back({tr[t].p[(j + 1) % 3], tr[t].p[(j + 2) % 3], nxt, t});
                    }
                }
            }
            
            // 4. 空洞を新たな三角形群で再分割
            int first_new = tr.size();
            for (int j = 0; j < (int)bnd.size(); ++j) {
                Triangle nt(pid, bnd[j].u, bnd[j].v);
                nt.adj[0] = bnd[j].out_tri;
                // 外部の三角形からの隣接リンクを更新
                if (bnd[j].out_tri != -1) {
                    Triangle& out = tr[bnd[j].out_tri];
                    for (int k = 0; k < 3; ++k) {
                        if (out.adj[k] == bnd[j].old_bad) {
                            out.adj[k] = first_new + j;
                            break;
                        }
                    }
                }
                // 新しい三角形同士を内部でリンク
                for (int k = 0; k < (int)bnd.size(); ++k) {
                    if (bnd[k].u == bnd[j].v) nt.adj[1] = first_new + k;
                    if (bnd[k].v == bnd[j].u) nt.adj[2] = first_new + k;
                }
                tr.push_back(nt);
            }
            
            // 5. History DAG の更新
            for (int t : bad) {
                tr[t].dead = true;
                for (int j = 0; j < (int)bnd.size(); ++j) {
                    tr[t].children.push_back(first_new + j);
                }
            }
        }
        
        // 最終的なドロネー網のエッジを抽出
        vector<pair<int, int>> edges;
        for (auto& t : tr) {
            if (!t.dead) {
                for (int i = 0; i < 3; ++i) {
                    int u = t.p[i], v = t.p[(i + 1) % 3];
                    if (u < n && v < n && u < v) {
                        edges.push_back({u, v});
                    }
                }
            }
        }
        sort(edges.begin(), edges.end());
        edges.erase(unique(edges.begin(), edges.end()), edges.end());
        return edges;
    }
}

// Euclidean MST本体
// 返り値: {MSTの重みの総和, 使用した辺(u, v)のリスト}
pair<double, vector<pair<int, int>>> euclidean_mst(const vector<pair<ll, ll>>& ps) {
    int n = ps.size();
    if (n <= 1) return {0.0, {}};
    
    // ドロネー三角形分割を用いて辺候補を O(N) 本に削減
    auto edges = Delaunay::build_delaunay(ps);
    
    // Kruskal法: 重みは平方で正確にソート (浮動小数点誤差を防ぐ)
    vector<pair<ll, pair<int, int>>> weighted_edges;
    for (auto& edge : edges) {
        int u = edge.first;
        int v = edge.second;
        ll dx = ps[u].first - ps[v].first;
        ll dy = ps[u].second - ps[v].second;
        ll w2 = dx * dx + dy * dy;
        weighted_edges.push_back({w2, {u, v}});
    }
    
    sort(weighted_edges.begin(), weighted_edges.end());

    UnionFind uf(n); // 前提としているUnionFindを使用
    double total_weight = 0;
    vector<pair<int, int>> mst_edges;

    for (auto& edge : weighted_edges) {
        ll w2 = edge.first;
        int u = edge.second.first;
        int v = edge.second.second;
        // 異なるグループなら繋ぐ
        if (uf.unite(u, v)) {
            total_weight += sqrt((double)w2);
            mst_edges.push_back({u, v});
        }
    }
    return {total_weight, mst_edges};
}

#include <utility>

struct GridPathMatching {
    using Cell = std::pair<int, int>;
    using Edge = std::pair<Cell, Cell>;

    // N×N グリッドの全マスを通る一筆書き経路（Nが偶数なら元のマスに戻れる閉路）を返す
    static std::vector<Cell> get_hamiltonian_path(int N) {
        std::vector<Cell> path;
        if (N <= 0) return path;
        path.reserve(N * N);
        
        if (N % 2 == 0) {
            for (int c = 0; c < N; ++c) path.push_back({0, c});
            for (int r = 1; r < N; ++r) {
                if (r % 2 == 1) for (int c = N - 1; c >= 1; --c) path.push_back({r, c});
                else            for (int c = 1; c < N; ++c) path.push_back({r, c});
            }
            for (int r = N - 1; r >= 1; --r) path.push_back({r, 0});
        } else {
            for (int r = 0; r < N; ++r) {
                if (r % 2 == 0) for (int c = 0; c < N; ++c) path.push_back({r, c});
                else            for (int c = N - 1; c >= 0; --c) path.push_back({r, c});
            }
        }
        return path;
    }

    // N×N グリッドの最大マッチング（ペアのリスト）を返す
    // missing_r, missing_c を指定すると、その1マスを除外したマッチングを構築
    static std::vector<Edge> get_max_matching(int N, int missing_r = -1, int missing_c = -1) {
        std::vector<Edge> res;
        if (N <= 0) return res;
        auto path = get_hamiltonian_path(N);
        int total = N * N;

        if (missing_r < 0 || missing_c < 0) {
            for (int i = 0; i + 1 < total; i += 2) res.push_back({path[i], path[i + 1]});
        } else {
            int idx = -1;
            for (int i = 0; i < total; ++i) {
                if (path[i].first == missing_r && path[i].second == missing_c) {
                    idx = i; break;
                }
            }
            if (idx != -1) {
                if (N % 2 == 0) {
                    for (int i = 0; i < total - 2; i += 2) {
                        res.push_back({path[(idx + 1 + i) % total], path[(idx + 2 + i) % total]});
                    }
                } else {
                    for (int i = 0; i + 1 < idx; i += 2) res.push_back({path[i], path[i + 1]});
                    for (int i = idx + 1; i + 1 < total; i += 2) res.push_back({path[i], path[i + 1]});
                }
            }
        }
        return res;
    }

    // 各マスの「マッチング先のマス」をO(1)で引ける二次元配列 (N×N) を作成して返す
    // ペアが存在しないマス（欠損マスや余ったマス）には {-1, -1} が入る
    static std::vector<std::vector<Cell>> get_matching_table(int N, int missing_r = -1, int missing_c = -1) {
        std::vector<std::vector<Cell>> table(N, std::vector<Cell>(N, {-1, -1}));
        auto edges = get_max_matching(N, missing_r, missing_c);
        for (auto [u, v] : edges) {
            table[u.first][u.second] = v;
            table[v.first][v.second] = u;
        }
        return table;
    }
};

// 前提：階乗および組み合わせの mod 計算 (init_nCr, nCr) が定義・初期化されていること
using ll = long long;

struct Point {
    ll r, c;
    bool operator<(const Point& other) const {
        if (r != other.r) return r < other.r;
        return c < other.c;
    }
};

// 2点間の経路数 (障害物無視)
ll count_paths(Point from, Point to, long long mod) {
    if (from.r > to.r || from.c > to.c) return 0;
    ll dr = to.r - from.r;
    ll dc = to.c - from.c;
    return nCr(dr + dc, dr, mod);
}

// 障害物回避DPのメイン処理
// start: スタート座標, goal: ゴール座標, obstacles: 障害物リスト
ll obstacle_avoidance_dp(Point start, Point goal, vector<Point> obstacles, long long mod) {
    // 障害物を座標順 (行 -> 列) にソート
    sort(obstacles.begin(), obstacles.end());

    // ゴールを最終目的地として障害物リストの最後に追加
    obstacles.push_back(goal);
    int K = obstacles.size();

    // dp[i]: 他の障害物を一切踏まずに、初めて障害物 i に到達する経路数
    vector<long long> dp(K, 0);

    for (int i = 0; i < K; i++) {
        // スタートから障害物 i への全経路数
        dp[i] = count_paths(start, obstacles[i], mod);

        // 途中で他の障害物 j にぶつかった場合を引く (包除原理)
        for (int j = 0; j < i; j++) {
            // j から i へ到達可能か判定 (ソート済みなので r_j <= r_i は保証。列のみ確認)
            if (obstacles[j].c <= obstacles[i].c) {
                long long invalid_paths = dp[j] * count_paths(obstacles[j], obstacles[i], mod) % mod;
                dp[i] = (dp[i] - invalid_paths + mod) % mod;
            }
        }
    }

    // ゴール (K-1番目) への合法な経路数が答え
    return dp[K - 1];
}

// 巡回セールスマン問題の遷移例
vector<vector<long long>> dp(1 << N, vector<long long>(N, INF));
dp[1][0] = 0; // 開始点
for (ll S = 1; S < (1 << N); S++) {
    for (ll v = 0; v < N; v++) {
        if (dp[S][v] == INF) continue;
        for (ll u = 0; u < N; u++) {
            if (!(S & (1 << u))) { // uが未訪問の場合
                dp[S | (1 << u)][u] = min(dp[S | (1 << u)][u], dp[S][v] + cost[v][u]);
            }
        }
    }
}

// 集合 S を部分集合 sub と (S ^ sub) に分割して最適化する例
vector<long long> dp(1LL << N, INF);
dp[0] = 0; // 初期値

for (long long S = 1; S < (1LL << N); S++) {
    // S の非空部分集合 sub を降順にすべて走査
    for (long long sub = S; sub > 0; sub = (sub - 1) & S) {
        dp[S] = min(dp[S], dp[S ^ sub] + cost[sub]);
    }
}

// N以下の条件を満たす数を数える桁DPの遷移例
// 桁DPの配列はサイズに変数が使えないため、関数の外（グローバル）で定数サイズで宣言する
const ll MAX_D = 100005; // 想定される最大桁数
const ll MAX_J = 100;    // 状態jの最大値
ll dp[MAX_D][2][2][MAX_J]; // dp[i][smaller][leading_zero][j]

void solve() {
    string N; // 桁数が大きい場合は文字列として受け取る
    ll D = N.size();

    // 複数テストケースなどで初期化が必要な場合は memset を使う
    memset(dp, 0, sizeof(dp));
    dp[0][0][1][0] = 1;

    for (ll i = 0; i < D; i++) {
        ll Nd = N[i] - '0';

        for (ll smaller = 0; smaller < 2; smaller++) {
            for (ll leading_zero = 0; leading_zero < 2; leading_zero++) {
                for (ll j = 0; j < MAX_J; j++) {
                    if (dp[i][smaller][leading_zero][j] == 0) continue;

                    ll limit = smaller ? 9 : Nd;
                    for (ll d = 0; d <= limit; d++) {
                        ll next_smaller = smaller || (d < Nd);
                        ll next_leading_zero = leading_zero && (d == 0);

                        // leading_zero を考慮して状態更新
                        ll next_j = /* jとdから次の状態を計算 */ j;

                        dp[i + 1][next_smaller][next_leading_zero][next_j]
                            += dp[i][smaller][leading_zero][j];
                    }
                }
            }
        }
    }
}

// v: 現在の頂点, p: 親頂点, G: グラフ, dp: DPテーブル
void dfs(ll v, ll p, const vvl& G, vvl& dp) {
    // 初期化（頂点 v 単体の状態を設定）
    dp[v][0] = 0; // 例: 頂点 v を選ばない場合
    dp[v][1] = 1; // 例: 頂点 v を選ぶ場合

    for (ll u : G[v]) {
        if (u == p) continue; // 親ノードへの逆走防止

        // 行きがけ: 子ノード u の DP を先に再帰計算
        dfs(u, v, G, dp);

        // 帰りがけ処理（遷移式: 子 u の結果をもとに親 v の DP を更新）
        dp[v][0] += max(dp[u][0], dp[u][1]);
        dp[v][1] += dp[u][0];
    }
}

// 1回目のDFS: 頂点 v を根とする「部分木」の DP 値をボトムアップに計算
void dfs1(ll v, ll p, const vvl& G, vvl& dp1) {
    dp1[v][0] = 1; // 初期化

    for (ll u : G[v]) {
        if (u == p) continue; // 親ノードへの逆走防止

        dfs1(u, v, G, dp1);

        // 【帰りがけ遷移】子 u の部分木結果を親 v に集約
        dp1[v][0] = (dp1[v][0] * (dp1[u][0] + 1)) % M;
    }
}

// 2回目のDFS: 親方向（部分木の外側）からの DP 値をトップダウンに伝播
void dfs2(ll v, ll p, const vvl& G, const vvl& dp1, vvl& dp2) {
    ll prod = 1;
    vl children;

    // 前向き走査: 左（手前）からの累積値を計算しながら各子へ掛ける
    for (ll u : G[v]) {
        if (u == p) continue;
        dp2[u][0] = (dp2[u][0] * prod) % M;
        prod = (prod * (dp1[u][0] + 1)) % M;
        children.push_back(u);
    }

    // 順序を反転して後ろ向き走査の準備
    reverse(children.begin(), children.end());

    // 親からの DP 値（dp2[v]）を含めた右（奥）からの累積値
    prod = (dp2[v][0] + 1) % M;

    for (ll u : children) {
        dp2[u][0] = (dp2[u][0] * prod) % M;
        prod = (prod * (dp1[u][0] + 1)) % M;

        // 子ノード u へ再帰伝播
        dfs2(u, v, G, dp1, dp2);
    }
}

// 最長増加部分列（LIS）の長さと復元
ll N;
// Aは入力配列
vector<ll> A(N);

vector<ll> dp;
vector<ll> subseq_idx(N); // 各要素が LIS 内のどの位置(0-indexed)に対応するかを保持

for (ll i = 0; i < N; i++) {
    // 二分探索で挿入位置を特定する
    auto it = lower_bound(dp.begin(), dp.end(), A[i]);
    ll idx = distance(dp.begin(), it);
    if (it == dp.end()) {
        dp.push_back(A[i]);
    } else {
        *it = A[i];
    }
    subseq_idx[i] = idx;
}

ll ans = dp.size(); // LIS の長さ

// LIS の復元（後ろから走査）
vector<ll> lis(ans);
ll cur_len = ans - 1;
for (ll i = N - 1; i >= 0; i--) {
    if (subseq_idx[i] == cur_len) {
        lis[cur_len] = A[i];
        cur_len--;
    }
}

// セグメント木に乗せる型: pair<最大重み, 組み合わせの数>
using S = pair<ll, ll>;
const ll MOD = 998244353; // 個数を数える際の法（問題に合わせて変更）

// 二項演算: 重みが大きい方を採用。同じなら個数を足し合わせる
S op(S a, S b) {
    if (a.first > b.first) return a;
    if (a.first < b.first) return b;
    return {a.first, (a.second + b.second) % MOD};
}

// 単位元
S e() {
    return {-1e18, 0};
}

void solve() {
    ll N;
    cin >> N;
    // Hは要素の値（あらかじめ 1 以上 N 以下に座標圧縮されているとする）
    // Aはそれぞれの重み（価値）
    vector<ll> H(N), A(N);
    for (int i = 0; i < N; i++) cin >> H[i];
    for (int i = 0; i < N; i++) cin >> A[i];

    // 値の最大値に合わせて初期化（H[i] が N 以下の前提）
    segtree<S, op, e> seg(N + 1);
    
    // 初期状態：長さ0の増加部分列（重み0、個数1）を仮想的に値0の位置に置く
    seg.set(0, {0, 1});

    for (int i = 0; i < N; i++) {
        // 自身より小さい値（0 〜 H[i] - 1）の範囲の最大重みと個数を取得
        S mx = seg.prod(0, H[i]);
        
        ll new_weight = mx.first + A[i];
        ll new_count = mx.second;

        // 現在の H[i] での（最大重み, 個数）を取得し、新しい候補とマージして更新
        S cur = seg.get(H[i]);
        seg.set(H[i], op(cur, {new_weight, new_count}));
    }
    
    // 全体の最大重みとその個数を取得
    S ans = seg.prod(0, N + 1);
    cout << "最大重み: " << ans.first << endl;
    cout << "個数: " << ans.second << endl;
}

// 2次元最長増加部分列の長さを求める
ll N;
vector<pair<ll, ll>> points(N); // {x, y}

// xの昇順、xが等しい場合はyの降順にソートする
sort(points.begin(), points.end(), [](const pair<ll, ll>& a, const pair<ll, ll>& b) {
    if (a.first != b.first) return a.first < b.first;
    return a.second > b.second;
});

vector<ll> dp;
for (ll i = 0; i < N; i++) {
    ll y = points[i].second;
    auto it = lower_bound(dp.begin(), dp.end(), y);
    if (it == dp.end()) {
        dp.push_back(y);
    } else {
        *it = y;
    }
}
ll ans = dp.size();

// 【基本構造】0-1ナップサック問題

// 1. 重さDP (Wが小さい場合: W <= 10^5 程度)
// dp[i] : 重さの合計が i 以下のときの価値の最大値
ll knapsack_weight_dp(const vector<ll>& weights, const vector<ll>& values, ll W) {
    int n = weights.size();
    vector<ll> dp(W + 1, 0);
    for (int i = 0; i < n; ++i) {
        // 重さが大きい方から更新する（同じ品物を複数回選ばないため）
        for (ll w = W; w >= weights[i]; --w) {
            dp[w] = max(dp[w], dp[w - weights[i]] + values[i]);
        }
    }
    return dp[W];
}

// 2. 価値DP (Vの合計が小さい場合: sum(V) <= 10^5 程度)
// dp[i] : 価値の合計が i のときの重さの最小値
ll knapsack_value_dp(const vector<ll>& weights, const vector<ll>& values, ll W) {
    int n = weights.size();
    ll max_v_sum = 0;
    for (ll v : values) max_v_sum += v;

    const ll INF = 1e18; // 十分大きい値
    vector<ll> dp(max_v_sum + 1, INF);
    dp[0] = 0;

    for (int i = 0; i < n; ++i) {
        for (ll v = max_v_sum; v >= values[i]; --v) {
            if (dp[v - values[i]] != INF) {
                dp[v] = min(dp[v], dp[v - values[i]] + weights[i]);
            }
        }
    }

    ll res = 0;
    for (ll v = 0; v <= max_v_sum; ++v) {
        if (dp[v] <= W) res = max(res, v);
    }
    return res;
}

// 【基本構造】通常の部分和問題 (O(NS))
// dp[i] : 和 i を作れるかどうかの真偽値
vector<bool> subset_sum_basic(const vector<ll>& A, ll S) {
    int n = A.size();
    vector<bool> dp(S + 1, false);
    dp[0] = true; // 0は何も選ばなければ作れる

    for (int i = 0; i < n; ++i) {
        // 同じ要素を複数回選ばないよう、後ろから更新する
        for (ll j = S; j >= A[i]; --j) {
            if (dp[j - A[i]]) {
                dp[j] = true;
            }
        }
    }
    return dp;
}

vector<long long> memo(n + 1, -1);

long long fib(ll n) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n];
    return memo[n] = fib(n - 1) + fib(n - 2);
}

ll H, W;
vector<vector<ll>> grid;
vector<vector<long long>> memo;

long long dfs(ll r, ll c) {
    if (r == H - 1 && c == W - 1) return 1; // ゴールに到達
    if (memo[r][c] != -1) return memo[r][c];
    
    long long res = 0;
    if (c + 1 < W) res += dfs(r, c + 1); // 右へ移動
    if (r + 1 < H) res += dfs(r + 1, c); // 下へ移動
    
    return memo[r][c] = res;
}

map<long long, long long> memo;

long long solve(long long n) {
    if (n == 0) return 0;
    if (memo.count(n)) return memo[n];
    
    // 遷移例: solve(n) = solve(n / 2) + solve(n / 3) + n
    long long res = solve(n / 2) + solve(n / 3) + n;
    return memo[n] = res;
}

#include <atcoder/all>
using namespace std;
using namespace atcoder;
using mint = modint998244353;

#include <complex>
#include <cmath>
using C = complex<double>;

void fft(vector<C>& a, bool invert) {
    int n = a.size();
    for (int i = 1, j = 0; i < n; i++) {
        int bit = n >> 1;
        for (; j & bit; bit >>= 1) j ^= bit;
        j ^= bit;
        if (i < j) swap(a[i], a[j]);
    }
    for (int len = 2; len <= n; len <<= 1) {
        double ang = 2 * M_PI / len * (invert ? -1 : 1);
        C wlen(cos(ang), sin(ang));
        for (int i = 0; i < n; i += len) {
            C w(1);
            for (int j = 0; j < len / 2; j++) {
                C u = a[i + j];
                C v = a[i + j + len / 2] * w;
                a[i + j] = u + v;
                a[i + j + len / 2] = u - v;
                w *= wlen;
            }
        }
    }
    if (invert) {
        for (C& x : a) x /= n;
    }
}

vector<double> convolution_fft(const vector<double>& a, const vector<double>& b) {
    vector<C> fa(a.begin(), a.end()), fb(b.begin(), b.end());
    int n = 1;
    while (n < a.size() + b.size()) n <<= 1;
    fa.resize(n); fb.resize(n);
    
    fft(fa, false);
    fft(fb, false);
    for (int i = 0; i < n; i++) fa[i] *= fb[i];
    fft(fa, true);
    
    vector<double> res(n);
    for (int i = 0; i < n; i++) res[i] = fa[i].real();
    return res;
}

// 下位集合に関する高速ゼータ変換 (OR畳み込みの前処理)
// g[S] = sum_{T ⊆ S} f[T]
// 【モノイド拡張】可換モノイド op(a, b) で置き換え可能 (例: max, min など)
template <typename T>
void fast_zeta_transform_or(vector<T>& a) {
    int n = a.size();
    for (int i = 1; i < n; i <<= 1) {
        for (int j = 0; j < n; j++) {
            if (!(j & i)) {
                // --- 変更ポイント ---
                a[j | i] += a[j];
                // 可換モノイド拡張例 (max): a[j | i] = max(a[j | i], a[j]);
                // --------------------
            }
        }
    }
}

// 下位集合に関する高速メビウス変換 (OR畳み込みの後処理 / 逆変換)
// 【群拡張】逆演算 inv_op(a, b) が必要 (min/max 等は逆演算がないため不可)
template <typename T>
void fast_mobius_transform_or(vector<T>& a) {
    int n = a.size();
    for (int i = 1; i < n; i <<= 1) {
        for (int j = 0; j < n; j++) {
            if (!(j & i)) {
                // --- 変更ポイント ---
                a[j | i] -= a[j];
                // 逆演算拡張例: a[j | i] = inv_op(a[j | i], a[j]);
                // --------------------
            }
        }
    }
}

// Bitwise OR 畳み込み: c[k] = sum_{i | j = k} a[i] * b[j]
// 【環拡張】外側演算(ゼータ/メビウス)と内側演算(積)に分配法則が必要
template <typename T>
vector<T> bitwise_or_convolution(vector<T> a, vector<T> b) {
    fast_zeta_transform_or(a);
    fast_zeta_transform_or(b);
    for (size_t i = 0; i < a.size(); i++) {
        // --- 変更ポイント ---
        a[i] *= b[i];
        // 独自の積演算: a[i] = mul(a[i], b[i]);
        // --------------------
    }
    fast_mobius_transform_or(a);
    return a;
}

// 上位集合に関する高速ゼータ変換 (AND畳み込みの前処理)
// g[S] = sum_{S ⊆ T} f[T]
// 【モノイド拡張】可換モノイド op(a, b) で置き換え可能
template <typename T>
void fast_zeta_transform_and(vector<T>& a) {
    int n = a.size();
    for (int i = 1; i < n; i <<= 1) {
        for (int j = 0; j < n; j++) {
            if (!(j & i)) {
                // --- 変更ポイント ---
                a[j] += a[j | i];
                // 可換モノイド拡張例 (min): a[j] = min(a[j], a[j | i]);
                // --------------------
            }
        }
    }
}

// 上位集合に関する高速メビウス変換 (AND畳み込みの後処理 / 包除原理)
// 【群拡張】逆演算 inv_op(a, b) が必要
template <typename T>
void fast_mobius_transform_and(vector<T>& a) {
    int n = a.size();
    for (int i = 1; i < n; i <<= 1) {
        for (int j = 0; j < n; j++) {
            if (!(j & i)) {
                // --- 変更ポイント ---
                a[j] -= a[j | i];
                // 逆演算拡張例: a[j] = inv_op(a[j], a[j | i]);
                // --------------------
            }
        }
    }
}

// Bitwise AND 畳み込み: c[k] = sum_{i & j = k} a[i] * b[j]
template <typename T>
vector<T> bitwise_and_convolution(vector<T> a, vector<T> b) {
    fast_zeta_transform_and(a);
    fast_zeta_transform_and(b);
    for (size_t i = 0; i < a.size(); i++) {
        // --- 変更ポイント ---
        a[i] *= b[i];
        // --------------------
    }
    fast_mobius_transform_and(a);
    return a;
}

// 約数ゼータ変換: g[i] = sum_{j | i} f[j]
// 【モノイド拡張】可換モノイド op(a, b) で置き換え可能 (例: max, min, gcd など)
template <typename T>
void divisor_zeta_transform(vector<T>& a) {
    int n = a.size() - 1;
    vector<bool> is_prime(n + 1, true);
    for (int p = 2; p <= n; ++p) {
        if (!is_prime[p]) continue;
        for (int i = 1; i * p <= n; ++i) {
            is_prime[i * p] = false;
            // --- 変更ポイント ---
            a[i * p] += a[i]; 
            // 可換モノイド拡張例 (max): a[i * p] = max(a[i * p], a[i]);
            // --------------------
        }
    }
}

// 約数メビウス変換 (ゼータ変換の逆変換)
// 【群拡張】逆演算 inv_op(a, b) が必要 (min/max 等は逆演算がないため不可)
template <typename T>
void divisor_mobius_transform(vector<T>& a) {
    int n = a.size() - 1;
    vector<bool> is_prime(n + 1, true);
    for (int p = 2; p <= n; ++p) {
        if (!is_prime[p]) continue;
        for (int i = n / p; i >= 1; --i) {
            is_prime[i * p] = false;
            // --- 変更ポイント ---
            a[i * p] -= a[i]; 
            // 逆演算拡張例: a[i * p] = inv_op(a[i * p], a[i]);
            // --------------------
        }
    }
}

// LCM畳み込み: c[k] = sum_{lcm(i, j) = k} a[i] * b[j]
// 【環拡張】外側演算(ゼータ/メビウス)と内側演算(積)に分配法則が必要
template <typename T>
vector<T> lcm_convolution(vector<T> a, vector<T> b) {
    divisor_zeta_transform(a);
    divisor_zeta_transform(b);
    for (size_t i = 1; i < a.size(); ++i) {
        // --- 変更ポイント ---
        a[i] *= b[i]; 
        // 独自の積演算: a[i] = mul(a[i], b[i]);
        // --------------------
    }
    divisor_mobius_transform(a);
    return a;
}

// 倍数ゼータ変換: g[i] = sum_{i | j} f[j]
// 【モノイド拡張】可換モノイド op(a, b) で置き換え可能
template <typename T>
void multiple_zeta_transform(vector<T>& a) {
    int n = a.size() - 1;
    vector<bool> is_prime(n + 1, true);
    for (int p = 2; p <= n; ++p) {
        if (!is_prime[p]) continue;
        for (int i = n / p; i >= 1; --i) {
            is_prime[i * p] = false;
            // --- 変更ポイント ---
            a[i] += a[i * p];
            // 可換モノイド拡張例 (gcd): a[i] = std::gcd(a[i], a[i * p]);
            // --------------------
        }
    }
}

// 倍数メビウス変換 (ゼータ変換の逆変換)
// 【群拡張】逆演算 inv_op(a, b) が必要
template <typename T>
void multiple_mobius_transform(vector<T>& a) {
    int n = a.size() - 1;
    vector<bool> is_prime(n + 1, true);
    for (int p = 2; p <= n; ++p) {
        if (!is_prime[p]) continue;
        for (int i = 1; i * p <= n; ++i) {
            is_prime[i * p] = false;
            // --- 変更ポイント ---
            a[i] -= a[i * p];
            // 逆演算拡張例: a[i] = inv_op(a[i], a[i * p]);
            // --------------------
        }
    }
}

// GCD畳み込み: c[k] = sum_{gcd(i, j) = k} a[i] * b[j]
template <typename T>
vector<T> gcd_convolution(vector<T> a, vector<T> b) {
    multiple_zeta_transform(a);
    multiple_zeta_transform(b);
    for (size_t i = 1; i < a.size(); ++i) {
        // --- 変更ポイント ---
        a[i] *= b[i];
        // --------------------
    }
    multiple_mobius_transform(a);
    return a;
}

// 高速アダマール変換 / 逆変換
template <typename T>
void fast_walsh_hadamard_transform(vector<T>& a, bool invert = false) {
    int n = a.size();
    for (int len = 1; len < n; len <<= 1) {
        for (int i = 0; i < n; i += 2 * len) {
            for (int j = 0; j < len; j++) {
                T u = a[i + j];
                T v = a[i + j + len];
                a[i + j] = u + v;
                a[i + j + len] = u - v;
            }
        }
    }
    if (invert) {
        T inv_n = T(1) / T(n);
        for (auto& x : a) x *= inv_n;
    }
}

// Bitwise XOR 畳み込み: c[k] = sum_{i ^ j = k} a[i] * b[j]
template <typename T>
vector<T> bitwise_xor_convolution(vector<T> a, vector<T> b) {
    fast_walsh_hadamard_transform(a);
    fast_walsh_hadamard_transform(b);
    for (size_t i = 0; i < a.size(); i++) a[i] *= b[i];
    fast_walsh_hadamard_transform(a, true);
    return a;
}

template <typename mint>
struct FPS : std::vector<mint> {
    using std::vector<mint>::vector;
    FPS(const std::vector<mint>& v) { this->assign(v.begin(), v.end()); }

    // 指定した次数までで切り打ち（リサイズ）
    FPS pre(ll deg) const {
        FPS res(*this);
        res.resize(deg);
        return res;
    }

    FPS& operator+=(const FPS& r) {
        if (r.size() > this->size()) this->resize(r.size());
        for (ll i = 0; i < (ll)r.size(); i++) (*this)[i] += r[i];
        return *this;
    }

    FPS& operator-=(const FPS& r) {
        if (r.size() > this->size()) this->resize(r.size());
        for (ll i = 0; i < (ll)r.size(); i++) (*this)[i] -= r[i];
        return *this;
    }

    // ACL の convolution を使った乗算
    FPS& operator*=(const FPS& r) {
        if (this->empty() || r.empty()) {
            this->clear();
            return *this;
        }
        auto res = atcoder::convolution(*this, r);
        this->assign(res.begin(), res.end());
        return *this;
    }

    FPS operator+(const FPS& r) const { return FPS(*this) += r; }
    FPS operator-(const FPS& r) const { return FPS(*this) -= r; }
    FPS operator*(const FPS& r) const { return FPS(*this) *= r; }

    FPS operator*(mint v) const {
        FPS res(*this);
        for (ll i = 0; i < (ll)res.size(); i++) res[i] *= v;
        return res;
    }
    FPS& operator*=(mint v) {
        for (ll i = 0; i < (ll)this->size(); i++) (*this)[i] *= v;
        return *this;
    }

    // 微分
    FPS deriv() const {
        if (this->empty()) return FPS();
        FPS res(this->size() - 1);
        for (ll i = 1; i < (ll)this->size(); i++) res[i - 1] = (*this)[i] * i;
        return res;
    }

    // 積分
    FPS integral() const {
        if (this->empty()) return FPS();
        FPS res(this->size() + 1);
        res[0] = 0;
        for (ll i = 0; i < (ll)this->size(); i++) res[i + 1] = (*this)[i] / (i + 1);
        return res;
    }

    // 逆元 (Inverse)
    FPS inv(ll deg = -1) const {
        if (deg == -1) deg = this->size();
        FPS res{(*this)[0].inv()};
        for (ll d = 1; d < deg; d *= 2) {
            FPS f = pre(2 * d);
            FPS g = res;
            f *= g;
            f.resize(2 * d);
            for (ll i = 0; i < 2 * d; i++) f[i] = -f[i];
            f[0] += 2;
            f *= g;
            f.resize(2 * d);
            res = f;
        }
        return res.pre(deg);
    }

    // 対数 (Log) : F[0] == 1 が必須
    FPS log(ll deg = -1) const {
        if (deg == -1) deg = this->size();
        FPS f = deriv();
        FPS g = inv(deg);
        f *= g;
        return f.integral().pre(deg);
    }

    // 指数 (Exp) : F[0] == 0 が必須
    FPS exp(ll deg = -1) const {
        if (deg == -1) deg = this->size();
        FPS res{1};
        for (ll d = 1; d < deg; d *= 2) {
            FPS f = res.log(2 * d);
            f[0] -= 1;
            for (ll i = 0; i < 2 * d; i++) f[i] = -f[i];
            FPS g = pre(2 * d);
            f += g;
            res *= f;
            res.resize(2 * d);
        }
        return res.pre(deg);
    }

    // 累乗 (Pow) : 定数項が0の場合（先行ゼロ）にも対応
    FPS pow(long long k, ll deg = -1) const {
        if (deg == -1) deg = this->size();
        if (k == 0) {
            FPS res(deg, 0);
            if (deg > 0) res[0] = 1;
            return res;
        }
        for (ll i = 0; i < (ll)this->size(); i++) {
            if ((*this)[i] != 0) {
                mint rev = (*this)[i].inv();
                FPS f(*this);
                for (ll j = 0; j < (ll)f.size(); j++) f[j] *= rev;
                f = f.pre(deg);
                f.erase(f.begin(), f.begin() + i);
                f = f.log(deg);
                for (ll j = 0; j < (ll)f.size(); j++) f[j] *= k;
                f = f.exp(deg);
                for (ll j = 0; j < (ll)f.size(); j++) f[j] *= (*this)[i].pow(k);
                
                FPS res(deg, 0);
                long long shift = i * k;
                if (shift >= deg) return res;
                for (ll j = 0; j < (ll)f.size() && j + shift < deg; j++) {
                    res[j + shift] = f[j];
                }
                return res;
            }
        }
        return FPS(deg, 0);
    }
};

using mint = modint998244353;
using fps = FPS<mint>;

// 乱数生成を扱いやすくする構造体
struct Random {
    mt19937_64 mt; // 64ビット版メルセンヌ・ツイスター

    // コンストラクタ：引数なしなら現在時刻、引数ありならその値をシードにする
    Random(uint64_t seed = chrono::steady_clock::now().time_since_epoch().count()) : mt(seed) {}

    // 1. nextInt: [L, R] の閉区間の整数を等確率でランダムに返す
    ll nextInt(ll L, ll R) {
        uniform_int_distribution<ll> dist(L, R);
        return dist(mt);
    }

    // 2. nextDouble: [0.0, 1.0) の実数を一様分布でランダムに返す
    double nextDouble() {
        uniform_real_distribution<double> dist(0.0, 1.0);
        return dist(mt);
    }
};

#include <chrono>

// Randomの導入が必要

// 実行時間を計測するための構造体
struct Timer {
    chrono::steady_clock::time_point start_time;
    
    // コンストラクタで生成時の時間を記録
    Timer() : start_time(chrono::steady_clock::now()) {}

    // 経過時間を秒単位の実数 (double) で返す
    double elapsed() const {
        return chrono::duration_cast<chrono::duration<double>>(
            chrono::steady_clock::now() - start_time).count();
    }
};

// 時間制限付き乱択アルゴリズムのテンプレート
void solve() {
    Timer timer;
    Random rnd;
    
    // TLEを避けるため、実際の制限時間より少し短めに設定 (例: 2.0秒制限なら1.8〜1.9秒)
    const double TIME_LIMIT = 1.8; 

    long long best_score = -1; // 最小化問題の場合は 1e18 などにする
    // ここに最良の解（状態）を保持する変数を定義する (例: vector<int> best_state;)

    int loop_count = 0; // 性能評価用（何回ループを回せたか）

    // 制限時間になるまでひたすらループを回す
    while (timer.elapsed() < TIME_LIMIT) {
        loop_count++;

        // 1. ランダムに解の候補を生成、または現在の解を少し変化させる（近傍遷移）
        // 例: int v = rnd.nextInt(0, N - 1);
        
        // 2. その解のスコアを計算する
        long long current_score = /* 評価関数の結果 */;

        // 3. スコアが改善されていたら、ベストスコアとベスト状態を更新する
        if (current_score > best_score) {
            best_score = current_score;
            // best_state = current_state; などの状態保存処理
        }
    }

    // デバッグ用: ループ回数や最終スコアを出力（本番では消すか cerr のままにする）
    // cerr << "Loop Count: " << loop_count << endl;
    // cerr << "Best Score: " << best_score << endl;

    // 最後に最良の解を出力する
    // print(best_state);
}

// pair の定義
pair<ll, ll> p = {1, 2};
auto q = make_pair(3, 4);

// 要素の読み出し
cout << p.first << " " << p.second << "\n";

// tuple の定義
tuple<ll, ll, ll> t = {1, 2, 3};

// tuple の要素取得
cout << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << "\n";

// {時間, イベント種類, ID} の順
using Event = tuple<ll, int, int>;

// structの定義と宇宙船演算子 (C++20: tupleの代用として推奨)
struct Event {
    ll time;
    int type;
    int id;
    // メンバ変数の上から順に辞書式比較を自動生成
    auto operator<=>(const Event&) const = default;
};
Event ev = {10, 0, 5};

// structured binding (C++17) : pair, tuple, struct 全てに対応
auto [x, y] = p;
auto [a, b, c] = t;
auto [time, type, id] = ev;

long long s = accumulate(v.begin(), v.end(), 0LL);

vector<ll> id(n);
iota(id.begin(), id.end(), 0);

sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());

auto it = min_element(v.begin(), v.end());
auto jt = max_element(v.begin(), v.end());

ll y = clamp(x, 0, 100);

auto f = [&](ll x) {
    return x * x;
};

// 安全な算術演算（オーバーフロー対策）
// namespaceを使わず、関数名に safe_ の接頭辞をつけています

constexpr long long SAFE_INF = std::numeric_limits<long long>::max();
constexpr long long SAFE_MIN_INF = std::numeric_limits<long long>::min();

// 内部判定用ラップ（GCC/Clang固有のビルトイン関数を利用）
inline bool safe_check_add(long long a, long long b, long long& res) {
    return __builtin_add_overflow(a, b, &res);
}
inline bool safe_check_mul(long long a, long long b, long long& res) {
    return __builtin_mul_overflow(a, b, &res);
}

// 1. 安全な足し算（a + b）
long long safe_add(long long a, long long b) {
    if (a == SAFE_INF || b == SAFE_INF) return SAFE_INF;
    if (a == SAFE_MIN_INF || b == SAFE_MIN_INF) return SAFE_MIN_INF;
    long long res;
    if (safe_check_add(a, b, res)) {
        return (a > 0) ? SAFE_INF : SAFE_MIN_INF;
    }
    return res;
}

// 2. 安全な引き算（a - b）
long long safe_sub(long long a, long long b) {
    if (b == SAFE_MIN_INF) return (a >= 0) ? SAFE_INF : a - b; // 厳密な極値回避
    return safe_add(a, -b);
}

// 3. 安全な掛け算（a * b）
long long safe_mul(long long a, long long b) {
    // どちらかが 0 なら 0
    if (a == 0 || b == 0) return 0;
    // どちらかが INF / MIN_INF の場合の伝搬
    if (a == SAFE_INF || b == SAFE_INF || a == SAFE_MIN_INF || b == SAFE_MIN_INF) {
        return ((a > 0) == (b > 0)) ? SAFE_INF : SAFE_MIN_INF;
    }
    long long res;
    if (safe_check_mul(a, b, res)) {
        return ((a ^ b) >= 0) ? SAFE_INF : SAFE_MIN_INF;
    }
    return res;
}

// 4. 安全な最小公倍数（lcm(a, b)）
long long safe_lcm(long long a, long long b) {
    if (a == 0 || b == 0) return 0;
    a = std::abs(a);
    b = std::abs(b);
    long long g = std::gcd(a, b);
    // a / g は割り切れるのでオーバーフローしない、その結果と b を掛ける
    return safe_mul(a / g, b);
}

// 5. 安全な累乗（base ^ exp）
long long safe_pow(long long base, long long exp) {
    if (exp < 0) return 0; // 整数範囲での負の乗数は基本 0（1^-1 など例外は割愛）
    if (exp == 0) return 1;
    long long res = 1;
    long long a = base;
    while (exp > 0) {
        if (exp & 1) res = safe_mul(res, a);
        exp >>= 1;
        if (exp > 0) a = safe_mul(a, a);
    }
    return res;
}

// （参考）MSVCなど、__builtin_mul_overflow がない環境向けのフォールバック判定
/*
bool portable_check_mul(long long a, long long b, long long& res) {
    if (a != 0 && b != 0) {
        if (a > 0 && b > 0 && a > SAFE_INF / b) return true;
        if (a > 0 && b < 0 && b < SAFE_MIN_INF / a) return true;
        if (a < 0 && b > 0 && a < SAFE_MIN_INF / b) return true;
        if (a < 0 && b < 0 && a < SAFE_INF / b) return true;
    }
    res = a * b;
    return false;
}
*/

// a=1, b=2, ..., z=26
ll alphabetIndexLower(char c) {
    if ('a' <= c && c <= 'z') {
        return c - 'a' + 1;
    }
    return -1; // 範囲外
}

// 使用例
char c = 'c';
cout << alphabetIndexLower(c) << "\n"; // 3

// A=1, B=2, ..., Z=26
ll alphabetIndexUpper(char c) {
    if ('A' <= c && c <= 'Z') {
        return c - 'A' + 1;
    }
    return -1; // 範囲外
}

// 使用例
char c = 'C';
cout << alphabetIndexUpper(c) << "\n"; // 3

// 座標圧縮
template <class T>
struct CoordinateCompression {
    vector<T> xs;  // 圧縮対象の値（構築後は昇順・重複なし）
    bool built = false;

    // 1. 値を 1 つ追加
    void add(const T& x) {
        xs.push_back(x);
        built = false;
    }

    // 2. 配列などの範囲をまとめて追加
    template <class It>
    void add_all(It first, It last) {
        xs.insert(xs.end(), first, last);
        built = false;
    }

    // 3. ソートして重複を除去し、圧縮を確定
    void build() {
        sort(xs.begin(), xs.end());
        xs.erase(unique(xs.begin(), xs.end()), xs.end());
        built = true;
    }

    // 4. 圧縮後の座標数
    int size() const {
        assert(built);
        return (int)xs.size();
    }

    // 5. 圧縮後の座標が空かどうか
    bool empty() const {
        assert(built);
        return xs.empty();
    }

    // 6. 値 x の圧縮 ID を取得
    //    登録済みなら 0-indexed の ID、未登録なら -1
    int id(const T& x) const {
        assert(built);

        auto it = lower_bound(xs.begin(), xs.end(), x);
        if (it == xs.end() || *it != x) return -1;

        return (int)(it - xs.begin());
    }

    // 7. x 以上となる最初の座標の位置
    //    つまり、x 未満の異なる座標の個数
    int lower(const T& x) const {
        assert(built);
        return (int)(
            lower_bound(xs.begin(), xs.end(), x) - xs.begin()
        );
    }

    // 8. x より大きい最初の座標の位置
    //    つまり、x 以下の異なる座標の個数
    int upper(const T& x) const {
        assert(built);
        return (int)(
            upper_bound(xs.begin(), xs.end(), x) - xs.begin()
        );
    }

    // 9. 値 x が圧縮対象に登録されているか
    bool contains(const T& x) const {
        return id(x) != -1;
    }

    // 10. 圧縮 ID から元の値を取得
    const T& value(int i) const {
        assert(built);
        return xs.at(i);
    }

    // 11. 元の値が [l, r] に含まれる座標の位置範囲
    //     戻り値は半開区間 [first, second)
    //     l や r 自体が登録されていなくても使用可能
    pair<int, int> range(const T& l, const T& r) const {
        assert(built);

        if (r < l) {
            int p = lower(l);
            return {p, p};
        }

        return {lower(l), upper(r)};
    }
};

vector<pair<char, long long>> rle;

for (ll i = 0; i < N; ) {
    ll j = i;
    while (j < N && S[j] == S[i]) j++;

    rle.push_back({S[i], j - i});
    i = j;
}

long long calc_mex(const vector<long long>& A) {
    ll n = A.size();
    vector<bool> exists(n + 1, false);
    
    for (auto a : A) {
        if (a >= 0 && a <= n) exists[a] = true;
    }
    
    for (ll i = 0; i <= n; i++) {
        if (!exists[i]) return i;
    }
    
    return 0;
}