//Place your snippets for cpp here. Each snippet is defined under a snippet name and has a prefix, body and 
// description. The prefix is what is used to trigger the snippet and the body will be expanded and inserted. Possible variables are:
// $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders. Placeholders with the 
// same ids are connected.
// Example:
// "Print to console": {
// 	"prefix": "log",
// 	"body": [
// 		"console.log('$1');",
// 		"$2"
// 	],
// 	"description": "Log output to console"
// }

{
    "ACM头文件": {
        "prefix": "acm-1.1start",
        "body": [
            "#include <bits/stdc++.h>",
            "#define int long long",
            "#define LL long long",
            "#define ll long long",
            "using namespace std;",
            "",
            "const int N = 2e5+1;",
            "const int MOD = 1e9+7;",
            "const int INF = 0x3f3f3f3f3f3f3f3f;",
            "const double PI = acos(-1.0);",
            "",
            "void solve() {",
            "    ",
            "}",
            "",
            "signed main() {",
            "    ios::sync_with_stdio(0);",
            "    cin.tie(0), cout.tie(0);",
            "    int t = 1;",
            "    cin >> t;",
            "    while (t--) {",
            "        solve();",
            "    }",
            "    return 0;",
            "}",
            "",
            "// by vanadium-23"
        ],
        "description": "插入 ACM头文件"
    },
    "并查集": {
        "prefix": "acm-2.4路径压缩",
        "body": [
            "#include<cstdio>",
            "#define Re register int",
            "const int N=1e4+3;",
            "int n,x,y,T,op,fa[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int find(Re x){return x==fa[x]?x:fa[x]=find(fa[x]);}",
            "int main(){",
            "\tin(n),in(T);",
            "\tfor(Re i=1;i<=n;++i)fa[i]=i;",
            "\twhile(T--){",
            "\t\tin(op),in(x),in(y);",
            "\t\tif(op<2){if(find(x)!=find(y))fa[find(x)]=find(y);}",
            "\t\telse puts(find(x)==find(y)?\"Y\":\"N\");",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 并查集"
    },
    "快速幂": {
        "prefix": "acm-1.3binpow",
        "body": [
            "long long binpow(long long a, long long b) {",
            "    long long res = 1;",
            "    while (b > 0) {",
            "        if (b & 1) res = res * a;",
            "        a = a * a;",
            "        b >>= 1;",
            "    }",
            "    return res;",
            "}"
        ],
        "description": "插入 快速幂"
    },
    "快速幂带MOD": {
        "prefix": "acm-1.3binpow-mod",
        "body": [
            "long long binpow(long long a, long long b) {",
            "    long long res = 1;",
            "    while (b > 0) {",
            "        if (b & 1) res = res * a % MOD;",
            "        a = a * a % MOD;",
            "        b >>= 1;",
            "    }",
            "    return res % MOD;",
            "}"
        ],
        "description": "插入 快速幂带MOD"
    },
    "平衡树": {
        "prefix": "acm-2.7BalancedBST",
        "body": [
            "struct TreeNode {",
            "    int key;",
            "    TreeNode* left;",
            "    TreeNode* right;",
            "    int height; // 节点高度",
            "    int size;   // 子树大小",
            "    int count;  // 重复次数",
            "",
            "    TreeNode(int value) ",
            "        : key(value), height(1), size(1), count(1), left(nullptr), right(nullptr) {}",
            "};",
            "",
            "class BalancedBST {",
            "private:",
            "    TreeNode* root;",
            "",
            "    // 获取节点高度",
            "    int getHeight(TreeNode* node) const {",
            "        return node ? node->height : 0;",
            "    }",
            "",
            "    // 获取节点子树大小",
            "    int getSize(TreeNode* node) const {",
            "        return node ? node->size : 0;",
            "    }",
            "",
            "    // 更新节点高度和大小",
            "    void updateNodeInfo(TreeNode* node) const {",
            "        if (node) {",
            "            node->height = 1 + std::max(getHeight(node->left), getHeight(node->right));",
            "            node->size = node->count + getSize(node->left) + getSize(node->right);",
            "        }",
            "    }",
            "",
            "    // 获取平衡因子",
            "    int getBalanceFactor(TreeNode* node) const {",
            "        return node ? getHeight(node->left) - getHeight(node->right) : 0;",
            "    }",
            "",
            "    // 右旋",
            "    TreeNode* rightRotate(TreeNode* y) const {",
            "        TreeNode* x = y->left;",
            "        TreeNode* T2 = x->right;",
            "",
            "        x->right = y;",
            "        y->left = T2;",
            "",
            "        updateNodeInfo(y);",
            "        updateNodeInfo(x);",
            "",
            "        return x;",
            "    }",
            "",
            "    // 左旋",
            "    TreeNode* leftRotate(TreeNode* x) const {",
            "        TreeNode* y = x->right;",
            "        TreeNode* T2 = y->left;",
            "",
            "        y->left = x;",
            "        x->right = T2;",
            "",
            "        updateNodeInfo(x);",
            "        updateNodeInfo(y);",
            "",
            "        return y;",
            "    }",
            "",
            "    // 平衡节点",
            "    TreeNode* balanceNode(TreeNode* node) const {",
            "        if (!node) return nullptr;",
            "",
            "        updateNodeInfo(node);",
            "        int balance = getBalanceFactor(node);",
            "",
            "        // Left Left Case",
            "        if (balance > 1 && getBalanceFactor(node->left) >= 0)",
            "            return rightRotate(node);",
            "",
            "        // Right Right Case",
            "        if (balance < -1 && getBalanceFactor(node->right) <= 0)",
            "            return leftRotate(node);",
            "",
            "        // Left Right Case",
            "        if (balance > 1 && getBalanceFactor(node->left) < 0) {",
            "            node->left = leftRotate(node->left);",
            "            return rightRotate(node);",
            "        }",
            "",
            "        // Right Left Case",
            "        if (balance < -1 && getBalanceFactor(node->right) > 0) {",
            "            node->right = rightRotate(node->right);",
            "            return leftRotate(node);",
            "        }",
            "",
            "        return node;",
            "    }",
            "",
            "    // 递归插入",
            "    TreeNode* insertHelper(TreeNode* node, int value){",
            "        if (!node) {",
            "            return new TreeNode(value);",
            "        }",
            "",
            "        if (value < node->key) {",
            "            node->left = insertHelper(node->left, value);",
            "        } else if (value > node->key) {",
            "            node->right = insertHelper(node->right, value);",
            "        } else {",
            "            node->count++;",
            "            node->size++;",
            "            return node;",
            "        }",
            "",
            "        return balanceNode(node);",
            "    }",
            "",
            "    // 查找最小节点",
            "    TreeNode* findMinNode(TreeNode* node) const {",
            "        while (node && node->left) {",
            "            node = node->left;",
            "        }",
            "        return node;",
            "    }",
            "",
            "    // 递归删除",
            "    TreeNode* removeHelper(TreeNode* node, int value){",
            "        if (!node) return nullptr;",
            "",
            "        if (value < node->key) {",
            "            node->left = removeHelper(node->left, value);",
            "        } else if (value > node->key) {",
            "            node->right = removeHelper(node->right, value);",
            "        } else {",
            "            if (node->count > 1) {",
            "                node->count--;",
            "                node->size--;",
            "                return node;",
            "            }",
            "",
            "            if (!node->left || !node->right) {",
            "                TreeNode* temp = node->left ? node->left : node->right;",
            "                if (!temp) {",
            "                    delete node;",
            "                    return nullptr;",
            "                } else {",
            "                    *node = *temp;",
            "                    delete temp;",
            "                }",
            "            } else {",
            "                TreeNode* successor = findMinNode(node->right);",
            "                node->key = successor->key;",
            "                node->count = successor->count;",
            "                successor->count = 1;",
            "                node->right = removeHelper(node->right, successor->key);",
            "            }",
            "        }",
            "",
            "        return balanceNode(node);",
            "    }",
            "",
            "    // 递归查找",
            "    bool searchHelper(TreeNode* node, int value) const {",
            "        if (!node) return false;",
            "        if (value == node->key) return true;",
            "        if (value < node->key) return searchHelper(node->left, value);",
            "        return searchHelper(node->right, value);",
            "    }",
            "",
            "    // 递归中序遍历",
            "    void inorderHelper(TreeNode* node, std::vector<int>& result) const {",
            "        if (!node) return;",
            "        inorderHelper(node->left, result);",
            "        for (int i = 0; i < node->count; ++i) {",
            "            result.push_back(node->key);",
            "        }",
            "        inorderHelper(node->right, result);",
            "    }",
            "",
            "    // 递归查询排名",
            "    int rankHelper(TreeNode* node, int value) const {",
            "        if (!node) return 0;",
            "        ",
            "        if (value < node->key) {",
            "            return rankHelper(node->left, value);",
            "        } else if (value > node->key) {",
            "            return getSize(node->left) + node->count + rankHelper(node->right, value);",
            "        } else {",
            "            return getSize(node->left) + 1;",
            "        }",
            "    }",
            "",
            "    // 递归按排名查找",
            "    int selectHelper(TreeNode* node, int k) const {",
            "        if (!node) return -1;",
            "        ",
            "        int leftSize = getSize(node->left);",
            "        ",
            "        if (k <= leftSize) {",
            "            return selectHelper(node->left, k);",
            "        } else if (k <= leftSize + node->count) {",
            "            return node->key;",
            "        } else {",
            "            return selectHelper(node->right, k - leftSize - node->count);",
            "        }",
            "    }",
            "",
            "    // 递归释放所有节点",
            "    void clearHelper(TreeNode* node) {",
            "        if (!node) return;",
            "        clearHelper(node->left);",
            "        clearHelper(node->right);",
            "        delete node;",
            "    }",
            "",
            "public:",
            "    BalancedBST() : root(nullptr) {}",
            "",
            "    // 插入元素 - O(log n)",
            "    void insert(int value) {",
            "        root = insertHelper(root, value);",
            "    }",
            "",
            "    // 删除元素 - O(log n)",
            "    void remove(int value) {",
            "        root = removeHelper(root, value);",
            "    }",
            "",
            "    // 查找元素 - O(log n)",
            "    bool search(int value) const {",
            "        return searchHelper(root, value);",
            "    }",
            "",
            "    // 获取最小值 - O(log n)",
            "    int min() const {",
            "        TreeNode* node = findMinNode(root);",
            "        return node ? node->key : -1;",
            "    }",
            "",
            "    // 获取最大值 - O(log n)",
            "    int max() const {",
            "        TreeNode* node = root;",
            "        while (node && node->right) {",
            "            node = node->right;",
            "        }",
            "        return node ? node->key : -1;",
            "    }",
            "",
            "    // 中序遍历 - O(n)",
            "    std::vector<int> inorder() const {",
            "        std::vector<int> result;",
            "        inorderHelper(root, result);",
            "        return result;",
            "    }",
            "",
            "    // 查询排名 - O(log n)",
            "    int rank(int value) const {",
            "        return rankHelper(root, value);",
            "    }",
            "",
            "    // 按排名查找 - O(log n)",
            "    int select(int k) const {",
            "        return selectHelper(root, k);",
            "    }",
            "",
            "    // 清空整棵树",
            "    void clear() {",
            "        clearHelper(root);",
            "        root = nullptr;",
            "    }",
            "",
            "    // 获取树的大小 - O(1)",
            "    int size() const {",
            "        return getSize(root);",
            "    }",
            "",
            "    // 获取树的高度 - O(1)",
            "    int height() const {",
            "        return getHeight(root);",
            "    }",
            "};"
        ],
        "description": "插入 平衡树"
    },
    "树状数组": {
        "prefix": "acm-2.5bit",
        "body": [
            "template<class T> struct BIT {",
            "    int n;",
            "    vector<T> w;",
            "    BIT(int n, auto &in) : n(n), w(n + 1) { // 预处理填值",
            "        for (int i = 1; i <= n; i++) {",
            "            add(i, in[i]);",
            "        }",
            "    }",
            "    void add(int x, T v) {",
            "        for (; x <= n; x += x & -x) {",
            "            w[x] += v;",
            "        }",
            "    }",
            "    T ask(int x) { // 前缀和查询",
            "        T ans = 0;",
            "        for (; x; x -= x & -x) {",
            "            ans += w[x];",
            "        }",
            "        return ans;",
            "    }",
            "    T ask(int l, int r) { // 差分实现区间和查询",
            "        return ask(r) - ask(l - 1);",
            "    }",
            "};"
        ],
        "description": "插入 树状数组"
    },
    "组合数学": {
        "prefix": "acm-7.2Comb",
        "body": [
            "class Combinatorics {",
            "private:",
            "    vector<ll> fact, inv_fact;",
            "    int max_n;",
            "    ",
            "public:",
            "    // 预处理阶乘和逆阶乘，O(n)",
            "    Combinatorics(int n) : max_n(n) {",
            "        fact.resize(n + 1);",
            "        inv_fact.resize(n + 1);",
            "        ",
            "        fact[0] = 1;",
            "        for (int i = 1; i <= n; i++) {",
            "            fact[i] = fact[i - 1] * i % MOD;",
            "        }",
            "        ",
            "        inv_fact[n] = inv(fact[n]);",
            "        for (int i = n - 1; i >= 0; i--) {",
            "            inv_fact[i] = inv_fact[i + 1] * (i + 1) % MOD;",
            "        }",
            "    }",
            "    ",
            "    // 快速幂计算逆元，O(log MOD)",
            "    ll inv(ll x) {",
            "        return qpow(x, MOD - 2);",
            "    }",
            "    ",
            "    // 快速幂，O(log exponent)",
            "    ll qpow(ll a, ll b) {",
            "        ll res = 1;",
            "        while (b) {",
            "            if (b & 1) res = res * a % MOD;",
            "            a = a * a % MOD;",
            "            b >>= 1;",
            "        }",
            "        return res;",
            "    }",
            "    ",
            "    // 组合数C(n,k)，O(1)",
            "    ll C(int n, int k) {",
            "        if (k < 0 || k > n) return 0;",
            "        return fact[n] * inv_fact[k] % MOD * inv_fact[n - k] % MOD;",
            "    }",
            "    ",
            "    // 排列数A(n,k)，O(1)",
            "    ll A(int n, int k) {",
            "        if (k < 0 || k > n) return 0;",
            "        return fact[n] * inv_fact[n - k] % MOD;",
            "    }",
            "    ",
            "    // 卢卡斯定理计算组合数，适用于n,k很大但MOD较小的情况",
            "    ll Lucas(ll n, ll k) {",
            "        if (k == 0) return 1;",
            "        return C(n % MOD, k % MOD) * Lucas(n / MOD, k / MOD) % MOD;",
            "    }",
            "    ",
            "    // 第二类斯特林数S(n,k)，将n个元素划分为k个非空子集，O(nk)",
            "    ll Stirling2(int n, int k) {",
            "        ll res = 0;",
            "        for (int i = 0; i <= k; i++) {",
            "            ll term = C(k, i) * qpow(i, n) % MOD;",
            "            if ((k - i) % 2) {",
            "                res = (res - term + MOD) % MOD;",
            "            } else {",
            "                res = (res + term) % MOD;",
            "            }",
            "        }",
            "        return res * inv_fact[k] % MOD;",
            "    }",
            "    ",
            "    // 贝尔数B(n)，基于第二类斯特林数的实现，O(n^2)",
            "    // B(n) = Σ S(n,k) for k=0 to n",
            "    ll Bell_Stirling(int n) {",
            "        ll res = 0;",
            "        for (int k = 0; k <= n; k++) {",
            "            res = (res + Stirling2(n, k)) % MOD;",
            "        }",
            "        return res;",
            "    }",
            "    ",
            "    // 贝尔数B(n)，基于动态规划的实现，O(n^2)",
            "    // 使用递推关系：B(n+1) = Σ C(n,k)*B(k) for k=0 to n",
            "    ll Bell_DP(int n) {",
            "        if (n == 0) return 1;",
            "        vector<ll> bell(n + 1);",
            "        bell[0] = 1;",
            "        ",
            "        for (int i = 1; i <= n; i++) {",
            "            bell[i] = 0;",
            "            for (int k = 0; k < i; k++) {",
            "                bell[i] = (bell[i] + C(i - 1, k) * bell[k]) % MOD;",
            "            }",
            "        }",
            "        return bell[n];",
            "    }",
            "    ",
            "    // 卡特兰数，O(1)",
            "    ll Catalan(int n) {",
            "        return C(2 * n, n) * inv(n + 1) % MOD;",
            "    }",
            "    ",
            "    // 错位排列数，O(n)预处理后O(1)查询",
            "    ll Derangement(int n) {",
            "        if (n == 0) return 1;",
            "        if (n == 1) return 0;",
            "        // D(n) = (n-1)*(D(n-1)+D(n-2))",
            "        vector<ll> d(n + 1);",
            "        d[0] = 1;",
            "        d[1] = 0;",
            "        for (int i = 2; i <= n; i++) {",
            "            d[i] = (i - 1) * (d[i - 1] + d[i - 2]) % MOD;",
            "        }",
            "        return d[n];",
            "    }",
            "    ",
            "    // 计算gcd，O(log min(a,b))",
            "    ll gcd(ll a, ll b) {",
            "        return b == 0 ? a : gcd(b, a % b);",
            "    }",
            "    ",
            "    // 计算lcm，O(log min(a,b))",
            "    ll lcm(ll a, ll b) {",
            "        return a / gcd(a, b) * b;",
            "    }",
            "    ",
            "    // 扩展欧几里得算法，求解ax + by = gcd(a,b)",
            "    ll ext_gcd(ll a, ll b, ll &x, ll &y) {",
            "        if (b == 0) {",
            "            x = 1;",
            "            y = 0;",
            "            return a;",
            "        }",
            "        ll d = ext_gcd(b, a % b, y, x);",
            "        y -= a / b * x;",
            "        return d;",
            "    }",
            "    ",
            "    // 中国剩余定理，求解x ≡ a_i (mod m_i)",
            "    ll CRT(const vector<ll> &a, const vector<ll> &m) {",
            "        ll M = 1, x = 0;",
            "        int n = a.size();",
            "        for (int i = 0; i < n; i++) M *= m[i];",
            "        ",
            "        for (int i = 0; i < n; i++) {",
            "            ll Mi = M / m[i];",
            "            ll y, z;",
            "            ext_gcd(Mi, m[i], y, z);",
            "            x = (x + a[i] * Mi % M * y % M) % M;",
            "        }",
            "        return (x + M) % M;",
            "    }",
            "    ",
            "    // 欧拉函数，计算小于n且与n互质的数的个数，O(sqrt(n))",
            "    ll EulerPhi(ll n) {",
            "        ll res = n;",
            "        for (ll i = 2; i * i <= n; i++) {",
            "            if (n % i == 0) {",
            "                res = res / i * (i - 1);",
            "                while (n % i == 0) n /= i;",
            "            }",
            "        }",
            "        if (n > 1) res = res / n * (n - 1);",
            "        return res;",
            "    }",
            "};",
            "",
            "Combinatorics comb(1000000); // 预处理1e6以内的阶乘"
        ],
        "description": "插入 组合数学"
    },
    "二分图最大匹配-匈牙利算法": {
        "prefix": "acm-3.4erfentu",
        "body": [
            "signed main() {",
            "    ios::sync_with_stdio(0);",
            "    cin.tie(0), cout.tie(0);",
            "    int n1,n2,m;",
            "    cin >> n1 >> n2 >> m;",
            "    vector<vector<int>>ver(n1+1);",
            "    for(int i = 1;i <= m;i++){",
            "        int x,y;",
            "        cin >> x >> y;",
            "        ver[x].push_back(y);",
            "    }",
            "",
            "    int ans = 0;",
            "    vector<int>match(n2+1);",
            "    for(int i = 1;i <= n1;i++){",
            "        vector<int>vis(n2+1);",
            "        auto dfs = [&](auto self,int x) -> bool {",
            "            for(auto y : ver[x]){",
            "                if(vis[y])continue;",
            "                vis[y] = 1;",
            "                if(!match[y] || self(self,match[y])){",
            "                    match[y] = x;",
            "                    return true;",
            "                }",
            "            }",
            "            return false;",
            "        };",
            "        if(dfs(dfs,i)){",
            "            ans++;",
            "        }",
            "    }",
            "    cout << ans << '\\n';",
            "    return 0;",
            "}"
        ],
        "description": "插入 二分图最大匹配-匈牙利算法"
    },
    "多项式乘法-快速傅里叶变换": {
        "prefix": "acm-7.4FFT",
        "body": [
            "struct Polynoial{",
            "    struct Complex{",
            "        double x,y;",
            "        Complex(double _x = 0.0,double _y = 0.0){",
            "            x = _x;",
            "            y = _y;",
            "        }",
            "        Complex operator-(const Complex &rhs) const{",
            "            return Complex(x-rhs.x,y-rhs.y);",
            "        }",
            "        Complex operator+(const Complex &rhs) const{",
            "            return Complex(x+rhs.x,y+rhs.y);",
            "        }",
            "        Complex operator*(const Complex &rhs) const{",
            "            return Complex(x*rhs.x-y*rhs.y,x*rhs.y+y*rhs.x);",
            "        }",
            "    };",
            "    ",
            "    int getSize(int n) {",
            "        int size = 1;",
            "        while (size < n) size <<= 1;",
            "        return size;",
            "    }",
            "    ",
            "    void change(vector<Complex>&a,int n){",
            "        for(int i = 1,j = n/2;i < n-1;i++){",
            "            if(i < j){",
            "                swap(a[i],a[j]);",
            "            }",
            "            int k = n/2;",
            "            while(j >= k){",
            "                j -= k;",
            "                k /= 2;",
            "            }",
            "            if(j < k)j += k;",
            "        }",
            "    }",
            "    ",
            "    void fft(vector<Complex>&a,int n,int opt){",
            "        change(a,n);",
            "        for(int h = 2;h <= n;h*=2){",
            "            Complex wn(cos(2*PI/h),sin(opt*2*PI/h));  // 修正：PI/h 而不是 PI/n",
            "            for(int j = 0;j < n;j+=h){",
            "                Complex w(1,0);",
            "                for(int k = j;k < j+h/2;k++){",
            "                    Complex u = a[k];",
            "                    Complex t = w*a[k+h/2];",
            "                    a[k]=u+t;",
            "                    a[k+h/2]=u-t;",
            "                    w=w*wn;",
            "                }",
            "            }",
            "        }",
            "        if(opt == -1){",
            "            for(int i = 0;i < n;i++){",
            "                a[i].x /= n;",
            "            }",
            "        }",
            "    }",
            "",
            "    vector<int> multiply(vector<int>& a, vector<int>& b) {",
            "        int size = getSize(a.size() + b.size() - 1);",
            "        ",
            "        vector<Complex> fa(size), fb(size);",
            "        for(int i = 0; i < (int)a.size(); i++) fa[i] = Complex(a[i], 0);",
            "        for(int i = 0; i < (int)b.size(); i++) fb[i] = Complex(b[i], 0);",
            "        for(int i = a.size(); i < size; i++) fa[i] = Complex(0, 0);",
            "        for(int i = b.size(); i < size; i++) fb[i] = Complex(0, 0);",
            "        ",
            "        fft(fa, size, 1);",
            "        fft(fb, size, 1);",
            "        ",
            "        for(int i = 0; i < size; i++) {",
            "            fa[i] = fa[i] * fb[i];",
            "        }",
            "        ",
            "        fft(fa, size, -1);",
            "        ",
            "        vector<int> res(size);",
            "        for(int i = 0; i < size; i++) {",
            "            res[i] = (int)(fa[i].x + 0.5);",
            "        }",
            "        return res;",
            "    }",
            "};"
        ],
        "description": "插入 多项式乘法-快速傅里叶变换"
    },
    "高斯消元": {
        "prefix": "acm-7.5高斯约旦消元",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=103;",
            "int n;LD eps=1e-8,a[N][N];",
            "inline int dcmp(Re a){return a<-eps?-1:(a>eps?1:0);}",
            "inline LD Abs(LD a){return dcmp(a)*a;}",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n);",
            "\tfor(Re i=1;i<=n;++i)\t",
            "\t\tfor(Re j=1;j<=n+1;++j)",
            "\t\t\tscanf(\"%lf\",&a[i][j]);",
            "\tfor(Re j=1;j<=n;++j){",
            "\t\tRe w=j;",
            "\t\tfor(Re i=j+1;i<=n;++i)",
            "\t\t\tif(dcmp(Abs(a[i][j])-Abs(a[w][j]))>0)w=i;",
            "\t\tfor(Re k=1;k<=n+1;++k)swap(a[j][k],a[w][k]);",
            "\t\tif(!dcmp(a[j][j]))return !puts(\"No Solution\");",
            "\t\tfor(Re i=1;i<=n;++i)",
            "\t\t\tif(i!=j){",
            "\t\t\t\tLD tmp=a[i][j]/a[j][j];",
            "\t\t\t\tfor(Re k=j;k<=n+1;++k)a[i][k]-=a[j][k]*tmp;",
            "\t\t\t}",
            "\t}",
            "\tfor(Re i=1;i<=n;++i)printf(\"%.2lf\\n\",a[i][n+1]/a[i][i]);",
            "}",
            ""
        ],
        "description": "插入 高斯消元"
    },
    "gcd 与 lcm": {
        "prefix": "acm-1.2gcd",
        "body": [
            "int gcd(int a, int b) {",
            "    return b ? gcd(b, a % b) : a;",
            "}",
            "int lcm(int a,int b){",
            "    return a * b / gcd(a,b);",
            "}"
        ],
        "description": "插入 gcd 与 lcm"
    },
    "KMP": {
        "prefix": "acm-6.1kmp",
        "body": [
            "#include<iostream>",
            "#include<cstdio>",
            "#include<string>",
            "using namespace std;",
            "int i,j,n,m,next[1000005];string a,b;",
            "int main(){",
            "\tcin>>a>>b;",
            "\tn=a.size();a='$'+a;",
            "\tm=b.size();b='$'+b;",
            "\tfor(i=2,j=0;i<=m;i++){",
            "\t\twhile(j&&b[i]!=b[j+1])j=next[j];",
            "\t\tif(b[i]==b[j+1])j++;",
            "\t\tnext[i]=j;",
            "\t}",
            "\tfor(i=1,j=0;i<=n;i++){",
            "\t\twhile(j&&a[i]!=b[j+1])j=next[j];",
            "\t\tif(a[i]==b[j+1])j++;",
            "\t\tif(j==m){j=next[j];printf(\"%d\\n\",i-m+1);}",
            "\t}",
            "\tfor(i=1;i<=m;i++)printf(\"%d \",next[i]);",
            "}",
            ""
        ],
        "description": "插入 KMP"
    },
    "Kruskal 重构树": {
        "prefix": "acm-4.4KruskalReconstructionTree",
        "body": [
            "struct KruskalReconstructionTree {",
            "    int n;                      // 原图节点数",
            "    int tot;                    // 重构树总节点数",
            "    vector<vector<int>> g;      // 树邻接表",
            "    vector<int> val;            // 节点权值 (原节点 -1)",
            "    vector<int> parent;         // 父节点",
            "    vector<int> dsu;            // 并查集",
            "",
            "    static const int LOG = 20;  // 倍增 LCA 参数",
            "    vector<int> depth;",
            "    vector<vector<int>> up;",
            "",
            "    KruskalReconstructionTree(int n_) : n(n_) {",
            "        tot = n;",
            "        g.resize(2 * n);",
            "        val.resize(2 * n);",
            "        parent.assign(2 * n, -1);",
            "        dsu.resize(2 * n);",
            "        iota(dsu.begin(), dsu.end(), 0);",
            "        for (int i = 0; i < n; i++) val[i] = -1;",
            "        depth.resize(2 * n);",
            "    }",
            "",
            "    int find(int x) {",
            "        while (dsu[x] != x) dsu[x] = dsu[dsu[x]], x = dsu[x];",
            "        return x;",
            "    }",
            "",
            "    // 构建重构树。edges: {u,v,w}",
            "    void build(vector<tuple<int, int, int>> edges, bool sorted = false) {",
            "        if (!sorted) {",
            "            sort(edges.begin(), edges.end(),",
            "                 [](const auto &a, const auto &b) {",
            "                     return get<2>(a) > get<2>(b); // 最大瓶颈路",
            "                 });",
            "        }",
            "        for (auto &[u, v, w] : edges) {",
            "            int ru = find(u), rv = find(v);",
            "            if (ru == rv) continue;",
            "            int node = tot++;",
            "            val[node] = w;",
            "            g[node].push_back(ru);",
            "            g[node].push_back(rv);",
            "            parent[ru] = parent[rv] = node;",
            "            dsu[ru] = dsu[rv] = node;",
            "            dsu[node] = node;",
            "            if (tot >= (int)g.size()) {",
            "                g.resize(tot + 5);",
            "                val.resize(tot + 5);",
            "                parent.resize(tot + 5);",
            "                depth.resize(tot + 5);",
            "            }",
            "        }",
            "        g.resize(tot);",
            "        val.resize(tot);",
            "        parent.resize(tot);",
            "        // 建立倍增表",
            "        initLCA();",
            "    }",
            "",
            "    void initLCA() {",
            "        depth.assign(tot, 0);",
            "        up.assign(tot, vector<int>(LOG, -1));",
            "        for (int i = 0; i < tot; i++)",
            "            if (parent[i] == -1) dfs(i, -1);",
            "    }",
            "",
            "    void dfs(int u, int p) {",
            "        up[u][0] = p;",
            "        for (int j = 1; j < LOG; j++) {",
            "            if (up[u][j - 1] != -1)",
            "                up[u][j] = up[up[u][j - 1]][j - 1];",
            "            else",
            "                up[u][j] = -1;",
            "        }",
            "        for (int v : g[u]) {",
            "            if (v == p) continue;",
            "            depth[v] = depth[u] + 1;",
            "            dfs(v, u);",
            "        }",
            "    }",
            "",
            "    // 查询 u, v 的 LCA",
            "    int lca(int u, int v) {",
            "        if (depth[u] < depth[v]) swap(u, v);",
            "        int diff = depth[u] - depth[v];",
            "        for (int j = 0; j < LOG; j++) {",
            "            if (diff >> j & 1) u = up[u][j];",
            "        }",
            "        if (u == v) return u;",
            "        for (int j = LOG - 1; j >= 0; j--) {",
            "            if (up[u][j] != up[v][j]) {",
            "                u = up[u][j];",
            "                v = up[v][j];",
            "            }",
            "        }",
            "        return up[u][0];",
            "    }",
            "",
            "    // 查询原图 u->v 瓶颈路（最小边权的最大值）",
            "    int queryMaxEdgeMin(int u, int v) {",
            "        int w = lca(u, v);",
            "        if (w == -1) return -1;",
            "        return val[w];",
            "    }",
            "",
            "    // 从 s 出发，仅走边权 ≤ lim 的边能到达的所有节点",
            "    vector<int> queryReachable(int s, int lim) {",
            "        int u = s;",
            "        for (int j = LOG - 1; j >= 0; j--)",
            "            if (up[u][j] != -1 && val[up[u][j]] <= lim)",
            "                u = up[u][j];",
            "        vector<int> res;",
            "        collectLeaves(u, -1, res);",
            "        return res;",
            "    }",
            "",
            "    // 从 s 出发，仅走边权 ≥ lim 的边能到达的所有节点（需降序构建）",
            "    vector<int> queryReachableMin(int s, int lim) {",
            "        int u = s;",
            "        for (int j = LOG - 1; j >= 0; j--)",
            "            if (up[u][j] != -1 && val[up[u][j]] >= lim)",
            "                u = up[u][j];",
            "        vector<int> res;",
            "        collectLeaves(u, -1, res);",
            "        return res;",
            "    }",
            "",
            "    // 收集子树中所有原图节点",
            "    void collectLeaves(int u, int p, vector<int> &out) {",
            "        if (u < n) { out.push_back(u); return; }",
            "        for (int v : g[u]) if (v != p) collectLeaves(v, u, out);",
            "    }",
            "};"
        ],
        "description": "插入 Kruskal 重构树"
    },
    "带懒标记的线段数": {
        "prefix": "acm-2.6Lazy_Segment_Tree_ask_add",
        "body": [
            "struct node{",
            "    int data,lazy;",
            "};",
            "",
            "void build(const vector<int>&datas,vector<node>&tree,int rt,int left,int right){",
            "    if(left == right){",
            "        tree[rt].data=datas[left];",
            "        return;",
            "    }",
            "    int mid = left+(right-left)/2;",
            "    build(datas,tree,2*rt,left,mid);",
            "    build(datas,tree,2*rt+1,mid+1,right);",
            "    tree[rt].data = tree[2*rt].data+tree[2*rt+1].data;",
            "}",
            "void pushDown(vector<node>&tree,int rt, int len){",
            "    if(tree[rt].lazy != 0){",
            "        tree[rt*2].data += tree[rt].lazy * (len - len/2);",
            "        tree[rt*2].lazy += tree[rt].lazy;",
            "        tree[rt*2+1].data += tree[rt].lazy * (len/2); ",
            "        tree[rt*2+1].lazy += tree[rt].lazy;",
            "        tree[rt].lazy = 0;  ",
            "    }",
            "}",
            "",
            "int query(vector<node>&tree,int rt,int left,int right,int ql,int qr){",
            "    if(ql > right || qr < left){",
            "        return MIN;",
            "    }",
            "    if(ql <= left && qr >= right){",
            "        return tree[rt].data;",
            "    }",
            "    int mid = left+(right-left)/2;",
            "    pushDown(tree,rt,right-left+1);",
            "    int leftsum = query(tree,2*rt,left,mid,ql,qr);",
            "    int rightsum = query(tree,2*rt+1,mid+1,right,ql,qr);",
            "    return leftsum+rightsum;",
            "}",
            "void updata(vector<node>&tree,int rt,int left,int right,int idx,int value){",
            "    if(left == right){",
            "        tree[rt].data = value;",
            "        tree[rt].lazy = 0;",
            "        return;",
            "    }",
            "    int mid = left+(right-left)/2;",
            "    pushDown(tree,rt,right-left+1);",
            "    if(idx<=mid){",
            "        updata(tree,2*rt,left,mid,idx,value);",
            "    }else{",
            "        updata(tree,2*rt+1,mid+1,right,idx,value);",
            "    }",
            "    tree[rt].data = tree[2*rt].data+tree[2*rt+1].data;",
            "}",
            "void updataRange(vector<node>&tree,int rt,int left,int right,int ul,int ur,int value){",
            "    if(ul>right||ur<left) return;",
            "    ",
            "    if(ul<=left && ur >= right){",
            "        tree[rt].data += value * (right - left + 1);",
            "        tree[rt].lazy += value;",
            "        return;",
            "    }",
            "    int mid = left+(right-left)/2;",
            "    pushDown(tree,rt,right-left+1);",
            "    updataRange(tree,2*rt,left,mid,ul,ur,value);",
            "    updataRange(tree,2*rt+1,mid+1,right,ul,ur,value);",
            "    tree[rt].data=tree[2*rt].data+tree[2*rt+1].data;",
            "}"
        ],
        "description": "插入 带懒标记的线段数"
    },
    "最近公共祖先": {
        "prefix": "acm-4.1lca",
        "body": [
            "#include <iostream>",
            "#include <vector>",
            "#include <queue>",
            "using namespace std;",
            "",
            "const int MAXN = 1e5 + 5;",
            "const int LOG = 20;  // 2^20 > 1e5",
            "",
            "vector<int> adj[MAXN];",
            "vector<int> ch[MAXN];",
            "int depth[MAXN];",
            "int parent[MAXN][LOG];",
            "int n, m, root;",
            "",
            "// 预处理：计算每个节点的深度和2^k级祖先",
            "void dfs(int u, int p) {",
            "    depth[u] = depth[p] + 1;",
            "    parent[u][0] = p;",
            "    for (int k = 1; k < LOG; ++k) {",
            "        parent[u][k] = parent[parent[u][k-1]][k-1];",
            "    }",
            "    for (int v : adj[u]) {",
            "        if (v != p) {",
            "            ch[u].push_back(v);",
            "            dfs(v, u);",
            "        }",
            "    }",
            "}",
            "",
            "// 查找u和v的最近公共祖先",
            "int lca(int u, int v) {",
            "    if (depth[u] < depth[v]) {",
            "        swap(u, v);",
            "    }",
            "    // 将u提到与v同一深度",
            "    for (int k = LOG - 1; k >= 0; --k) {",
            "        if (depth[u] - (1 << k) >= depth[v]) {",
            "            u = parent[u][k];",
            "        }",
            "    }",
            "    if (u == v) {",
            "        return u;",
            "    }",
            "    // 同时向上跳",
            "    for (int k = LOG - 1; k >= 0; --k) {",
            "        if (parent[u][k] != parent[v][k]) {",
            "            u = parent[u][k];",
            "            v = parent[v][k];",
            "        }",
            "    }",
            "    return parent[u][0];",
            "}",
            "",
            "int main() {",
            "    ios::sync_with_stdio(false);",
            "    cin.tie(nullptr);",
            "",
            "    cin >> n >> m;",
            "    root = 1;",
            "    for (int i = 1; i < n; ++i) {",
            "        int u, v;",
            "        cin >> u >> v;",
            "        adj[u].push_back(v);",
            "        adj[v].push_back(u);",
            "    }",
            "",
            "    // 预处理",
            "    dfs(root, 0);",
            "",
            "    // lca查询",
            "    // cout << lca(u, v);",
            "    return 0;",
            "}"
        ],
        "description": "插入 最近公共祖先"
    },
    "线段树": {
        "prefix": "acm-2.6LazySegmentTree-full",
        "body": [
            "template<class Info, class Tag> struct LazySegmentTree {",
            "    int n;",
            "    vector<Info> info;",
            "    vector<Tag> tag;",
            "    LazySegmentTree(vector<Info> init) {",
            "        n = init.size();",
            "        info.assign(4 * n, Info());",
            "        tag.assign(4 * n, Tag());",
            "        function<void(int, int, int)> build = [&](int p, int l, int r) {",
            "            if (l == r) {",
            "                info[p] = init[l - 1];",
            "                return;",
            "            }",
            "            int m = (l + r) / 2;",
            "            build(2 * p, l, m);",
            "            build(2 * p + 1, m + 1, r);",
            "            pull(p);",
            "        };",
            "        build(1, 1, n);",
            "    }",
            "    void pull(int p) {",
            "        info[p] = info[2 * p] + info[2 * p + 1];",
            "    }",
            "    void apply(int p, const Tag &v) {",
            "        info[p].apply(v);",
            "        tag[p].apply(v);",
            "    }",
            "    void push(int p) {",
            "        apply(2 * p, tag[p]);",
            "        apply(2 * p + 1, tag[p]);",
            "        tag[p] = Tag();",
            "    }",
            "    void rangeApply(int p, int l, int r, int x, int y, const Tag &v) {",
            "        if (l > y || r < x) return;",
            "        if (l >= x && r <= y) {",
            "            apply(p, v);",
            "            return;",
            "        }",
            "        push(p);",
            "        int m = (l + r) / 2;",
            "        rangeApply(2 * p, l, m, x, y, v);",
            "        rangeApply(2 * p + 1, m + 1, r, x, y, v);",
            "        pull(p);",
            "    }",
            "    Info rangeQuery(int p, int l, int r, int x, int y) {",
            "        if (l > y || r < x) return Info();",
            "        if (l >= x && r <= y) return info[p];",
            "        push(p);",
            "        int m = (l + r) / 2;",
            "        return rangeQuery(2 * p, l, m, x, y) + rangeQuery(2 * p + 1, m + 1, r, x, y);",
            "    }",
            "};",
            "struct Tag {",
            "    LL x;",
            "    Tag(LL x = 0) { this->x = x; }",
            "    void apply(const Tag &t) { x += t.x; }",
            "};",
            "struct Info {",
            "    LL x, l, r;",
            "    Info(LL x = 0, LL l = 0, LL r = 0) { this->x = x; this->l = l; this->r = r; }",
            "    void apply(const Tag &t) { if (t.x) x += t.x * (r - l + 1); }",
            "};",
            "Info operator+(const Info &a, const Info &b) { return Info(a.x + b.x, a.l, b.r); }"
        ],
        "description": "插入 线段树"
    },
    "单调队列": {
        "prefix": "acm-2.3monotonic_queue",
        "body": [
            "vector<int> maxSlidingWindow(vector<int>& nums, int k) {",
            "    vector<int> res;",
            "    deque<int> dq;",
            "    int n = nums.size();",
            "    for (int i = 0; i < n; ++i) {",
            "        while (!dq.empty() && dq.front() < i - k + 1) {",
            "            dq.pop_front();",
            "        }",
            "        while (!dq.empty() && nums[i] >= nums[dq.back()]) {",
            "            dq.pop_back();",
            "        }",
            "        dq.push_back(i);",
            "        if (i >= k - 1) {",
            "            res.push_back(nums[dq.front()]);",
            "        }",
            "    }",
            "    return res;",
            "}"
        ],
        "description": "插入 单调队列"
    },
    "线性筛": {
        "prefix": "acm-7.1xianxingshai",
        "body": [
            "vector<int> pri;",
            "bool not_prime[N];",
            "void pre(int n) {",
            "    for (int i = 2; i <= n; i++) {",
            "        if (!not_prime[i]) {",
            "            pri.push_back(i);",
            "        }",
            "        for (int pri_j : pri) {",
            "            if (i * pri_j > n) break;",
            "            not_prime[i * pri_j] = true;",
            "            if (i % pri_j == 0) {",
            "                break;",
            "            }",
            "        }",
            "    }",
            "}"
        ],
        "description": "插入 线性筛"
    },
    "异或线性基": {
        "prefix": "acm-7.6xianxingji",
        "body": [
            "struct Basis{",
            "    static const int K=60;",
            "    ll a[K];",
            "    Basis(){memset(a,0,sizeof a);}",
            "    bool ins(ll x){",
            "        for(int i=K-1;~i;--i)",
            "        if(x>>i&1){",
            "            if(!a[i]){a[i]=x;return true;}",
            "            x^=a[i];",
            "        }",
            "        return false;",
            "    }",
            "    ll max_val(ll x=0){",
            "        for(int i=K-1;~i;--i)if((x^a[i])>x)x^=a[i];",
            "        return x;",
            "    }",
            "}B;"
        ],
        "description": "插入 异或线性基"
    },
    "树链剖分+MOD": {
        "prefix": "acm-4.2shulianpoufenMOD",
        "body": [
            "const int MAXN = 1e5 + 5;  // 最大节点数",
            "int N, M, R, P;  // 节点数、操作数、根节点、模数",
            "vector<int> adj[MAXN];  // 邻接表存储树结构",
            "int val[MAXN];  // 节点初始权值",
            "",
            "// 树链剖分相关变量",
            "int parent[MAXN];  // 父节点",
            "int depth[MAXN];   // 节点深度",
            "int sz[MAXN];      // 子树大小",
            "int heavy[MAXN];   // 重儿子",
            "int pos[MAXN];     // 节点在线段树中的位置",
            "int top[MAXN];     // 所在重链的顶部节点",
            "int current_pos;   // 当前DFS序位置",
            "",
            "// 线段树节点结构",
            "struct node {",
            "    int data;  // 节点值",
            "    int lazy;  // 懒标记",
            "    node() : data(0), lazy(0) {}",
            "};",
            "",
            "vector<node> tree;  // 线段树",
            "",
            "// 构建线段树",
            "void build(const vector<int>& datas, vector<node>& tree, int rt, int left, int right) {",
            "    if (left == right) {",
            "        tree[rt].data = datas[left];",
            "        return;",
            "    }",
            "    int mid = left + (right - left) / 2;",
            "    build(datas, tree, 2 * rt, left, mid);",
            "    build(datas, tree, 2 * rt + 1, mid + 1, right);",
            "    tree[rt].data = (tree[2 * rt].data + tree[2 * rt + 1].data) % P;",
            "}",
            "",
            "// 下传懒标记",
            "void pushDown(vector<node>& tree, int rt, int len) {",
            "    if (tree[rt].lazy != 0) {",
            "        tree[rt * 2].data = (tree[rt * 2].data + tree[rt].lazy * (len - len / 2)) % P;",
            "        tree[rt * 2].lazy = (tree[rt * 2].lazy + tree[rt].lazy) % P;",
            "        tree[rt * 2 + 1].data = (tree[rt * 2 + 1].data + tree[rt].lazy * (len / 2)) % P;",
            "        tree[rt * 2 + 1].lazy = (tree[rt * 2 + 1].lazy + tree[rt].lazy) % P;",
            "        tree[rt].lazy = 0;",
            "    }",
            "}",
            "",
            "// 线段树区间查询",
            "int query(vector<node>& tree, int rt, int left, int right, int ql, int qr) {",
            "    if (ql > right || qr < left) {",
            "        return 0;",
            "    }",
            "    if (ql <= left && qr >= right) {",
            "        return tree[rt].data;",
            "    }",
            "    pushDown(tree, rt, right - left + 1);",
            "    int mid = left + (right - left) / 2;",
            "    int leftsum = query(tree, 2 * rt, left, mid, ql, qr);",
            "    int rightsum = query(tree, 2 * rt + 1, mid + 1, right, ql, qr);",
            "    return (leftsum + rightsum) % P;",
            "}",
            "",
            "// 线段树区间更新",
            "void updateRange(vector<node>& tree, int rt, int left, int right, int ul, int ur, int value) {",
            "    if (ul > right || ur < left) return;",
            "    if (ul <= left && ur >= right) {",
            "        tree[rt].data = (tree[rt].data + value * (right - left + 1)) % P;",
            "        tree[rt].lazy = (tree[rt].lazy + value) % P;",
            "        return;",
            "    }",
            "    pushDown(tree, rt, right - left + 1);",
            "    int mid = left + (right - left) / 2;",
            "    updateRange(tree, 2 * rt, left, mid, ul, ur, value);",
            "    updateRange(tree, 2 * rt + 1, mid + 1, right, ul, ur, value);",
            "    tree[rt].data = (tree[2 * rt].data + tree[2 * rt + 1].data) % P;",
            "}",
            "",
            "// 第一次DFS：计算父节点、深度、子树大小和重儿子",
            "void dfs1(int u, int p) {",
            "    parent[u] = p;",
            "    depth[u] = depth[p] + 1;",
            "    sz[u] = 1;",
            "    heavy[u] = 0;",
            "    for (int v : adj[u]) {",
            "        if (v != p) {",
            "            dfs1(v, u);",
            "            sz[u] += sz[v];",
            "            if (sz[v] > sz[heavy[u]]) {",
            "                heavy[u] = v;",
            "            }",
            "        }",
            "    }",
            "}",
            "",
            "// 第二次DFS：进行重链剖分，计算DFS序和重链顶部",
            "void dfs2(int u, int p, int chain_top) {",
            "    pos[u] = ++current_pos;",
            "    top[u] = chain_top;",
            "    if (heavy[u]) {",
            "        dfs2(heavy[u], u, chain_top);",
            "    }",
            "    for (int v : adj[u]) {",
            "        if (v != p && v != heavy[u]) {",
            "            dfs2(v, u, v);",
            "        }",
            "    }",
            "}",
            "",
            "// 路径更新：将x到y路径上的节点值都加上z",
            "void pathUpdate(int x, int y, int z) {",
            "    while (top[x] != top[y]) {",
            "        if (depth[top[x]] > depth[top[y]]) {",
            "            swap(x, y);",
            "        }",
            "        updateRange(tree, 1, 1, N, pos[top[y]], pos[y], z);",
            "        y = parent[top[y]];",
            "    }",
            "    if (depth[x] > depth[y]) {",
            "        swap(x, y);",
            "    }",
            "    updateRange(tree, 1, 1, N, pos[x], pos[y], z);",
            "}",
            "",
            "// 路径查询：查询x到y路径上的节点值之和",
            "int pathQuery(int x, int y) {",
            "    int res = 0;",
            "    while (top[x] != top[y]) {",
            "        if (depth[top[x]] > depth[top[y]]) {",
            "            swap(x, y);",
            "        }",
            "        res = (res + query(tree, 1, 1, N, pos[top[y]], pos[y])) % P;",
            "        y = parent[top[y]];",
            "    }",
            "    if (depth[x] > depth[y]) {",
            "        swap(x, y);",
            "    }",
            "    res = (res + query(tree, 1, 1, N, pos[x], pos[y])) % P;",
            "    return res;",
            "}",
            "",
            "// 子树更新：将以x为根的子树所有节点值加上z",
            "void subtreeUpdate(int x, int z) {",
            "    int l = pos[x];",
            "    int r = pos[x] + sz[x] - 1;",
            "    updateRange(tree, 1, 1, N, l, r, z);",
            "}",
            "",
            "// 子树查询：查询以x为根的子树所有节点值之和",
            "int subtreeQuery(int x) {",
            "    int l = pos[x];",
            "    int r = pos[x] + sz[x] - 1;",
            "    return query(tree, 1, 1, N, l, r);",
            "}",
            "",
            "// 求两个节点的最近公共祖先（LCA）",
            "int lca(int x, int y) {",
            "    while (top[x] != top[y]) {",
            "        if (depth[top[x]] < depth[top[y]]) {",
            "            swap(x, y);",
            "        }",
            "        x = parent[top[x]];",
            "    }",
            "    return depth[x] < depth[y] ? x : y;",
            "}",
            "",
            "int main() {",
            "    ios::sync_with_stdio(false);",
            "    cin.tie(nullptr);",
            "",
            "    cin >> N >> M >> R >> P;",
            "    for (int i = 1; i <= N; ++i) {",
            "        cin >> val[i];",
            "    }",
            "    for (int i = 1; i < N; ++i) {",
            "        int x, y;",
            "        cin >> x >> y;",
            "        adj[x].push_back(y);",
            "        adj[y].push_back(x);",
            "    }",
            "",
            "    // 第一次DFS预处理",
            "    dfs1(R, 0);",
            "    current_pos = 0;",
            "    // 第二次DFS进行重链剖分",
            "    dfs2(R, 0, R);",
            "",
            "    // 构建线段树",
            "    vector<int> datas(N + 1);",
            "    for (int i = 1; i <= N; ++i) {",
            "        datas[pos[i]] = val[i] % P;",
            "    }",
            "",
            "    tree.resize(4 * (N + 1));",
            "    build(datas, tree, 1, 1, N);",
            "",
            "    // 处理操作",
            "    while (M--) {",
            "        int cmd;",
            "        cin >> cmd;",
            "        if (cmd == 1) {  // 路径更新",
            "            int x, y, z;",
            "            cin >> x >> y >> z;",
            "            pathUpdate(x, y, z);",
            "        } else if (cmd == 2) {  // 路径查询",
            "            int x, y;",
            "            cin >> x >> y;",
            "            cout << pathQuery(x, y) << '\\n';",
            "        } else if (cmd == 3) {  // 子树更新",
            "            int x, z;",
            "            cin >> x >> z;",
            "            subtreeUpdate(x, z);",
            "        } else if (cmd == 4) {  // 子树查询",
            "            int x;",
            "            cin >> x;",
            "            cout << subtreeQuery(x) << '\\n';",
            "        }",
            "    }",
            "",
            "    return 0;",
            "}"
        ],
        "description": "插入 树链剖分+MOD"
    },
    "网络流-最大流与最小割": {
        "prefix": "acm-3.5wangluoliu",
        "body": [
            "struct Edge {",
            "    int to, rev;",
            "    int cap;",
            "    bool is_cut; // 标记是否为割边",
            "};",
            "",
            "class MinCut {",
            "private:",
            "    std::vector<Edge> G[MAXN];",
            "    int level[MAXN];",
            "    int iter[MAXN];",
            "",
            "public:",
            "    // 添加一条从from到to，容量为cap的边",
            "    void addEdge(int from, int to, int cap) {",
            "        G[from].push_back({to, (int)G[to].size(), cap, false});",
            "        G[to].push_back({from, (int)G[from].size() - 1, 0, false});",
            "    }",
            "",
            "    // 构建层次图",
            "    bool bfs(int s, int t) {",
            "        memset(level, -1, sizeof(level));",
            "        std::queue<int> q;",
            "        level[s] = 0;",
            "        q.push(s);",
            "        while (!q.empty()) {",
            "            int v = q.front(); q.pop();",
            "            for (const auto& e : G[v]) {",
            "                if (e.cap > 0 && level[e.to] < 0) {",
            "                    level[e.to] = level[v] + 1;",
            "                    q.push(e.to);",
            "                }",
            "            }",
            "        }",
            "        return level[t] != -1;",
            "    }",
            "",
            "    // 在层次图上寻找增广路",
            "    int dfs(int v, int t, int upTo) {",
            "        if (v == t) return upTo;",
            "        for (int &i = iter[v]; i < G[v].size(); ++i) {",
            "            Edge &e = G[v][i];",
            "            if (e.cap > 0 && level[v] < level[e.to]) {",
            "                int d = dfs(e.to, t, std::min(upTo, e.cap));",
            "                if (d > 0) {",
            "                    e.cap -= d;",
            "                    G[e.to][e.rev].cap += d;",
            "                    return d;",
            "                }",
            "            }",
            "        }",
            "        return 0;",
            "    }",
            "",
            "    // 求最大流",
            "    int maxFlow(int s, int t) {",
            "        int flow = 0;",
            "        while (bfs(s, t)) {",
            "            memset(iter, 0, sizeof(iter));",
            "            int f;",
            "            while ((f = dfs(s, t, INF)) > 0) {",
            "                flow += f;",
            "            }",
            "        }",
            "        return flow;",
            "    }",
            "",
            "    // 获取最小割的割边集合",
            "    std::vector<std::pair<int, int>> getMinCutEdges(int s) {",
            "        std::vector<std::pair<int, int>> cutEdges;",
            "        bool vis[MAXN] = {0};",
            "        std::queue<int> q;",
            "        q.push(s);",
            "        vis[s] = true;",
            "        while (!q.empty()) {",
            "            int v = q.front(); q.pop();",
            "            for (const auto& e : G[v]) {",
            "                if (e.cap > 0 && !vis[e.to]) {",
            "                    vis[e.to] = true;",
            "                    q.push(e.to);",
            "                }",
            "            }",
            "        }",
            "        // 割边：从S集合到T集合的满流边",
            "        for (int u = 0; u < MAXN; ++u) {",
            "            if (vis[u]) {",
            "                for (const auto& e : G[u]) {",
            "                    if (!vis[e.to] && G[e.to][e.rev].cap > 0) {",
            "                        cutEdges.emplace_back(u, e.to);",
            "                    }",
            "                }",
            "            }",
            "        }",
            "        return cutEdges;",
            "    }",
            "",
            "    // 清空图",
            "    void clear(int n) {",
            "        for (int i = 0; i <= n; ++i) G[i].clear();",
            "    }",
            "};"
        ],
        "description": "插入 网络流-最大流与最小割"
    },
    "CPP-start": {
        "prefix": "acm-1.1CPP-start",
        "body": [
            "",
            "",
            "#include <iostream>",
            "using namespace std;",
            "",
            "int main(){",
            "    ",
            "    return 0;",
            "}"
        ],
        "description": "插入 CPP-start"
    },
    "欧拉筛.返回质数的个数。": {
        "prefix": "acm-7.1oulashai",
        "body": [
            "int prime[MAXN];              //保存质数",
            "int vis[MAXN];                //记录是否被筛",
            "int euler_sieve(int n){       //欧拉筛。返回质数的个数。",
            "    int cnt = 0;              //记录质数个数",
            "    memset(vis,0,sizeof(vis));",
            "    memset(prime,0,sizeof(prime));",
            "    for(int i=2;i<=n;i++){             //检查每个数，筛去其中的合数",
            "        if(!vis[i]) prime[cnt++]=i;    //如果没有筛过，是质数，记录。第一个质数是2",
            "        for(int j=0; j<cnt; j++){      //用已经得到的质数去筛后面的数",
            "            if(i*prime[j] >n)  break;  //只筛小于等于n的数",
            "            vis[i*prime[j]]=1;         //关键1。用x的最小质因数筛去x",
            "            if(i%prime[j]==0)  break;  //关键2。如果不是这个数的最小质因子，结束",
            "        }",
            "    }",
            "    return cnt;                        //返回小于等于n的素数的个数",
            "}"
        ],
        "description": "插入 欧拉筛.返回质数的个数。"
    },
    "单调栈类": {
        "prefix": "acm-2.3monotonic_stack",
        "body": [
            "// 单调栈：寻找每个元素右侧第一个比它大的元素",
            "vector<int> nextGreaterElement(vector<int>& nums) {",
            "    int n = nums.size();",
            "    vector<int> res(n, -1);",
            "    stack<int> st;",
            "    for (int i = 0; i < n; ++i) {",
            "        while (!st.empty() && nums[i] > nums[st.top()]) {",
            "            res[st.top()] = nums[i];",
            "            st.pop();",
            "        }",
            "        st.push(i);",
            "    }",
            "    return res;",
            "}"
        ],
        "description": "插入 单调栈类"
    },
    "树链剖分": {
        "prefix": "acm-4.3重链剖分",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "int n,m,x,y,z,T,P,op,root,A[N],AA[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Killed_Tree{",
            "\tstruct QAQ{int to,next;}a[N<<1];",
            "\tint o,id_o,fa[N],id[N],idx[N],top[N],son[N],size[N],deep[N],head[N];",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tstruct Segment_Tree{",
            "\t\t#define pl (p<<1)",
            "\t\t#define pr (p<<1|1)",
            "\t\t#define mid (L+R>>1)",
            "\t\tstruct QAQ{int S,l,r,add;}tr[N<<2];",
            "\t\tinline void pushdown(Re p){",
            "\t\t\tRe v=tr[p].add;",
            "\t\t\tif(v){",
            "\t\t\t\t(tr[pl].S+=v*(tr[pl].r-tr[pl].l+1)%P)%=P,(tr[pl].add+=v)%=P;",
            "\t\t\t\t(tr[pr].S+=v*(tr[pr].r-tr[pr].l+1)%P)%=P,(tr[pr].add+=v)%=P;",
            "\t\t\t\ttr[p].add=0;",
            "\t\t\t}",
            "\t\t}",
            "\t\tinline void build(Re p,Re L,Re R){",
            "\t\t\ttr[p].l=L,tr[p].r=R;",
            "\t\t\tif(L==R){tr[p].S=AA[L]%P;return;}",
            "\t\t\tbuild(pl,L,mid),build(pr,mid+1,R);",
            "\t\t\ttr[p].S=(tr[pl].S+tr[pr].S)%P;",
            "\t\t}",
            "\t\tinline void change(Re p,Re l,Re r,Re v){",
            "\t\t\tRe L=tr[p].l,R=tr[p].r;",
            "\t\t\tif(l<=L&&R<=r){(tr[p].S+=v*(R-L+1)%P)%=P,(tr[p].add+=v)%=P;return;}",
            "\t\t\tpushdown(p);",
            "\t\t\tif(l<=mid)change(pl,l,r,v);",
            "\t\t\tif(r>mid)change(pr,l,r,v);",
            "\t\t\ttr[p].S=(tr[pl].S+tr[pr].S)%P;",
            "\t\t}",
            "\t\tinline int ask(Re p,Re l,Re r){",
            "\t\t\tRe L=tr[p].l,R=tr[p].r;",
            "\t\t\tif(l<=L&&R<=r)return tr[p].S;",
            "\t\t\tRe ans=0;pushdown(p);",
            "\t\t\tif(l<=mid)(ans+=ask(pl,l,r))%=P;",
            "\t\t\tif(r>mid)(ans+=ask(pr,l,r))%=P;",
            "\t\t\treturn ans;",
            "\t\t}",
            "\t}TR;",
            "\tinline void dfs1(Re x,Re Fa){",
            "\t\tsize[x]=1,deep[x]=deep[fa[x]=Fa]+1;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=Fa){",
            "\t\t\t\tdfs1(to,x);",
            "\t\t\t\tsize[x]+=size[to];",
            "\t\t\t\tif(size[to]>size[son[x]])son[x]=to;",
            "\t\t\t}",
            "\t}",
            "\tinline void dfs2(Re x,Re rt){",
            "\t\tid[x]=++id_o,idx[id_o]=x,AA[id_o]=A[x],top[x]=rt;",
            "\t\tif(!son[x])return;//Ҷ�ڵ�",
            "\t\tdfs2(son[x],rt);",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=fa[x]&&to!=son[x])dfs2(to,to);",
            "\t}",
            "\tinline void kill(Re rt){dfs1(rt,0),dfs2(rt,rt),TR.build(1,1,n);}",
            "\tinline int ask_dis(Re x,Re y){",
            "\t\tRe ans=0;",
            "\t\twhile(top[x]!=top[y]){",
            "\t\t\tif(deep[top[x]]<deep[top[y]])swap(x,y);",
            "\t\t\t(ans+=TR.ask(1,id[top[x]],id[x]))%=P;",
            "\t\t\tx=fa[top[x]];",
            "\t\t}",
            "\t\tif(deep[x]>deep[y])swap(x,y);",
            "\t\t(ans+=TR.ask(1,id[x],id[y]))%=P;",
            "\t\treturn ans;",
            "\t}",
            "\tinline void change_dis(Re x,Re y,Re v){",
            "\t\twhile(top[x]!=top[y]){",
            "\t\t\tif(deep[top[x]]<deep[top[y]])swap(x,y);",
            "\t\t\tTR.change(1,id[top[x]],id[x],v);",
            "\t\t\tx=fa[top[x]];",
            "\t\t}",
            "\t\tif(deep[x]>deep[y])swap(x,y);",
            "\t\tTR.change(1,id[x],id[y],v);",
            "\t}",
            "\tinline int ask_son(Re x){",
            "\t\treturn TR.ask(1,id[x],id[x]+size[x]-1);",
            "\t}",
            "\tinline void change_son(Re x,Re v){",
            "\t\tTR.change(1,id[x],id[x]+size[x]-1,v);",
            "\t}",
            "}T1;",
            "int main(){",
            "\tin(n),in(T),in(root),in(P),m=n-1;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\twhile(m--)in(x),in(y),T1.add(x,y),T1.add(y,x);",
            "\tT1.kill(root);",
            "\twhile(T--){",
            "\t\tin(op);",
            "\t\tif(op<2)in(x),in(y),in(z),T1.change_dis(x,y,z%P);",
            "\t\telse if(op<3)in(x),in(y),printf(\"%d\\n\",T1.ask_dis(x,y));",
            "\t\telse if(op<4)in(x),in(z),T1.change_son(x,z%P);",
            "\t\telse in(x),printf(\"%d\\n\",T1.ask_son(x));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 树链剖分"
    },
    "线段树- mex": {
        "prefix": "acm-2.6segment-tree-mex",
        "body": [
            "struct tnode {",
            "    int l, r;",
            "    int mins;",
            "};",
            "",
            "struct Segment {",
            "    tnode t[4 * N];",
            "    int fa[4 * N];",
            "    void built(int root, int l, int r) {",
            "        \"\"\"",
            "        构建线段树",
            "        :param root: 当前节点",
            "        :param l: 左端点",
            "        :param r: 右端点",
            "        \"\"\"",
            "        t[root].l = l;",
            "        t[root].r = r;",
            "        if (l == r) {",
            "            t[root].mins = 0;",
            "            fa[l] = root;",
            "            return;",
            "        }",
            "        int ch = root << 1;",
            "        int mid = (l + r) >> 1;",
            "        built(ch, l, mid);",
            "        built(ch + 1, mid + 1, r);",
            "        t[root].mins = min(t[ch].mins, t[ch + 1].mins);",
            "    }",
            "    void modify(int num, int pos) {",
            "        \"\"\"",
            "        修改线段树",
            "        :param num: 要修改的位置",
            "        :param pos: 要修改的值",
            "        \"\"\"",
            "        int root = fa[num];",
            "        t[root].mins = pos;",
            "        root >>= 1;",
            "        while (root) {",
            "            int ch = root << 1;",
            "            t[root].mins = min(t[ch].mins, t[ch + 1].mins);",
            "            root >>= 1;",
            "        }",
            "    }",
            "    int query(int l) {",
            "        \"\"\"",
            "        查询线段树",
            "        :param l: 查询的左端点",
            "        :return: 最小的未被覆盖的位置",
            "        \"\"\"",
            "        int root = 1;",
            "        while (t[root].l != t[root].r) {",
            "            int ch = root << 1;",
            "            if (t[ch].mins >= l) {",
            "                root = ch + 1;",
            "            } else {",
            "                root = ch;",
            "            }",
            "        }",
            "        return t[root].l - 1;",
            "    }",
            "} ST;",
            "",
            "// int main() {",
            "//     // 初始化线段树，假设值范围是1到n",
            "//     int n;",
            "//     cin >> n;",
            "//     ST.built(1, 1, n);",
            "//     // 示例：处理m次操作",
            "//     int m;",
            "//     cin >> m;",
            "//     while (m--) {",
            "//         int op, x, y;",
            "//         cin >> op;",
            "//         if (op == 1) {",
            "//             cin >> x >> y;",
            "//             ST.modify(x, y);",
            "//         } else if (op == 2) {",
            "//             cin >> x;",
            "//             cout << ST.query(x) << '\\n';",
            "//         }",
            "//     }",
            "// }"
        ],
        "description": "插入 线段树- mex"
    },
    "高斯消元-解加法方程组": {
        "prefix": "acm-7.5gauss-add",
        "body": [
            "bool Gauss(Matrix a, int n) {",
            "\tfor(int i=1; i<=n; i++) {",
            "\t\tint r=i;",
            "\t\tfor(int j=i+1; j<=n; j++) ",
            "\t\t\tif(abs(a[j][i]) > abs(a[r][i])) r=j;",
            "\t\tif(abs(a[r][i])<eps) return false;",
            "\t\tif(r!=i) for(int j=1; j<=n+1; j++) swap(a[r][j], a[i][j]);",
            "\t\t",
            "\t\tfor(int j=i+1; j<=n; j++) {",
            "\t\t\tdouble t = a[j][i]/a[i][i];",
            "\t\t\tfor(int k=i; k<=n+1; k++) a[j][k] -= t*a[i][k];",
            "\t\t}",
            "\t}",
            "\tfor(int i=n; i>=1; i--) {",
            "\t\tfor(int j=n; j>i; j--) a[i][n+1] -= a[i][j]*a[j][n+1];",
            "\t\ta[i][n+1] /= a[i][i];",
            "\t}",
            "\treturn true;",
            "}"
        ],
        "description": "插入 高斯消元-解加法方程组"
    },
    "时间随机种子": {
        "prefix": "acm-1.5random",
        "body": [
            "auto now = chrono::high_resolution_clock::now();",
            "auto seed = now.time_since_epoch().count();",
            "srand(static_cast<unsigned int>(seed));"
        ],
        "description": "插入 时间随机种子"
    },
    "扑克牌模板": {
        "prefix": "acm-1.5poker",
        "body": [
            "",
            "struct Card",
            "{",
            "    int suit, rank; // 花色 0..3, 点数 2..14",
            "",
            "    Card() : Card(0, 0) {}",
            "    Card(char suit_ch, char rank_ch) : Card(GetSuit(suit_ch), GetRank(rank_ch)) {}",
            "    Card(int suit, int rank) : suit(suit), rank(rank) {}",
            "",
            "    static int GetSuit(char ch)",
            "    {",
            "        if (ch == 'C') return 0;",
            "        if (ch == 'D') return 1;",
            "        if (ch == 'H') return 2;",
            "        return 3; // 'S'",
            "    }",
            "    static int GetRank(char ch)",
            "    {",
            "        if (ch == 'A') return 14;",
            "        if (ch == 'K') return 13;",
            "        if (ch == 'Q') return 12;",
            "        if (ch == 'J') return 11;",
            "        if (ch == 'T') return 10;",
            "        return ch - '0';",
            "    }",
            "",
            "    bool operator < (const Card &rhs) const { return rank < rhs.rank; }",
            "    bool operator == (const Card &rhs) const { return rank == rhs.rank && suit == rhs.suit; }",
            "};",
            "",
            "",
            "struct CombEval",
            "{",
            "    enum class Type : int",
            "    {",
            "        Unspecified = 0,",
            "        HighCard,      // 高牌",
            "        Pair,          // 一对",
            "        TwoPairs,      // 两对",
            "        Three,         // 三条",
            "        Straight,      // 顺子",
            "        Flush,         // 同花",
            "        FullHouse,     // 葫芦",
            "        Four,          // 四条",
            "        StraightFlush, // 同花顺",
            "        RoyalFlush,    // 皇家同花顺",
            "    };",
            "",
            "    CombEval() : CombEval(Type::Unspecified, {}) {}",
            "    CombEval(Type type, const vector<Card> &cards) : type(type), cards(cards) {}",
            "",
            "    ",
            "",
            "    // 高牌 — 任何牌都至少是高牌",
            "    bool TryHighCard() { return true; }",
            "",
            "    // 一对 — 找出唯一一对，将其余牌按点数降序排列到前面",
            "    bool TryPair()",
            "    {",
            "        int id = -1;",
            "        for (int i = 0; id == -1 && i <= 3; i++)",
            "            if (cards[i].rank == cards[i + 1].rank)",
            "                id = i;",
            "        if (id == -1) return false;",
            "",
            "        int main_rank = cards[id].rank;",
            "        // 将对子移到末尾，其余牌按降序前置",
            "        for (int i = 0, cnt = 0; i <= 4; i++)",
            "            if (cards[i].rank != main_rank)",
            "            {",
            "                for (int j = i; j > cnt; j--)",
            "                    swap(cards[j], cards[j - 1]);",
            "                cnt++;",
            "            }",
            "        return true;",
            "    }",
            "",
            "    // 两对 — 找出两对，将非对子牌移到最前",
            "    bool TryTwoPairs()",
            "    {",
            "        int id1 = -1, id2 = -1;",
            "        for (int i = 0; i <= 3; i++)",
            "            if (cards[i].rank == cards[i + 1].rank)",
            "            {",
            "                if (id1 == -1) id1 = i;",
            "                else id2 = i;",
            "                i++;",
            "            }",
            "        if (id1 == -1 || id2 == -1) return false;",
            "",
            "        // 将单牌移到最前，便于比较",
            "        for (int j = 8 - id1 * 2 - id2 * 2; j; j--)",
            "            swap(cards[j], cards[j - 1]);",
            "        return true;",
            "    }",
            "",
            "    // 三条 — 找出唯一三条，将其余牌按降序前置",
            "    bool TryThree()",
            "    {",
            "        int id = -1;",
            "        for (int i = 0; id == -1 && i <= 2; i++)",
            "            if (cards[i].rank == cards[i + 1].rank && cards[i].rank == cards[i + 2].rank)",
            "                id = i;",
            "        if (id == -1) return false;",
            "",
            "        int main_rank = cards[id].rank;",
            "        for (int i = 0, cnt = 0; i <= 4; i++)",
            "            if (cards[i].rank != main_rank)",
            "            {",
            "                for (int j = i; j > cnt; j--)",
            "                    swap(cards[j], cards[j - 1]);",
            "                cnt++;",
            "            }",
            "        return true;",
            "    }",
            "",
            "    // 顺子 — 判断是否连续；处理 A-2-3-4-5 特殊顺",
            "    bool TryStraight()",
            "    {",
            "        for (int i = 1; i <= 3; i++)",
            "            if (cards[i].rank != cards[i - 1].rank + 1)",
            "                return false;",
            "        if (cards[4].rank == cards[3].rank + 1)",
            "            return true;",
            "        // A-2-3-4-5 特殊顺：cards = {2,3,4,5,14}",
            "        if (cards[4].rank == 14 && cards[0].rank == 2)",
            "        {",
            "            // 将 A 移到末尾 ⇒ {2,3,4,5,14} → {14,2,3,4,5}，便于比较",
            "            for (int i = 4; i; i--)",
            "                swap(cards[i], cards[i - 1]);",
            "            return true;",
            "        }",
            "        return false;",
            "    }",
            "",
            "    // 同花 — 所有牌花色相同",
            "    bool TryFlush()",
            "    {",
            "        for (const Card &card : cards)",
            "            if (card.suit != cards[0].suit)",
            "                return false;",
            "        return true;",
            "    }",
            "",
            "    // 葫芦 — 三条 + 一对",
            "    bool TryFullHouse()",
            "    {",
            "        if (!TryThree()) return false;",
            "        return cards[0].rank == cards[1].rank;",
            "    }",
            "",
            "    // 四条 — 四张相同点数",
            "    bool TryFour()",
            "    {",
            "        if (!TryThree()) return false;",
            "        return cards[1].rank == cards[2].rank;",
            "    }",
            "",
            "    // 同花顺",
            "    bool TryStraightFlush() { return TryFlush() && TryStraight(); }",
            "",
            "    // 皇家同花顺 — 同花顺且最小牌为 10（10,J,Q,K,A）",
            "    bool TryRoyalFlush()",
            "    {",
            "        if (!TryStraightFlush()) return false;",
            "        return cards[0].rank == 10;",
            "    }",
            "",
            "    ",
            "    void Sort()",
            "    {",
            "        sort(cards.begin(), cards.end());",
            "    }",
            "",
            "    ",
            "    bool operator < (const CombEval &rhs) const",
            "    {",
            "        if (type != rhs.type)",
            "            return int(type) < int(rhs.type);",
            "        // 从最大牌开始比较",
            "        for (int i = 4; i >= 0; i--)",
            "            if ((cards[i] < rhs.cards[i]) || (rhs.cards[i] < cards[i]))",
            "                return cards[i] < rhs.cards[i];",
            "        return false;",
            "    }",
            "    bool operator == (const CombEval &rhs) const",
            "    {",
            "        return !(*this < rhs) && !(rhs < *this);",
            "    }",
            "",
            "    Type type;",
            "    vector<Card> cards;",
            "};",
            "",
            "",
            "CombEval GetCombEval(const vector<Card> &cards)",
            "{",
            "    CombEval ret;",
            "    ret.cards = cards;",
            "    ret.Sort();",
            "",
            "    bool ok = false;",
            "    if (!ok && ret.TryRoyalFlush())    ret.type = CombEval::Type::RoyalFlush,    ok = true;",
            "    ret.Sort();",
            "    if (!ok && ret.TryStraightFlush()) ret.type = CombEval::Type::StraightFlush, ok = true;",
            "    if (!ok && ret.TryFour())          ret.type = CombEval::Type::Four,          ok = true;",
            "    if (!ok && ret.TryFullHouse())     ret.type = CombEval::Type::FullHouse,     ok = true;",
            "    if (!ok && ret.TryFlush())         ret.type = CombEval::Type::Flush,         ok = true;",
            "    if (!ok && ret.TryStraight())      ret.type = CombEval::Type::Straight,      ok = true;",
            "    if (!ok && ret.TryThree())         ret.type = CombEval::Type::Three,         ok = true;",
            "    if (!ok && ret.TryTwoPairs())      ret.type = CombEval::Type::TwoPairs,      ok = true;",
            "    if (!ok && ret.TryPair())          ret.type = CombEval::Type::Pair,          ok = true;",
            "    if (!ok && ret.TryHighCard())      ret.type = CombEval::Type::HighCard,      ok = true;",
            "    return ret;",
            "}"
        ],
        "description": "插入 扑克牌模板"
    },
    "计算几何大板子": {
        "prefix": "acm-8.3Geometry",
        "body": [
            "namespace Geometry {",
            "using T = ll;",
            "constexpr T eps = 0;",
            "",
            "bool eq(const T &x, const T &y) { return abs(x - y) <= eps; }",
            "inline constexpr int type(T x, T y) {",
            "    if(x == 0 and y == 0) return 0;",
            "    if(y < 0 or (y == 0 and x > 0)) return -1;",
            "    return 1;",
            "}",
            "struct Point {",
            "    T x, y;",
            "    constexpr Point(T _x = 0, T _y = 0) : x(_x), y(_y) {}",
            "    constexpr Point operator+() const noexcept { return *this; }",
            "    constexpr Point operator-() const noexcept { return Point(-x, -y); }",
            "    constexpr Point operator+(const Point &p) const { return Point(x + p.x, y + p.y); }",
            "    constexpr Point operator-(const Point &p) const { return Point(x - p.x, y - p.y); }",
            "    constexpr Point &operator+=(const Point &p) { return x += p.x, y += p.y, *this; }",
            "    constexpr Point &operator-=(const Point &p) { return x -= p.x, y -= p.y, *this; }",
            "    constexpr T operator*(const Point &p) const { return x * p.x + y * p.y; }",
            "    constexpr Point &operator*=(const T &k) { return x *= k, y *= k, *this; }",
            "    constexpr Point operator*(const T &k) { return Point(x * k, y * k); }",
            "    constexpr bool operator==(const Point &r) const noexcept { return r.x == x and r.y == y; }",
            "    constexpr T cross(const Point &r) const { return x * r.y - y * r.x; }",
            "",
            "    constexpr bool operator<(const Point &r) const { return pair(x, y) < pair(r.x, r.y); }",
            "",
            "    // 1 : left, 0 : same, -1 : right",
            "    constexpr int toleft(const Point &r) const {",
            "        auto t = cross(r);",
            "        return t > eps ? 1 : t < -eps ? -1 : 0;",
            "    }",
            "",
            "    constexpr bool arg_cmp(const Point &r) const {",
            "        int L = type(x, y), R = type(r.x, r.y);",
            "        if(L != R) return L < R;",
            "",
            "        T X = x * r.y, Y = r.x * y;",
            "        if(X != Y) return X > Y;",
            "        return x < r.x;",
            "    }",
            "};",
            "bool arg_cmp(const Point &l, const Point &r) { return l.arg_cmp(r); }",
            "ostream &operator<<(ostream &os, const Point &p) { return os << p.x << \" \" << p.y; }",
            "istream &operator>>(istream &is, Point &p) {",
            "    is >> p.x >> p.y;",
            "    return is;",
            "}",
            "",
            "struct Line {",
            "    Point a, b;",
            "    Line() = default;",
            "    Line(Point a, Point b) : a(a), b(b) {}",
            "    // ax + by = c",
            "    Line(T A, T B, T C) {",
            "        if(A == 0) {",
            "            a = Point(0, C / B), b = Point(1, C / B);",
            "        } else if(B == 0) {",
            "            a = Point(C / A, 0), b = Point(C / A, 1);",
            "        } else {",
            "            a = Point(0, C / B), b = Point(C / A, 0);",
            "        }",
            "    }",
            "    // 1 : left, 0 : same, -1 : right",
            "    constexpr int toleft(const Point &r) const {",
            "        auto t = (b - a).cross(r - a);",
            "        return t > eps ? 1 : t < -eps ? -1 : 0;",
            "    }",
            "",
            "    friend std::ostream &operator<<(std::ostream &os, Line &ls) {",
            "        return os << \"{\"",
            "                  << \"(\" << ls.a.x << \", \" << ls.a.y << \"), (\" << ls.b.x << \", \" << ls.b.y << \")}\";",
            "    }",
            "};",
            "istream &operator>>(istream &is, Line &p) { return is >> p.a >> p.b; }",
            "",
            "struct Segment : Line {",
            "    Segment() = default;",
            "    Segment(Point a, Point b) : Line(a, b) {}",
            "};",
            "",
            "ostream &operator<<(ostream &os, Segment &p) { return os << p.a << \" to \" << p.b; }",
            "istream &operator>>(istream &is, Segment &p) {",
            "    is >> p.a >> p.b;",
            "    return is;",
            "}",
            "",
            "struct Circle {",
            "    Point p;",
            "    T r;",
            "    Circle() = default;",
            "    Circle(Point p, T r) : p(p), r(r) {}",
            "};",
            "",
            "using pt = Point;",
            "using Points = vector<pt>;",
            "using Polygon = Points;",
            "T cross(const pt &x, const pt &y) { return x.x * y.y - x.y * y.x; }",
            "T dot(const pt &x, const pt &y) { return x.x * y.x + x.y * y.y; }",
            "",
            "T abs2(const pt &x) { return dot(x, x); }",
            "// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_1_C",
            "// 点の回転方向",
            "int ccw(const Point &a, Point b, Point c) {",
            "    b = b - a, c = c - a;",
            "    if(cross(b, c) > 0) return +1;   // \"COUNTER_CLOCKWISE\"",
            "    if(cross(b, c) < 0) return -1;   // \"CLOCKWISE\"",
            "    if(dot(b, c) < 0) return +2;     // \"ONLINE_BACK\"",
            "    if(abs2(b) < abs2(c)) return -2; // \"ONLINE_FRONT\"",
            "    return 0;                        // \"ON_SEGMENT\"",
            "}",
            "",
            "// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_A",
            "// 平行判定",
            "bool parallel(const Line &a, const Line &b) { return (cross(a.b - a.a, b.b - b.a) == 0); }",
            "",
            "// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_A",
            "// 垂直判定",
            "bool orthogonal(const Line &a, const Line &b) { return (dot(a.a - a.b, b.a - b.b) == 0); }",
            "",
            "bool intersect(const Line &l, const Point &p) { return abs(ccw(l.a, l.b, p)) != 1; }",
            "",
            "bool intersect(const Line &l, const Line &m) { return !parallel(l, m); }",
            "",
            "bool intersect(const Segment &s, const Point &p) { return ccw(s.a, s.b, p) == 0; }",
            "",
            "bool intersect(const Line &l, const Segment &s) { return cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) <= 0; }",
            "",
            "// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_B",
            "bool intersect(const Segment &s, const Segment &t) { return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 && ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0; }",
            "",
            "bool intersect(const Polygon &ps, const Polygon &qs) {",
            "    int pl = si(ps), ql = si(qs), i = 0, j = 0;",
            "    while((i < pl or j < ql) and (i < 2 * pl) and (j < 2 * ql)) {",
            "        auto ps0 = ps[(i + pl - 1) % pl], ps1 = ps[i % pl];",
            "        auto qs0 = qs[(j + ql - 1) % ql], qs1 = qs[j % ql];",
            "        if(intersect(Segment(ps0, ps1), Segment(qs0, qs1))) return true;",
            "        Point a = ps1 - ps0;",
            "        Point b = qs1 - qs0;",
            "        T v = cross(a, b);",
            "        T va = cross(qs1 - qs0, ps1 - qs0);",
            "        T vb = cross(ps1 - ps0, qs1 - ps0);",
            "",
            "        if(!v and va < 0 and vb < 0) return false;",
            "        if(!v and !va and !vb) {",
            "            i += 1;",
            "        } else if(v >= 0) {",
            "            if(vb > 0)",
            "                i += 1;",
            "            else",
            "                j += 1;",
            "        } else {",
            "            if(va > 0)",
            "                j += 1;",
            "            else",
            "                i += 1;",
            "        }",
            "    }",
            "    return false;",
            "}",
            "",
            "T norm(const Point &p) { return p.x * p.x + p.y * p.y; }",
            "Point projection(const Segment &l, const Point &p) {",
            "    T t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);",
            "    return l.a + (l.a - l.b) * t;",
            "}",
            "",
            "Point crosspoint(const Line &l, const Line &m) {",
            "    T A = cross(l.b - l.a, m.b - m.a);",
            "    T B = cross(l.b - l.a, l.b - m.a);",
            "    if(A == 0 and B == 0) return m.a;",
            "    return m.a + (m.b - m.a) * (B / A);",
            "}",
            "",
            "// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_C",
            "Point crosspoint(const Segment &l, const Segment &m) { return crosspoint(Line(l), Line(m)); }",
            "",
            "// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_3_B",
            "// 凸性判定",
            "bool is_convex(const Points &p) {",
            "    int n = (int)p.size();",
            "    for(int i = 0; i < n; i++) {",
            "        if(ccw(p[(i + n - 1) % n], p[i], p[(i + 1) % n]) == -1) return false;",
            "    }",
            "    return true;",
            "}",
            "",
            "Points convex_hull(Points p) {",
            "    int n = p.size(), k = 0;",
            "    if(n <= 2) return p;",
            "    sort(begin(p), end(p), [](pt x, pt y) { return (x.x != y.x ? x.x < y.x : x.y < y.y); });",
            "    Points ch(2 * n);",
            "    for(int i = 0; i < n; ch[k++] = p[i++]) {",
            "        while(k >= 2 && cross(ch[k - 1] - ch[k - 2], p[i] - ch[k - 1]) <= 0) --k;",
            "    }",
            "    for(int i = n - 2, t = k + 1; i >= 0; ch[k++] = p[i--]) {",
            "        while(k >= t && cross(ch[k - 1] - ch[k - 2], p[i] - ch[k - 1]) <= 0) --k;",
            "    }",
            "    ch.resize(k - 1);",
            "    return ch;",
            "}",
            "",
            "// 面積の 2 倍",
            "T area2(const Points &p) {",
            "    T res = 0;",
            "    rep(i, si(p)) { res += cross(p[i], p[i == si(p) - 1 ? 0 : i + 1]); }",
            "    return res;",
            "}",
            "",
            "enum { _OUT, _ON, _IN };",
            "",
            "int contains(const Polygon &Q, const Point &p) {",
            "    bool in = false;",
            "    for(int i = 0; i < Q.size(); i++) {",
            "        Point a = Q[i] - p, b = Q[(i + 1) % Q.size()] - p;",
            "        if(a.y > b.y) swap(a, b);",
            "        if(a.y <= 0 && 0 < b.y && cross(a, b) < 0) in = !in;",
            "        if(cross(a, b) == 0 && dot(a, b) <= 0) return _ON;",
            "    }",
            "    return in ? _IN : _OUT;",
            "}",
            "",
            "Polygon Minkowski_sum(const Polygon &P, const Polygon &Q) {",
            "    vector<Segment> e1(P.size()), e2(Q.size()), ed(P.size() + Q.size());",
            "    const auto cmp = [](const Segment &u, const Segment &v) { return (u.b - u.a).arg_cmp(v.b - v.a); };",
            "    rep(i, P.size()) e1[i] = {P[i], P[(i + 1) % P.size()]};",
            "    rep(i, Q.size()) e2[i] = {Q[i], Q[(i + 1) % Q.size()]};",
            "    rotate(begin(e1), min_element(all(e1), cmp), end(e1));",
            "    rotate(begin(e2), min_element(all(e2), cmp), end(e2));",
            "    merge(all(e1), all(e2), begin(ed), cmp);",
            "    const auto check = [](const Points &res, const Point &u) {",
            "        const auto back1 = res.back(), back2 = *prev(end(res), 2);",
            "        return eq(cross(back1 - back2, u - back2), eps) and dot(back1 - back2, u - back1) >= -eps;",
            "    };",
            "    auto u = e1[0].a + e2[0].a;",
            "    Points res{u};",
            "    res.reserve(P.size() + Q.size());",
            "    for(const auto &v : ed) {",
            "        u = u + v.b - v.a;",
            "        while(si(res) >= 2 and check(res, u)) res.pop_back();",
            "        res.eb(u);",
            "    }",
            "    if(res.size() and check(res, res[0])) res.pop_back();",
            "    return res;",
            "}",
            "",
            "// -1 : on, 0 : out, 1 : in",
            "// O(log(n))",
            "int is_in(const Polygon &p, const Point &a) {",
            "    if(p.size() == 1) return a == p[0] ? -1 : 0;",
            "    if(p.size() == 2) return intersect(Segment(p[0], p[1]), a);",
            "    if(a == p[0]) return -1;",
            "    if((p[1] - p[0]).toleft(a - p[0]) == -1 || (p.back() - p[0]).toleft(a - p[0]) == 1) return 0;",
            "    const auto cmp = [&](const Point &u, const Point &v) { return (u - p[0]).toleft(v - p[0]) == 1; };",
            "    const size_t i = lower_bound(p.begin() + 1, p.end(), a, cmp) - p.begin();",
            "    if(i == 1) return intersect(Segment(p[0], p[i]), a) ? -1 : 0;",
            "    if(i == p.size() - 1 && intersect(Segment(p[0], p[i]), a)) return -1;",
            "    if(intersect(Segment(p[i - 1], p[i]), a)) return -1;",
            "    return (p[i] - p[i - 1]).toleft(a - p[i - 1]) > 0;",
            "}",
            "",
            "Points halfplane_intersection(vector<Line> L, const T inf = 1e9) {",
            "    Point box[4] = {Point(inf, inf), Point(-inf, inf), Point(-inf, -inf), Point(inf, -inf)};",
            "    rep(i, 4) { L.emplace_back(box[i], box[(i + 1) % 4]); }",
            "    sort(all(L), [](const Line &l, const Line &r) { return (l.b - l.a).arg_cmp(r.b - r.a); });",
            "    deque<Line> dq;",
            "    int len = 0;",
            "    auto check = [](const Line &a, const Line &b, const Line &c) { return a.toleft(crosspoint(b, c)) == -1; };",
            "    rep(i, L.size()) {",
            "        while(dq.size() > 1 and check(L[i], *(end(dq) - 2), *(end(dq) - 1))) dq.pop_back();",
            "        while(dq.size() > 1 and check(L[i], dq[0], dq[1])) dq.pop_front();",
            "        // dump(L[i], si(dq));",
            "",
            "        if(dq.size() and eq(cross(L[i].b - L[i].a, dq.back().b - dq.back().a), 0)) {",
            "            if(dot(L[i].b - L[i].a, dq.back().b - dq.back().a) < eps) return {};",
            "            if(L[i].toleft(dq.back().a) == -1)",
            "                dq.pop_back();",
            "            else",
            "                continue;",
            "        }",
            "        dq.emplace_back(L[i]);",
            "    }",
            "",
            "    while(dq.size() > 2 and check(dq[0], *(end(dq) - 2), *(end(dq) - 1))) dq.pop_back();",
            "    while(dq.size() > 2 and check(dq.back(), dq[0], dq[1])) dq.pop_front();",
            "    if(si(dq) < 3) return {};",
            "    Polygon ret(dq.size());",
            "    rep(i, dq.size()) ret[i] = crosspoint(dq[i], dq[(i + 1) % dq.size()]);",
            "    return ret;",
            "}",
            "} // namespace Geometry",
            "",
            "using namespace Geometry;"
        ],
        "description": "插入 计算几何大板子"
    },
    "区间第k小": {
        "prefix": "acm-2.8seg",
        "body": [
            "#pragma GCC optimize(\"O3,unroll-loops\")",
            "#include <iostream>",
            "#include <vector>",
            "#include <algorithm>",
            "using namespace std;",
            "const int N = 2e5 + 5; ",
            "int n, m, cnt, root[N], a[N];",
            "int ls[N << 5], rs[N << 5], w[N << 5];",
            "vector<int> b;",
            "int update(int lu, int l, int r, int x) {",
            "    int u = ++cnt;",
            "    ls[u] = ls[lu]; rs[u] = rs[lu]; w[u] = w[lu] + 1;",
            "    if (l == r) return u;",
            "    int mid = (l + r) >> 1;",
            "    if (x <= mid) ls[u] = update(ls[lu], l, mid, x);",
            "    else rs[u] = update(rs[lu], mid + 1, r, x);",
            "    return u;",
            "}",
            "// 核心变化：前缀和相减，二分找第 K 小",
            "int query(int u1, int u2, int l, int r, int k) {",
            "    if (l == r) return l;",
            "    int d = w[ls[u2]] - w[ls[u1]]; ",
            "    int mid = (l + r) >> 1;",
            "    if (k <= d) return query(ls[u1], ls[u2], l, mid, k); ",
            "    else return query(rs[u1], rs[u2], mid + 1, r, k - d); ",
            "}",
            "void solve() {",
            "    cin >> n >> m;",
            "    for (int i = 1; i <= n; i++) {",
            "        cin >> a[i];",
            "        b.push_back(a[i]);",
            "    }",
            "    sort(b.begin(), b.end());",
            "    b.erase(unique(b.begin(), b.end()), b.end());",
            "    int max_val = b.size();",
            "    for (int i = 1; i <= n; i++) {",
            "        int x = lower_bound(b.begin(), b.end(), a[i]) - b.begin() + 1;",
            "        root[i] = update(root[i - 1], 1, max_val, x);",
            "    }",
            "    ",
            "    while (m--) {",
            "        int l, r, k;",
            "        cin >> l >> r >> k;",
            "        int ans_rk = query(root[l - 1], root[r], 1, max_val, k);",
            "        cout << b[ans_rk - 1] << '\\n'; ",
            "    }",
            "}",
            "",
            "int main() {",
            "    ios::sync_with_stdio(false);",
            "    cin.tie(0), cout.tie(0);",
            "    solve();",
            "    return 0;",
            "}"
        ],
        "description": "插入 区间第k小"
    },
    "区间元素数": {
        "prefix": "acm-2.8seg",
        "body": [
            "#include<iostream>",
            "#include<stack>",
            "#include<string>",
            "#include<set>",
            "#include<algorithm>",
            "#include<queue>",
            "#include<map>",
            "#include<vector>",
            "#include<cmath>",
            "using namespace std;",
            "//#define int long long",
            "const int N=1e6+5;",
            "int n,m,cnt,root[N],last[N];",
            "int ls[N<<5],rs[N<<5],w[N<<5];",
            "int update(int lu,int l,int r,int x){",
            "\tint u=++cnt;",
            "\tls[u]=ls[lu],rs[u]=rs[lu],w[u]=w[lu];w[u]++;",
            "\tif(l==r)return u;",
            "\tint mid=(l+r)>>1;",
            "\tif(x<=mid)ls[u]=update(ls[lu],l,mid,x);",
            "\telse rs[u]=update(rs[lu],mid+1,r,x);",
            "\treturn u;",
            "}",
            "int query(int u1,int u2,int l,int r,int x){",
            "\tif(l>=x)return 0;",
            "\tif(r<x)return w[u2]-w[u1];",
            "\tint mid=(l+r)>>1;",
            "\treturn query(ls[u1],ls[u2],l,mid,x)+query(rs[u1],rs[u2],mid+1,r,x);",
            "}",
            "void solve(){",
            "\tcin>>n;",
            "\tfor(int i=1;i<=n;i++){",
            "\t\tint x;",
            "\t\tcin>>x;",
            "\t\tif(last[x])root[i]=update(root[i-1],0,n,last[x]);",
            "\t\telse root[i]=update(root[i-1],0,n,0);\t",
            "\t\tlast[x]=i;\t",
            "\t}",
            "\tcin>>m;",
            "\twhile(m--){",
            "\t\tint l,r;",
            "\t\tcin>>l>>r;",
            "\t\tcout<<query(root[l-1],root[r],0,n,l)<<'\\n';",
            "\t}",
            "}",
            "signed main()",
            "{",
            "    ios::sync_with_stdio(false);",
            "    cin.tie(0),cout.tie(0);",
            "    int T=1;",
            "    while(T--)solve();",
            "}",
            "/*",
            "*/"
        ],
        "description": "插入 区间元素数"
    },
    "区间MEX": {
        "prefix": "acm-2.8seg",
        "body": [
            "#pragma GCC optimize(\"O3,unroll-loops\")",
            "#include <iostream>",
            "using namespace std;",
            "const int N = 2e5 + 5; ",
            "int n, q, cnt, root[N];",
            "int ls[N * 40], rs[N * 40], min_pos[N * 40]; ",
            "int update(int pre, int l, int r, int x, int pos) {",
            "    int u = ++cnt;",
            "    ls[u] = ls[pre]; rs[u] = rs[pre]; ",
            "    if (l == r) {",
            "        min_pos[u] = pos;",
            "        return u;",
            "    }",
            "    int mid = (l + r) >> 1;",
            "    if (x <= mid) ls[u] = update(ls[pre], l, mid, x, pos);",
            "    else rs[u] = update(rs[pre], mid + 1, r, x, pos);",
            "    min_pos[u] = min(min_pos[ls[u]], min_pos[rs[u]]);",
            "    return u;",
            "}",
            "int query(int u, int l, int r, int limit_L) {",
            "    if (l == r) return l;",
            "    int mid = (l + r) >> 1;",
            "    if (min_pos[ls[u]] < limit_L) return query(ls[u], l, mid, limit_L);",
            "    else return query(rs[u], mid + 1, r, limit_L);",
            "}",
            "void solve() {",
            "    cin >> n >> q;",
            "    for (int i = 1, x; i <= n; ++i) {",
            "        cin >> x;",
            "        if (x > n + 1) {",
            "            root[i] = root[i - 1];",
            "        } else {",
            "            root[i] = update(root[i - 1], 0, n + 1, x, i);",
            "        }",
            "    }",
            "    while (q--) {",
            "        int l, r;",
            "        cin >> l >> r;",
            "        cout << query(root[r], 0, n + 1, l) << '\\n';",
            "    }",
            "}",
            "int main() {",
            "    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);",
            "    solve();",
            "    return 0;",
            "}"
        ],
        "description": "插入 区间MEX"
    },
    "前缀基": {
        "prefix": "acm-7.6b",
        "body": [
            "#include <iostream>",
            "#include <vector>",
            "",
            "using ll = long long;",
            "using namespace std;",
            "const int MOD = 998244353;",
            "",
            "ll qpow(ll a, ll b) {",
            "    ll res = 1;",
            "    a %= MOD;",
            "    while (b) {",
            "        if (b & 1) res = res * a % MOD;",
            "        a = a * a % MOD;",
            "        b >>= 1;",
            "    }",
            "    return res;",
            "}",
            "",
            "/**",
            " * 线性批量求逆元 (前缀积法)",
            " * 传入需要求逆元的数组 a (1-indexed)，将结果存入 inv_a (1-indexed)",
            " * 时间复杂度: O(n + log(MOD))",
            " */",
            "void linear_inv(const std::vector<ll>& a, std::vector<ll>& inv_a) {",
            "    int n = a.size() - 1;",
            "    if (n <= 0) return;",
            "    std::vector<ll> pre(n + 1, 1), inv_pre(n + 1, 1);",
            "    for (int i = 1; i <= n; i++) {",
            "        pre[i] = pre[i - 1] * a[i] % MOD;",
            "    }",
            "    inv_pre[n] = qpow(pre[n], MOD - 2);",
            "    for (int i = n; i >= 1; i--) {",
            "        inv_pre[i - 1] = inv_pre[i] * a[i] % MOD;",
            "    }",
            "    for (int i = 1; i <= n; i++) {",
            "        inv_a[i] = inv_pre[i] * pre[i - 1] % MOD;",
            "    }",
            "}"
        ],
        "description": "插入 前缀基"
    },
    "矩阵快速幂": {
        "prefix": "acm-7.5结构体",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=103,P=1e9+7;",
            "LL n,K;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Matrix{",
            "\tLL a[N][N];",
            "\tMatrix(){memset(a,0,sizeof(a));}",
            "\tinline void read(){",
            "\t\tfor(Re i=1;i<=n;++i)",
            "    \t\tfor(Re j=1;j<=n;++j)\t",
            "    \t\t\tin(a[i][j]);",
            "\t}",
            "\tinline void print(){",
            "\t\tfor(Re i=1;i<=n;puts(\"\"),++i)",
            "    \t\tfor(Re j=1;j<=n;++j)\t",
            "    \t\t\tprintf(\"%lld \",a[i][j]);",
            "\t}",
            "\tinline Matrix operator*(const Matrix &O)const{",
            "\t\tMatrix ans;",
            "\t\tfor(Re i=1;i<=n;++i)",
            "\t\t\tfor(Re j=1;j<=n;++j)",
            "\t\t\t\tfor(Re k=1;k<=n;++k)",
            "\t\t\t\t\t(ans.a[i][j]+=a[i][k]*O.a[k][j]%P)%=P;",
            "\t\treturn ans;",
            "\t}",
            "\tinline Matrix operator*=(Matrix &O){return *this=*this*O;}",
            "}A;",
            "inline Matrix mi(Matrix x,Re k){",
            "\tif(!k)return x;--k;",
            "\tMatrix s=x;",
            "\twhile(k){",
            "\t\tif(k&1)s*=x;",
            "\t\tx*=x,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "int main(){",
            "\tin(n),in(K),A.read(),mi(A,K).print();",
            "}",
            ""
        ],
        "description": "插入 矩阵快速幂"
    },
    "sg函数": {
        "prefix": "acm-7.3sg",
        "body": [
            "#include <bits/stdc++.h>",
            "using namespace std;",
            "",
            "const int N = 1e5 + 5;",
            "int sg[N], f[105], k; // f存允许的步数(需升序), k是步数种类",
            "int vis[N];",
            "",
            "void get_sg(int n) {",
            "\tfor (int i = 1; i <= n; i++) {",
            "\t\t// vis时间戳黑科技：严格O(1)标记，绝对不写 memset",
            "\t\tfor (int j = 1; j <= k && f[j] <= i; j++) {",
            "\t\t\tvis[sg[i - f[j]]] = i;",
            "\t\t}",
            "\t\t// 求 mex",
            "\t\tfor (int j = 0; ; j++) {",
            "\t\t\tif (vis[j] != i) {",
            "\t\t\t\tsg[i] = j;",
            "\t\t\t\tbreak;",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "}",
            "int main() {",
            "\t// 1. 初始化规则数组 (必须升序!)",
            "\tk = 3;",
            "\tf[1] = 1; ",
            "\tf[2] = 3; ",
            "\tf[3] = 4;",
            "\t// sort(f + 1, f + 1 + k); // 如果题目给的规则没排序，一定要加上这句！",
            "\t",
            "\t// 2. 预处理 SG 函数",
            "\t// 假设题目告诉你，单堆石子最多 10000 个",
            "\tget_sg(10000); ",
            "\t",
            "\t// 3. 处理多堆石子的异或和",
            "\tint m;",
            "\tcin >> m; // m 堆石子",
            "\t",
            "\tint ans = 0;",
            "\tfor (int i = 1; i <= m; i++) {",
            "\t\tint a;",
            "\t\tcin >> a; // 读入这一堆有 a 个石子",
            "\t\t",
            "\t\t// 核心：把这一堆的 sg 值异或进去",
            "\t\tans ^= sg[a]; ",
            "\t}",
            "\t",
            "\t// 4. 审判时刻",
            "\tif (ans != 0) {",
            "\t\tcout << \"先手必胜！\" << endl;",
            "\t} else {",
            "\t\tcout << \"后手必胜！\" << endl;",
            "\t}",
            "\t",
            "\treturn 0;",
            "}"
        ],
        "description": "插入 sg函数"
    },
    "极角排序": {
        "prefix": "acm-8.2sort",
        "body": [
            "#include <bits/stdc++.h>",
            "using namespace std;",
            "struct Point {",
            "\tlong long x, y;",
            "\t",
            "\t// 1. 象限划分 / 半平面划分",
            "\t// 规定极角从 x 轴正半轴开始，逆时针方向为正。",
            "\t// 我们将平面分为上下两个半区：",
            "\t// 上半区 (包含正 x 轴)：y > 0，或者 y == 0 且 x > 0 (返回 0)",
            "\t// 下半区 (包含负 x 轴)：y < 0，或者 y == 0 且 x < 0 (返回 1)",
            "\t// 原点 (0,0) 通常特殊处理或不参与极角排序，这里默认归为上半区",
            "\tint half() const {",
            "\t\tif (y > 0 || (y == 0 && x > 0)) return 0;",
            "\t\treturn 1;",
            "\t}",
            "};",
            "",
            "// 几何意义：以 OA 和 OB 为邻边的平行四边形的有向面积",
            "// 如果结果 > 0，说明从 OA 到 OB 是逆时针方向 (A 的极角小于 B 的极角)",
            "// 如果结果 < 0，说明是顺时针方向",
            "// 如果结果 == 0，说明 A, O, B 三点共线",
            "long long cross(Point a, Point b) {",
            "\treturn a.x * b.y - a.y * b.x;",
            "}",
            "",
            "// 3. 距离平方 (用于共线时的副关键字排序)",
            "long long dist2(Point a) {",
            "\treturn a.x * a.x + a.y * a.y;",
            "}",
            "",
            "// 4. 终极极角排序比较函数 (逆时针排列)",
            "bool polar_cmp(Point a, Point b) {",
            "\t// 步骤一：如果两个点在不同的半区，上半区的点一定排在前面",
            "\tif (a.half() != b.half()) {",
            "\t\treturn a.half() < b.half();",
            "\t}",
            "\t",
            "\tlong long cp = cross(a, b);",
            "\tif (cp != 0) {",
            "\t\t// cp > 0 表示 a 在 b 的顺时针方向（即 a 的角度更小）",
            "\t\treturn cp > 0; ",
            "\t}",
            "\t",
            "\t// 步骤三：如果极角完全相同 (共线)，通常把距离原点更近的点排在前面",
            "\treturn dist2(a) < dist2(b);",
            "}",
            "",
            "// ==========================================",
            "// 5. 实战用法示例",
            "// ==========================================",
            "void polar_sort_example() {",
            "\tvector<Point> pts = {",
            "{-2, -2}, {1, 1}, {-1, 1}, {2, 0}, {0, 2}, {1, -1}",
            "};",
            "\t",
            "\t// 假设以原点 (0,0) 为基准点进行极角排序",
            "\t// 如果基准点是其他的点 P，只需要把所有的点先减去 P (平移坐标系) 再排序即可",
            "\tsort(pts.begin(), pts.end(), polar_cmp);",
            "\t",
            "\t// 排序后的 pts 顺序将是严格的逆时针一圈",
            "}"
        ],
        "description": "插入 极角排序"
    },
    "求凸包面积": {
        "prefix": "acm-8.1tubao",
        "body": [
            "// 传入多边形的顶点数组 p（不要求首尾点重合，只要是顺时针或逆时针按顺序排列即可）",
            "// 返回多边形的面积",
            "double polygon_area(const vector<Point>& p) {",
            "    int n = p.size();",
            "    if (n < 3) return 0.0; ",
            "    double sum = 0;",
            "    for (int i = 0; i < n; i++) {",
            "        sum += cross(p[i], p[(i + 1) % n]); ",
            "    }",
            "    return abs(sum) / 2.0; ",
            "}"
        ],
        "description": "插入 求凸包面积"
    },
    "求凸包直径（旋转卡壳）": {
        "prefix": "acm-8.3tubao",
        "body": [
            "#include <bits/stdc++.h>",
            "#include <ext/pb_ds/assoc_container.hpp> // 包含所有容器（哈希表、树、堆）",
            "#include <ext/pb_ds/tree_policy.hpp>     // 包含树的相关策略（用于实现平衡树）",
            "#include <ext/pb_ds/hash_policy.hpp>     // 包含哈希表的相关策略",
            "//#include <ext/pb_ds/priority_queue.hpp>  // 包含优先级队列（堆）",
            "using namespace std;",
            "using namespace __gnu_pbds;",
            "using ll = long long;",
            "template <typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;",
            "#define up(i, a, b) for (int i = (a); i <= (b); ++i)",
            "#define down(i, a, b) for (int i = (a); i >= (b); --i)",
            "#define sm int,vector<int>,greater<int>",
            "#define int long long",
            "mt19937_64 gen(12345);",
            "const int N=1e6+5,mod=998244353,inf=1e9+7;;",
            "int n,m,q,k;",
            "int a[N],b[N],c[N],d[N];",
            "int gcd(int x,int y)",
            "{",
            "\tif(y==0)return x;",
            "\treturn gcd(y,x%y);",
            "}",
            "int ksm(int a,int n,int p)",
            "{",
            "\tif(n<0)return 0;",
            "\tint res=1;",
            "\twhile(n)",
            "\t{",
            "\t\tif(n&1)res=res*a%p;",
            "\t\tn>>=1;",
            "\t\ta=a*a%p;",
            "\t}",
            "\treturn res;",
            "}",
            "const double eps = 1e-9;",
            "int sgn(double x) {",
            "\tif (abs(x) < eps) return 0;",
            "\treturn x < 0 ? -1 : 1;",
            "}",
            "struct Point {",
            "\tdouble x, y;",
            "\tPoint(double _x = 0, double _y = 0) : x(_x), y(_y) {}",
            "\t",
            "\tPoint operator - (const Point& b) const {",
            "\t\treturn Point(x - b.x, y - b.y);",
            "\t}",
            "\t",
            "\t//优先按 x 排序，x 相同按 y 排序",
            "\tbool operator < (const Point& b) const {",
            "\t\tif (sgn(x - b.x) == 0) return sgn(y - b.y) < 0;",
            "\t\treturn sgn(x - b.x) < 0;",
            "\t}",
            "\t",
            "\t// 判等（用于去重）",
            "\tbool operator == (const Point& b) const {",
            "\t\treturn sgn(x - b.x) == 0 && sgn(y - b.y) == 0;",
            "\t}",
            "};",
            "",
            "double cross(const Point& a, const Point& b) {",
            "\treturn a.x * b.y - a.y * b.x;",
            "}",
            "",
            "// 返回值 > 0：p2 在 p0->p1 的左侧（向左转）",
            "// 返回值 < 0：p2 在 p0->p1 的右侧（向右转）",
            "// 返回值 == 0：三点共线",
            "double cross(const Point& p0, const Point& p1, const Point& p2) {",
            "\treturn cross(p1 - p0, p2 - p0);",
            "}",
            "",
            "int dist(const Point& p0, const Point& p1){",
            "\treturn (p0.x-p1.x)*(p0.x-p1.x)+(p0.y-p1.y)*(p0.y-p1.y);",
            "}",
            "// 输入点集 P，返回凸包上的点集（逆时针顺序，起点和终点不重合）",
            "vector<Point> convex_hull(vector<Point>& P) {",
            "\tint n = P.size();",
            "\tif (n <= 2) return P; // 退化情况：点数小于等于2，本身就是凸包",
            "\t",
            "\t// 1. 排序并去重",
            "\tsort(P.begin(), P.end());",
            "\tP.erase(unique(P.begin(), P.end()), P.end());",
            "\tn = P.size();",
            "\tif (n <= 2) return P;",
            "\t",
            "\tvector<Point> hull(2 * n); // 用数组模拟栈，速度最快",
            "\tint top = 0;               // 栈顶指针，表示栈内元素个数",
            "\t",
            "\t// 2. 求下凸壳",
            "\tfor (int i = 0; i < n; i++) {",
            "\t\t// 【核心判断】：如果向右转或共线，则弹栈",
            "\t\t// 注意：如果你需要保留凸包边上的共线点，把 <= 改成 < 即可",
            "\t\twhile (top >= 2 && sgn(cross(hull[top - 2], hull[top - 1], P[i])) <= 0) {",
            "\t\t\ttop--;",
            "\t\t}",
            "\t\thull[top++] = P[i];",
            "\t}",
            "\t",
            "\t// 3. 求上凸壳",
            "\tint tmp = top; // 记录下凸壳的元素个数，上凸壳弹栈时不能破坏下凸壳",
            "\tfor (int i = n - 2; i >= 0; i--) {",
            "\t\twhile (top > tmp && sgn(cross(hull[top - 2], hull[top - 1], P[i])) <= 0) {",
            "\t\t\ttop--;",
            "\t\t}",
            "\t\thull[top++] = P[i];",
            "\t}",
            "\t",
            "\tif (n > 1) top--;",
            "\thull.resize(top);",
            "\treturn hull;",
            "}",
            "int hull_diam(vector<Point>& hull){",
            "\tint j=2;",
            "\tint ans=0,H=hull.size();",
            "\tif (H == 2) {",
            "        return dist(hull[0], hull[1]) ;",
            "    }",
            "    if (H <= 1) {",
            "        return 0;",
            "    }",
            "\tup(i,0,H-1){",
            "\t\tint next_i=(i+1)%H;",
            "\t\twhile(cross(hull[i],hull[next_i],hull[j])<=cross(hull[i],hull[next_i],hull[(j+1)%H])){",
            "\t\t\tj=(j+1)%H;",
            "\t\t}",
            "\t\tans=max(ans,dist(hull[i],hull[j]));",
            "\t\tans=max(ans,dist(hull[next_i],hull[j]));",
            "\t}",
            "\treturn ans;   ",
            "}",
            "void solve(){",
            "\tcin>>n;",
            "\tvector<Point>pts(n);",
            "\tup(i,0,n-1)cin>>pts[i].x>>pts[i].y;",
            "\tvector<Point>hull=convex_hull(pts);",
            "\tcout<<hull_diam(hull);",
            "}",
            "",
            "signed main() ",
            "{",
            "\tios::sync_with_stdio(0);",
            "\tcin.tie(0), cout.tie(0);",
            "\tint t = 1;",
            "\t// cin >> t;",
            "\twhile (t--){",
            "\t\tsolve();",
            "\t}",
            "//\tsystem(\"x-www-browser https://ys.mihoyo.com/\");",
            "//\tcout << fixed << setprecision(10) << x << '\\n';",
            "\treturn 0;",
            "}",
            "/*",
            "1",
            "38133 49107",
            "",
            "2 27269",
            "",
            "",
            "*/"
        ],
        "description": "插入 求凸包直径（旋转卡壳）"
    },
    "凸包（单调链法）": {
        "prefix": "acm-8.1tubao",
        "body": [
            "#pragma GCC optimize(\"O2\")",
            "#pragma GCC optimize(\"O3\")",
            "#pragma GCC optimize(\"Ofast\")",
            "#pragma GCC optimize(\"unroll-loops\")",
            "#include <bits/stdc++.h>",
            "using namespace std;",
            "using ll = long long;",
            "#define up(i, a, b) for (int i = (a); i <= (b); ++i)",
            "#define down(i, a, b) for (int i = (a); i >= (b); --i)",
            "#define sm int,vector<int>,greater<int>",
            "#define int long long",
            "mt19937_64 gen(12345);",
            "const int N=1e6+5,mod=998244353,inf=1e9+7;;",
            "int n,m,q,k;",
            "int a[N],b[N],c[N],d[N];",
            "int gcd(int x,int y)",
            "{",
            "\tif(y==0)return x;",
            "\treturn gcd(y,x%y);",
            "}",
            "int ksm(int a,int n,int p)",
            "{",
            "\tif(n<0)return 0;",
            "\tint res=1;",
            "\twhile(n)",
            "\t{",
            "\t\tif(n&1)res=res*a%p;",
            "\t\tn>>=1;",
            "\t\ta=a*a%p;",
            "\t}",
            "\treturn res;",
            "}",
            "const double eps = 1e-9;",
            "int sgn(double x) {",
            "\tif (abs(x) < eps) return 0;",
            "\treturn x < 0 ? -1 : 1;",
            "}",
            "struct Point {",
            "\tdouble x, y;",
            "\tPoint(double _x = 0, double _y = 0) : x(_x), y(_y) {}",
            "\t",
            "\tPoint operator - (const Point& b) const {",
            "\t\treturn Point(x - b.x, y - b.y);",
            "\t}",
            "\t",
            "\t//优先按 x 排序，x 相同按 y 排序",
            "\tbool operator < (const Point& b) const {",
            "\t\tif (sgn(x - b.x) == 0) return sgn(y - b.y) < 0;",
            "\t\treturn sgn(x - b.x) < 0;",
            "\t}",
            "\t",
            "\t// 判等（用于去重）",
            "\tbool operator == (const Point& b) const {",
            "\t\treturn sgn(x - b.x) == 0 && sgn(y - b.y) == 0;",
            "\t}",
            "};",
            "",
            "double cross(const Point& a, const Point& b) {",
            "\treturn a.x * b.y - a.y * b.x;",
            "}",
            "",
            "// 返回值 > 0：p2 在 p0->p1 的左侧（向左转）",
            "// 返回值 < 0：p2 在 p0->p1 的右侧（向右转）",
            "// 返回值 == 0：三点共线",
            "double cross(const Point& p0, const Point& p1, const Point& p2) {",
            "\treturn cross(p1 - p0, p2 - p0);",
            "}",
            "",
            "// 输入点集 P，返回凸包上的点集（逆时针顺序，起点和终点不重合）",
            "vector<Point> convex_hull(vector<Point>& P) {",
            "\tint n = P.size();",
            "\tif (n <= 2) return P; // 退化情况：点数小于等于2，本身就是凸包",
            "\t",
            "\t// 1. 排序并去重",
            "\tsort(P.begin(), P.end());",
            "\tP.erase(unique(P.begin(), P.end()), P.end());",
            "\tn = P.size();",
            "\tif (n <= 2) return P;",
            "\t",
            "\tvector<Point> hull(2 * n); // 用数组模拟栈，速度最快",
            "\tint top = 0;               // 栈顶指针，表示栈内元素个数",
            "\t",
            "\t// 2. 求下凸壳",
            "\tfor (int i = 0; i < n; i++) {",
            "\t\t// 【核心判断】：如果向右转或共线，则弹栈",
            "\t\t// 注意：如果你需要保留凸包边上的共线点，把 <= 改成 < 即可",
            "\t\twhile (top >= 2 && sgn(cross(hull[top - 2], hull[top - 1], P[i])) <= 0) {",
            "\t\t\ttop--;",
            "\t\t}",
            "\t\thull[top++] = P[i];",
            "\t}",
            "\t",
            "\t// 3. 求上凸壳",
            "\tint tmp = top; // 记录下凸壳的元素个数，上凸壳弹栈时不能破坏下凸壳",
            "\tfor (int i = n - 2; i >= 0; i--) {",
            "\t\twhile (top > tmp && sgn(cross(hull[top - 2], hull[top - 1], P[i])) <= 0) {",
            "\t\t\ttop--;",
            "\t\t}",
            "\t\thull[top++] = P[i];",
            "\t}",
            "\t",
            "\t// 4. 收尾：最后加入的起点与栈底的起点重合，需减去",
            "\tif (n > 1) top--;",
            "\thull.resize(top); // 截断有效部分",
            "\treturn hull;",
            "}",
            "",
            "void solve(){",
            "\tcin>>n;",
            "\tvector<Point>pts(n);",
            "\tup(i,0,n-1)",
            "\t\tcin>>pts[i].x>>pts[i].y;",
            "\tvector<Point>hull=convex_hull(pts);",
            "\tdouble ans=0;",
            "\tdouble tx=hull.back().x,ty=hull.back().y;",
            "\tfor(auto const &[x,y]:hull){",
            "\t\tans+=sqrt((x-tx)*(x-tx)+(y-ty)*(y-ty));",
            "\t\ttx=x;",
            "\t\tty=y;",
            "\t}",
            "\tcout << fixed << setprecision(2) << ans << '\\n';",
            "}",
            "signed main()",
            "{",
            "\tios::sync_with_stdio(0);",
            "\tcin.tie(0), cout.tie(0);",
            "\tint t = 1;",
            "//\tcin >> t;",
            "\twhile (t--){",
            "\t\tsolve();",
            "\t}",
            "//\tsystem(\"x-www-browser https://ys.mihoyo.com/\");",
            "//\tcout << fixed << setprecision(10) << x << '\\n';",
            "\treturn 0;",
            "}"
        ],
        "description": "插入 凸包（单调链法）"
    },
    "二进制优化多重背包": {
        "prefix": "acm-5.1宝物筛选",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=103,M=4e4+3;",
            "int n,m,x,y,z,V,ans,v[N*17],w[N*17],dp[M];",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "int main(){",
            "\tin(m),in(V);",
            "\tmemset(dp,-127,sizeof(dp));",
            "\tdp[0]=0;",
            "\twhile(m--){",
            "\t\tin(x),in(y),in(z);Re p=1;",
            "\t\twhile(z>=p)v[++n]=y*p,w[n]=x*p,z-=p,p<<=1;",
            "\t\tif(z)v[++n]=y*z,w[n]=x*z;",
            "\t}",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=V;j>=v[i];--j)\t",
            "\t\t\tdp[j]=max(dp[j],dp[j-v[i]]+w[i]);",
            "\tfor(Re i=0;i<=V;++i)ans=max(ans,dp[i]);",
            "\tprintf(\"%d\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 二进制优化多重背包"
    },
    "单调队列优化多重背包": {
        "prefix": "acm-5.1CodeVS 5429",
        "body": [
            "#include<cstdio>",
            "#define Re register int",
            "const int N=7003,M=7003;",
            "int n,h,t,V,mp,tmp,v[N],w[N],c[N],Q[N],K[N],dp[M];",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "inline int max(Re a,Re b){return a>b?a:b;}",
            "inline int min(Re a,Re b){return a<b?a:b;}",
            "int main(){",
            "    in(n),in(V);",
            "    for(Re i=1;i<=n;++i)in(v[i]),in(w[i]),in(c[i]);",
            "    for(Re i=1;i<=n;++i)",
            "    \tfor(Re r=0;r<v[i];++r){",
            "    \t\th=1,t=0,mp=(V-r)/v[i];",
            "    \t\tfor(Re p=0;p<=mp;++p){",
            "    \t\t\ttmp=dp[p*v[i]+r]-w[i]*p;",
            "    \t\t\twhile(h<=t&&Q[t]<=tmp)--t;",
            "    \t\t\tQ[++t]=tmp,K[t]=p;",
            "    \t\t\twhile(h<=t&&p-K[h]>min(c[i],V/v[i]))++h;",
            "    \t\t\tdp[p*v[i]+r]=max(dp[p*v[i]+r],Q[h]+p*w[i]);",
            "\t\t\t}",
            "\t\t}",
            "    printf(\"%d\",dp[V]);",
            "}",
            ""
        ],
        "description": "插入 单调队列优化多重背包"
    },
    "最长公共子序列": {
        "prefix": "acm-5.1二分",
        "body": [
            "// luogu-judger-enable-o2",
            "#include<bits/stdc++.h>",
            "using namespace std;",
            "int pan[100010],b[100010],f[100010],n,i,a,len=1,l,r,mid;",
            "inline int in(){",
            "    int x=0,fh=1;char c=getchar();",
            "    while(c<'0'||c>'9')c=getchar();",
            "    while(c>='0'&&c<='9')x=x*10+c-'0',c=getchar();",
            "    return x*fh;",
            "}",
            "int main(){",
            "    n=in();",
            "    for(i=1;i<=n;i++)a=in(),pan[a]=i,f[i]=0xfffffff;",
            "    for(i=1;i<=n;i++)a=in(),b[i]=pan[a];",
            "    for(i=1;i<=n;i++)printf(\"%d \",b[i]);puts(\"\");",
            "    f[1]=b[1];",
            "    for(i=2;i<=n;i++){",
            "    \tl=0;r=len;",
            "    \tif(b[i]>f[len])f[++len]=b[i];",
            "    \telse{",
            "    \t\twhile(l<r){",
            "    \t\t\tmid=(l+r)/2;",
            "    \t\t\tif(f[mid]<b[i])l=mid+1;",
            "    \t\t\telse r=mid;",
            "    \t\t}",
            "    \t\tf[l]=min(b[i],f[l]);",
            "    \t}",
            "    }",
            "    for(i=1;i<=n;i++)printf(\"%d \",f[i]);puts(\"\");",
            "    printf(\"%d\",len);",
            "    return 0;",
            "}",
            ""
        ],
        "description": "插入 最长公共子序列"
    },
    "基站选址": {
        "prefix": "acm-5.1线段树优化",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<vector>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const LL N=2e4+3,inf=1e18;",
            "int n,K,L[N],R[N],D[N],C[N],W[N],S[N];LL ans=inf,dp[N];vector<int>V[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline LL calc(Re j,Re i){",
            "\tLL ans=0;",
            "\tfor(Re k=j+1;k<i;++k)if(L[k]>j&&R[k]<i)ans+=W[k];",
            "\treturn ans;",
            "}",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tLL tr[N<<2],add[N<<2];",
            "\tinline void updata(Re p,LL v){tr[p]+=v,add[p]+=v;}",
            "\tinline void pushdown(Re p){",
            "\t\tif(add[p])updata(pl,add[p]),updata(pr,add[p]),add[p]=0;",
            "\t}",
            "\tinline void build(Re p,Re L,Re R){",
            "\t\tadd[p]=0;",
            "\t\tif(L==R){tr[p]=dp[L];return;}",
            "\t\tbuild(pl,L,mid),build(pr,mid+1,R);",
            "\t\ttr[p]=min(tr[pl],tr[pr]);",
            "\t}",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Re v){",
            "\t\tif(l<=L&&R<=r){updata(p,v);return;}",
            "\t\tpushdown(p);",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,v);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,v);",
            "\t\ttr[p]=min(tr[pl],tr[pr]);",
            "\t}",
            "\tinline void change(Re p,Re L,Re R,Re x,Re v){",
            "\t\tif(L==R){tr[p]+=v;return;}",
            "\t\tpushdown(p);",
            "\t\tif(x<=mid)change(pl,L,mid,x,v);",
            "\t\telse change(pr,mid+1,R,x,v);",
            "\t\ttr[p]=min(tr[pl],tr[pr]);",
            "\t}",
            "\tinline LL ask(Re p,Re L,Re R,Re l,Re r){",
            "\t\tif(l<=L&&R<=r)return tr[p];",
            "\t\tLL ans=inf;pushdown(p);",
            "\t\tif(l<=mid)ans=min(ans,ask(pl,L,mid,l,r));",
            "\t\tif(r>mid)ans=min(ans,ask(pr,mid+1,R,l,r));",
            "\t\treturn ans; ",
            "\t}",
            "\t#undef mid",
            "}TR;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(K);",
            "\tfor(Re i=2;i<=n;++i)in(D[i]);",
            "\tfor(Re i=1;i<=n;++i)in(C[i]);",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tin(S[i]);",
            "\t\tRe l=1,r=i;",
            "\t\twhile(l<r){",
            "\t\t\tRe mid=l+r>>1;",
            "\t\t\tif(D[mid]>=D[i]-S[i])r=mid;",
            "\t\t\telse l=mid+1;",
            "\t\t}",
            "\t\tL[i]=r;",
            "\t\tl=i,r=n;",
            "\t\twhile(l<r){",
            "\t\t\tRe mid=l+r+1>>1;",
            "\t\t\tif(D[mid]<=D[i]+S[i])l=mid;",
            "\t\t\telse r=mid-1;",
            "\t\t}",
            "\t\tR[i]=l,V[R[i]].push_back(i);",
            "\t}",
            "\tfor(Re i=1;i<=n;++i)in(W[i]);",
            "\tmemset(dp,20,sizeof(dp));",
            "\tdp[0]=0,D[0]=-1e9,C[n+1]=0;",
            "\tfor(Re k=1;k<=K;++k){",
            "\t\tTR.build(1,0,n);",
            "\t\tfor(Re i=1;i<=n+1;++i){",
            "\t\t\tLL tmp=dp[i];",
            "\t\t\tdp[i]=min(dp[i],TR.ask(1,0,n,0,i-1)+C[i]);",
            "\t\t\tfor(Re j=0,SZ=V[i].size();j<SZ;++j)TR.change(1,0,n,0,L[V[i][j]]-1,W[V[i][j]]);",
            "\t\t\tif(dp[i]!=tmp)TR.change(1,0,n,i,dp[i]-tmp);",
            "\t\t}",
            "\t\tans=min(ans,dp[n+1]);",
            "\t}",
            "\tprintf(\"%lld\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 基站选址"
    },
    "Yet Another Minimization Problem": {
        "prefix": "acm-5.1分治套莫队",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,M=23;",
            "int n,K,A[N];LL dp[M][N];",
            "inline void in(Re &x){",
            "\tint f=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=f?-x:x;",
            "}",
            "struct MODUI{",
            "\tint nowL,nowR,cnt[N];LL ans;",
            "\tinline LL calc(Re L,Re R){",
            "\t\twhile(nowR<R)++nowR,ans+=cnt[A[nowR]]++;",
            "\t\twhile(nowL>L)--nowL,ans+=cnt[A[nowL]]++;",
            "\t\twhile(nowR>R)ans-=--cnt[A[nowR]],--nowR;",
            "\t\twhile(nowL<L)ans-=--cnt[A[nowL]],++nowL;",
            "\t\treturn ans;",
            "\t}",
            "}TR;",
            "inline void sakura(Re l,Re r,Re L,Re R,Re k){",
            "\tif(l>r)return;Re mid=l+r>>1,w=0;LL tmp;",
            "\tfor(Re j=L;j<=R&&j<mid;++j)",
            "\t\tif((tmp=dp[k-1][j]+TR.calc(j+1,mid))<=dp[k][mid])",
            "\t\t\tdp[k][mid]=tmp,w=j;",
            "\tsakura(l,mid-1,L,w,k),sakura(mid+1,r,w,R,k);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(K);",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\tmemset(dp,19,sizeof(dp)),dp[0][0]=0;",
            "\tTR.nowL=1,TR.nowR=0;",
            "\tfor(Re k=1;k<=K;++k)sakura(k,n,k-1,n-1,k);",
            "\tprintf(\"%lld\\n\",dp[K][n]);",
            "}",
            ""
        ],
        "description": "插入 Yet Another Minimization Problem"
    },
    "[P5574]任务分配问题": {
        "prefix": "acm-5.1分治套莫队套树状数组",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=25003,M=27;",
            "int n,K,A[N];LL dp[M][N];",
            "inline void in(Re &x){",
            "\tint f=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=f?-x:x;",
            "}",
            "struct BIT{",
            "\tint nowL,nowR,C[N];LL ans;",
            "\tinline void add(Re x,Re v){if(!x)return;while(x<=n)C[x]+=v,x+=x&-x;}",
            "\tinline int ask(Re x){Re ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}",
            "\tinline LL calc(Re L,Re R){",
            "\t\twhile(nowR<R)++nowR,ans+=ask(A[nowR]-1),add(A[nowR],1);",
            "\t\twhile(nowL>L)--nowL,ans+=nowR-nowL-ask(A[nowL]),add(A[nowL],1);",
            "\t\twhile(nowR>R)add(A[nowR],-1),ans-=ask(A[nowR]-1),--nowR;",
            "\t\twhile(nowL<L)add(A[nowL],-1),ans-=nowR-nowL-ask(A[nowL]),++nowL;",
            "\t\treturn ans;",
            "\t}",
            "}TR;",
            "inline void sakura(Re l,Re r,Re L,Re R,Re k){",
            "\tif(l>r)return;Re mid=l+r>>1,w=0;LL tmp;",
            "\tfor(Re j=L;j<=R&&j<mid;++j)",
            "\t\tif((tmp=dp[k-1][j]+TR.calc(j+1,mid))<=dp[k][mid])",
            "\t\t\tdp[k][mid]=tmp,w=j;",
            "\tsakura(l,mid-1,L,w,k),sakura(mid+1,r,w,R,k);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(K);",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\tmemset(dp,19,sizeof(dp)),dp[0][0]=0;",
            "\tTR.nowL=1,TR.nowR=0;",
            "\tfor(Re k=1;k<=K;++k)sakura(k,n,k-1,n-1,k);",
            "\tprintf(\"%lld\\n\",dp[K][n]);",
            "}",
            ""
        ],
        "description": "插入 [P5574]任务分配问题"
    },
    "Lightning Conductor": {
        "prefix": "acm-5.1分治",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e5+3;",
            "int i,j,n,h,t,a[N],Q[N],Poi[N];",
            "double tmp,p[N],sqr[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void sakura(Re l,Re r,Re L,Re R){",
            "\tif(l>r)return;",
            "\tRe mid=l+r>>1,j0;double mx=0;",
            "\tfor(Re j=L;j<=mid&&j<=R;++j)",
            "\t\tif((tmp=a[j]+sqr[mid-j])>mx)mx=tmp,j0=j;",
            "\tp[mid]=max(p[mid],mx);",
            "\tsakura(l,mid-1,L,j0),sakura(mid+1,r,j0,R);",
            "}",
            "int main(){",
            "    in(n);",
            "    for(Re i=1;i<=n;++i)in(a[i]),sqr[i]=sqrt(i);",
            "    sakura(1,n,1,n);",
            "    for(Re i=1;i<n-i+1;++i)swap(a[i],a[n-i+1]),swap(p[i],p[n-i+1]);",
            "    sakura(1,n,1,n);",
            "    for(Re i=n;i;--i)printf(\"%d\\n\",(int)ceil(p[i])-a[i]);",
            "}",
            ""
        ],
        "description": "插入 Lightning Conductor"
    },
    "Cats Transport": {
        "prefix": "acm-5.1min",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=1e5+5;",
            "LL p,n,m,P,w,h,t,H[N],T[N],Q[N],S[N],dp[105][N];",
            "inline LL min(Re a,Re b){return a<b?a:b;}",
            "//                         i",
            "//                         k=j+1",
            "//dp[p][i]=dp[p-1][j]+(i-j)*T[i]-(S[i]-S[j])",
            "//(T[i]) * j + (dp[p][i]-i*T[i]+S[i]) = (dp[p-1][j]+S[j])",
            "//  k    * x +            b           =        y",
            "inline LL X(Re j){return j;}",
            "inline LL Y(Re j){return dp[p-1][j]+S[j];}",
            "inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}",
            "int main(){",
            "\tmemset(dp,0x3f,sizeof(dp));dp[0][0]=0;",
            "    scanf(\"%lld%lld%lld\",&n,&m,&P);",
            "    for(Re i=2;i<=n;H[i]+=H[i-1],++i)scanf(\"%lld\",&H[i]);",
            "    for(Re i=1;i<=m;T[i]=t-H[w],++i)scanf(\"%lld%lld\",&w,&t);",
            "    std::sort(T+1,T+m+1);",
            "    for(Re i=1;i<=m;++i)S[i]=S[i-1]+T[i];",
            "    for(p=1;p<=P;++p){",
            "    \th=1,t=0,Q[++t]=0,dp[p][0]=0;",
            "\t    for(Re i=1;i<=m;++i){",
            "\t        while(h<t&&slope(Q[h],Q[h+1])<=T[i])++h;",
            "\t        dp[p][i]=min(dp[p-1][i],dp[p-1][j=Q[h]]+(i-j)*T[i]-S[i]+S[j]);",
            "\t        if(Y(i)>=0x3f3f3f3f3f3f3f3fll)continue;",
            "\t\t\twhile(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i))--t;",
            "\t        Q[++t]=i;",
            "\t    }",
            "\t}",
            "    printf(\"%lld\",dp[P][m]); ",
            "}",
            ""
        ],
        "description": "插入 Cats Transport"
    },
    "CDQ 斜率优化  (k x均不单调)": {
        "prefix": "acm-5.1Building Bridges",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LD long double",
            "#define LL long long",
            "#define Re register int",
            "#define S2(a) (1ll*(a)*(a))",
            "using namespace std;",
            "const LL N=1e5+3,inf=1e18;",
            "int n,H[N],W[N],Q[N];LL S[N],dp[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "//dp[i]=min(dp[i],dp[j]+(H[i]-H[j])*(H[i]-H[j])+S[i-1]-S[j]);",
            "//dp[i]=dp[j]-2*H[i]*H[j]+H[j]*H[j]+H[i]*H[i]+S[i-1]-S[j]",
            "//(2*H[i]) * H[j] + (dp[i]-S[i-1]-H[i]*H[i]) = (dp[j]+H[j]*H[j]-S[j])",
            "//   k     *  x   +            b             =          y",
            "#define X(j) (a[j].x)",
            "#define Y(j) (a[j].y)",
            "struct QAQ{",
            "\tint k,x,id;LL y;",
            "\tinline bool operator<(const QAQ &O)const{return x!=O.x?x<O.x:y<O.y;}",
            "}a[N],b[N];",
            "inline bool cmp(QAQ A,QAQ B){return A.k<B.k;}",
            "inline LD slope(Re i,Re j){return X(i)==X(j)?(Y(j)>Y(i)?inf:-inf):(LD)(Y(j)-Y(i))/(X(j)-X(i));}",
            "inline void CDQ(Re L,Re R){",
            "\tif(L==R){Re j=a[L].id;a[L].y=dp[j]+(LL)H[j]*H[j]-S[j];return;}",
            "\tRe mid=L+R>>1,p1=L,p2=mid+1,h=1,t=0;",
            "\tfor(Re i=L;i<=R;++i)a[i].id<=mid?b[p1++]=a[i]:b[p2++]=a[i];",
            "\tfor(Re i=L;i<=R;++i)a[i]=b[i];",
            "\tCDQ(L,mid);",
            "\tfor(Re i=L;i<=mid;++i){",
            "\t\twhile(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i))--t;",
            "\t\tQ[++t]=i;",
            "\t}",
            "\tfor(Re i=mid+1,j,id;i<=R;++i){",
            "\t\twhile(h<t&&slope(Q[h],Q[h+1])<=a[i].k)++h;",
            "\t\tif(h<=t)id=a[i].id,j=Q[h],dp[id]=min(dp[id],a[j].y-(LL)a[i].k*a[j].x+S[id-1]+(LL)H[id]*H[id]);",
            "\t}",
            "\tCDQ(mid+1,R);",
            "\tRe w=L-1;p1=L,p2=mid+1;",
            "\twhile(p1<=mid&&p2<=R)b[++w]=a[p1]<a[p2]?a[p1++]:a[p2++];",
            "\twhile(p1<=mid)b[++w]=a[p1++];while(p2<=R)b[++w]=a[p2++];",
            "\tfor(Re i=L;i<=R;++i)a[i]=b[i];",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n);",
            "\tfor(Re i=1;i<=n;++i)in(H[i]);",
            "\tfor(Re i=1;i<=n;++i)in(W[i]);",
            "\tfor(Re i=1;i<=n;++i)S[i]=S[i-1]+W[i],dp[i]=inf;",
            "\tfor(Re i=1;i<=n;++i)a[i].k=(H[i]<<1),a[i].x=H[i],a[i].id=i;",
            "\tsort(a+1,a+n+1,cmp);",
            "\tdp[1]=0,CDQ(1,n);",
            "\tprintf(\"%lld\\n\",dp[n]);",
            "}",
            ""
        ],
        "description": "插入 CDQ 斜率优化  (k x均不单调)"
    },
    "二分 斜率优化   (x单调 k不单调)": {
        "prefix": "acm-5.1任务安排3",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=3e5+5;",
            "LL i,j,n,h=1,t=0,S,Q[N],ST[N],SF[N],dp[N];",
            "//dp[p][i]=min(dp[p-1][j]+(ST[i]+S*p)*(SF[i]-SF[j]));",
            "//dp[i]=dp[j]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]);",
            "//(S+ST[i]) * SF[j] + (dp[i]-ST[i]*SF[i]-S*SF[i]) = (dp[j])",
            "//    k     *   x   +              b              = y",
            "//ti� 均>0，且ST[i]是单调递增",
            "inline LL min(Re a,Re b){return a<b?a:b;}",
            "inline LL X(Re j){return SF[j];}",
            "inline LL Y(Re j){return dp[j];}",
            "inline long double slope(Re i,Re j){return X(j)==X(i)?(Y(j)>=Y(i)?1e18:-1e18):(long double)(Y(j)-Y(i))/(X(j)-X(i));}",
            "inline LL sakura(Re k){",
            "\tif(h==t)return Q[h];",
            "\tRe l=h,r=t;",
            "\twhile(l<r){",
            "\t\tRe mid=l+r>>1,i=Q[mid],j=Q[mid+1];",
            "\t\tif(slope(i,j)<k)l=mid+1;",
            "\t\telse r=mid;",
            "\t}",
            "\treturn Q[l];",
            "}",
            "int main(){",
            "    scanf(\"%lld%lld\",&n,&S);",
            "    for(i=1;i<=n;ST[i]+=ST[i-1],SF[i]+=SF[i-1],++i)scanf(\"%lld%lld\",&ST[i],&SF[i]);",
            "    Q[++t]=0;",
            "\tfor(i=1;i<=n;++i){",
            "\t\tj=sakura(S+ST[i]);",
            "        dp[i]=dp[j]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]);",
            "        while(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i))--t;",
            "        Q[++t]=i;",
            "\t}",
            "    printf(\"%lld\",dp[n]);",
            "}",
            ""
        ],
        "description": "插入 二分 斜率优化   (x单调 k不单调)"
    },
    "单调队列 斜率优化  (x k 均单调)": {
        "prefix": "acm-5.1玩具装箱 Toy",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=5e4+5;",
            "LL i,j,n,L,h=1,t=0,Q[N],S[N],dp[N];",
            "//dp[i]=S[i]^2-2*S[i]*L+dp[j]+(S[j]+L)^2-2S[i]*S[j]",
            "//(2*S[i]) * S[j] + (dp[i]-S[i]^2+2S[i]L)=(dp[j]+(S[j]+L)^2)",
            "//   k     *  x   +           b          =        y",
            "inline LL min(Re a,Re b){return a<b?a:b;}",
            "inline LL X(Re j){return S[j];}",
            "inline LL Y(Re j){return dp[j]+(S[j]+L)*(S[j]+L);}",
            "inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}",
            "int main(){",
            "    scanf(\"%lld%lld\",&n,&L);++L; ",
            "    for(i=1;i<=n;S[i]+=S[i-1]+1,++i)scanf(\"%lld\",&S[i]);",
            "    Q[++t]=0;",
            "    for(i=1;i<=n;++i){",
            "        while(h<t&&slope(Q[h],Q[h+1])<=2*S[i])++h;",
            "        dp[i]=dp[j=Q[h]]+(S[i]-S[j]-L)*(S[i]-S[j]-L);",
            "        while(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i))--t;",
            "        Q[++t]=i;",
            "    }",
            "    printf(\"%lld\",dp[n]);",
            "}",
            ""
        ],
        "description": "插入 单调队列 斜率优化  (x k 均单调)"
    },
    "仓库建设": {
        "prefix": "acm-5.1min",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=1e6+5;",
            "LL i,j,n,w,h=1,t=0,W[N],P[N],C[N],Q[N],SP[N],SC[N],dp[N];",
            "inline LL min(Re a,Re b){return a<b?a:b;}",
            "//dp[i]=dp[j]+Ci+Wi*(SP[i]-SP[j])-(SC[i]-SC[j])",
            "//(Wi) * SP[j] + (dp[i]+SC[i]-Wi*SP[i]) = (dp[j]+SC[j])",
            "// k   *   x   +           b            =       y",
            "inline LL X(Re j){return SP[j];}",
            "inline LL Y(Re j){return dp[j]+SC[j];}",
            "inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}",
            "int main(){",
            "    scanf(\"%lld\",&n);",
            "    for(i=1;i<=n;SC[i]=SC[i-1]+W[i]*SP[i],SP[i]+=SP[i-1],++i)scanf(\"%lld%lld%lld\",&W[i],&SP[i],&C[i]);",
            "    Q[++t]=0;",
            "    for(i=1;i<=n;++i){",
            "        while(h<t&&slope(Q[h],Q[h+1])<W[i])++h;",
            "        dp[i]=dp[j=Q[h]]+C[i]+W[i]*(SP[i]-SP[j])-SC[i]+SC[j];",
            "        while(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;",
            "        Q[++t]=i;",
            "    }",
            "    printf(\"%lld\",dp[n]);",
            "}",
            ""
        ],
        "description": "插入 仓库建设"
    },
    "任务安排1 O": {
        "prefix": "acm-5.1n^2",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=1e4+5;",
            "LL i,j,n,h=1,t=0,S,Q[N],ST[N],SF[N],dp[N];",
            "//dp[p][i]=min(dp[p-1][j]+(ST[i]+S*p)*(SF[i]-SF[j]));",
            "//dp[i]=min(dp[i],dp[j]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]));",
            "inline LL min(Re a,Re b){return a<b?a:b;}",
            "int main(){",
            "    memset(dp,127,sizeof(dp));dp[0]=0;",
            "    scanf(\"%lld%lld\",&n,&S);",
            "    for(i=1;i<=n;ST[i]+=ST[i-1],SF[i]+=SF[i-1],++i)scanf(\"%lld%lld\",&ST[i],&SF[i]);",
            "    for(i=1;i<=n;++i)",
            "    \tfor(j=0;j<i;++j)",
            "    \t\tdp[i]=min(dp[i],dp[j]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]));",
            "    printf(\"%lld\",dp[n]);",
            "}",
            ""
        ],
        "description": "插入 任务安排1 O"
    },
    "任务安排2 O": {
        "prefix": "acm-5.1n",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=3e5+5;",
            "LL i,j,n,h=1,t=0,S,Q[N],ST[N],SF[N],dp[N];",
            "//dp[p][i]=min(dp[p-1][j]+(ST[i]+S*p)*(SF[i]-SF[j]));",
            "//dp[i]=dp[j]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]);",
            "//(S+ST[i]) * SF[j] + (dp[i]-ST[i]*SF[i]-S*SF[i]) = (dp[j])",
            "//    k     *   x   +              b              = y",
            "inline LL min(Re a,Re b){return a<b?a:b;}",
            "inline LL X(Re j){return SF[j];}",
            "inline LL Y(Re j){return dp[j];}",
            "inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}",
            "int main(){",
            "    scanf(\"%lld%lld\",&n,&S);",
            "    for(i=1;i<=n;ST[i]+=ST[i-1],SF[i]+=SF[i-1],++i)scanf(\"%lld%lld\",&ST[i],&SF[i]);",
            "    Q[++t]=0;",
            "\tfor(i=1;i<=n;++i){",
            "\t\twhile(h<t&&slope(Q[h],Q[h+1])<(S+ST[i]))++h;",
            "        dp[i]=dp[j=Q[h]]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]);",
            "        while(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;",
            "        Q[++t]=i;",
            "\t}",
            "    printf(\"%lld\",dp[n]);",
            "}",
            ""
        ],
        "description": "插入 任务安排2 O"
    },
    "土地征用 Land Acquisition": {
        "prefix": "acm-5.1min",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=5e4+5;",
            "struct QAQ{LL L,W;inline bool operator<(QAQ p)const{return W<p.W;}}a[N];",
            "LL i,j,n,m,h=1,t=0,H=1,T,L[N],W[N],Q[N],dp[N];",
            "inline LL min(Re a,Re b){return a<b?a:b;}",
            "inline LL X(Re j){return -L[j+1];}",
            "inline LL Y(Re j){return dp[j];}",
            "inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}",
            "int main(){",
            "    scanf(\"%lld\",&m);",
            "    for(i=1;i<=m;++i)scanf(\"%lld%lld\",&a[i].L,&a[i].W);",
            "    std::sort(a+1,a+m+1);",
            "    for(i=1;i<=m;++i){",
            "    \twhile(1<=n&&L[n]<=a[i].L)--n;",
            "    \tL[++n]=a[i].L,W[n]=a[i].W;",
            "\t}",
            "    Q[++t]=0;",
            "    for(i=1;i<=n;++i){",
            "        while(h<t&&slope(Q[h],Q[h+1])<W[i])++h;",
            "        dp[i]=dp[j=Q[h]]+L[j+1]*W[i];",
            "        while(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;",
            "        Q[++t]=i;",
            "    }",
            "    printf(\"%lld\",dp[n]);",
            "}",
            ""
        ],
        "description": "插入 土地征用 Land Acquisition"
    },
    "序列分割": {
        "prefix": "acm-5.1max",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=1e5+5,M=205;",
            "LL tmp,i,j,p,n,K,h,t,Q[N],S[N],to[M][N],dp[M][N];",
            "inline LL max(Re a,Re b){return a>b?a:b;}",
            "//dp[p][i]=dp[p-1][j]+S[j]*(S[i]-S[j])",
            "//(S[i]) * S[j] + (-dp[p][i]) = (S[j]^2-dp[p-1][j])",
            "//  k    *  x   +       b     =          y",
            "inline LL X(Re j){return S[j];}",
            "inline LL Y(Re j){return S[j]*S[j]-dp[p-1][j];}",
            "inline long double slope(Re i,Re j){return X(j)==X(i)?-1e18:(long double)(Y(j)-Y(i))/(X(j)-X(i));}",
            "int main(){",
            "    scanf(\"%lld%lld\",&n,&K);",
            "    for(i=1;i<=n;S[i]+=S[i-1],++i)scanf(\"%lld\",&S[i]);",
            "    for(p=1;p<=K;++p){",
            "        h=1,t=0,Q[++t]=p-1;",
            "        for(i=p;i+K-p<=n;++i){",
            "            while(h<t&&slope(Q[h],Q[h+1])<S[i])++h;",
            "        \tdp[p][i]=dp[p-1][to[p][i]=j=Q[h]]+S[j]*(S[i]-S[j]);",
            "       \t\twhile(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;",
            "        \tQ[++t]=i;",
            "        }",
            "    }",
            "    printf(\"%lld\\n\",dp[K][n]);",
            "    for(i=n,j=K;j>=1;--j)printf(\"%lld \",i=to[j][i]);",
            "}",
            ""
        ],
        "description": "插入 序列分割"
    },
    "征途": {
        "prefix": "acm-5.1min",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=3e3+5;",
            "LL p,i,j,n,m,h,t,Q[N],S[N],dp[N][N];",
            "//S_walk[m]=S[n]",
            "//              m                               m",
            "//             i=1                             i=1",
            "//        m",
            "//       i=1",
            "//dp[p][i]=min(dp[p-1][j]+(S[i]-S[j])^2)",
            "//(2*S[i]) * S[j] + (dp[p][i]-S[i]^2) = (dp[p-1][j]+S[j]^2)",
            "//   k     *  x   +         b         =          y",
            "inline LL min(Re a,Re b){return a<b?a:b;}",
            "inline LL X(Re j){return S[j];}",
            "inline LL Y(Re j){return dp[p-1][j]+S[j]*S[j];}",
            "inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}",
            "int main(){",
            "    memset(dp,127,sizeof(dp));dp[0][0]=0;",
            "    scanf(\"%lld%lld\",&n,&m);",
            "    for(i=1;i<=n;S[i]+=S[i-1],++i)scanf(\"%lld\",&S[i]);",
            "    for(p=1;p<=m;++p){",
            "    \th=1,t=0,Q[++t]=0,dp[p][0]=0;",
            "\t    for(i=1;i<=n;++i){",
            "\t        while(h<t&&slope(Q[h],Q[h+1])<2*S[i])++h;",
            "\t        dp[p][i]=min(dp[p-1][i],dp[p-1][j=Q[h]]+(S[i]-S[j])*(S[i]-S[j]));",
            "\t\t\twhile(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;",
            "\t        Q[++t]=i;",
            "\t    }",
            "\t}",
            "    printf(\"%lld\",m*dp[m][n]-S[n]*S[n]);",
            "}",
            ""
        ],
        "description": "插入 征途"
    },
    "摆渡车": {
        "prefix": "acm-5.1min",
        "body": [
            "#include<cstdio>",
            "#define Re register int",
            "const int N=4e6+105;",
            "int i,j,n,m,h=1,t=0,T,ti,ans=2e9,G[N],S[N],Q[N],dp[N];",
            "inline int min(Re a,Re b){return a<b?a:b;}",
            "//                 i",
            "//                 k=j+1",
            "//dp[i]=dp[j]+(G[i]-G[j])*i-(S[i]-S[j])",
            "//(i) * G[j] + (dp[i]+S[j]-i*G[i]) = (dp[j]+S[j])",
            "// k  *  x   +          b          =      y",
            "inline int X(Re j){return G[j];}",
            "inline int Y(Re j){return dp[j]+S[j];}",
            "inline long double slope(Re i,Re j){return X(i)==X(j)?(Y(j)>Y(i)?2e9:-2e9):(long double)(Y(j)-Y(i))/(long double)(X(j)-X(i));}",
            "int main(){",
            "    scanf(\"%d%d\",&n,&m);",
            "    for(i=1;i<=n;T=-min(-T,-ti),++G[ti],S[ti]+=ti,++i)scanf(\"%d\",&ti);",
            "    for(i=1;i<T+m;++i)G[i]+=G[i-1],S[i]+=S[i-1];",
            "    for(i=0;i<m;++i)dp[i]=G[i]*i-S[i];",
            "    Q[++t]=0;",
            "    for(i=m;i<T+m;++i){",
            "    \twhile(h<t&&slope(Q[h],Q[h+1])<=i)++h;",
            "        dp[i]=dp[j=Q[h]]+(G[i]-G[j])*i-S[i]+S[j];",
            "       \twhile(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i-m+1))--t;",
            "        Q[++t]=i-m+1;//(j+1)+m<=i",
            "\t}",
            "    for(i=T;i<T+m;++i)ans=min(ans,dp[i]);",
            "    printf(\"%d\",ans);",
            "}",
            ""
        ],
        "description": "插入 摆渡车"
    },
    "特别行动队": {
        "prefix": "acm-5.1max",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=1e6+5;",
            "LL tmp,i,j,n,a,b,c,h=1,t=0,Q[N],S[N],dp[N];",
            "inline LL max(Re a,Re b){return a>b?a:b;}",
            "//dp[i]=dp[j]+a*(S[i]-S[j])^2+b*(S[i]-S[j])+c",
            "//(-2a*S[i]) * S[j] + (b*S[i]+a*S[i]^2-dp[i]) = (b*S[j]-dp[j]-a*S[j]^2)",
            "//    k      * x    +           b             =             y",
            "inline LL X(Re j){return S[j];}",
            "inline LL Y(Re j){return b*S[j]-dp[j]-a*S[j]*S[j];}",
            "inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}",
            "int main(){",
            "\tscanf(\"%lld%lld%lld%lld\",&n,&a,&b,&c);",
            "\tfor(i=1;i<=n;S[i]+=S[i-1],++i)scanf(\"%lld\",&S[i]);",
            "\tQ[++t]=0;",
            "\tfor(i=1;i<=n;++i){",
            "\t\twhile(h<t&&slope(Q[h],Q[h+1])<(-2*a*S[i]))++h;",
            "\t\tdp[i]=dp[j=Q[h]]+a*(S[i]-S[j])*(S[i]-S[j])+b*(S[i]-S[j])+c;",
            "\t\twhile(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;",
            "\t\tQ[++t]=i;",
            "\t}",
            "\tprintf(\"%lld\",dp[n]);",
            "}",
            ""
        ],
        "description": "插入 特别行动队"
    },
    "货币兑换": {
        "prefix": "acm-5.1CDQ斜率优化",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define LD long double",
            "#define Re register int",
            "using namespace std;",
            "const LL N=1e5+3,inf=1e18;",
            "const LD eps=1e-20;",
            "inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}",
            "int n,h,t,Q[N];LD S,A[N],B[N],Ra[N],f[N],dp[N];",
            "inline void in(Re &x){",
            "    int dp=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')dp|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=dp?-x:x;",
            "}",
            "inline void in(LD &X){",
            "\tX=0;LD Y=1.0;int dp=0;char c=getchar();",
            "\twhile(c<'0'||c>'9')dp|=c=='-',c=getchar(); ",
            "\twhile(c>='0'&&c<='9')X=X*10+(c^48),c=getchar(); ",
            "\tif(c=='.'){c=getchar();while(c>='0'&&c<='9')X+=(Y/=10)*(c^48),c=getchar();}",
            "\tX=dp?-X:X;",
            "}",
            "//dp[i]=max((B[i]/A[i])*f[j]+Ra[j]*f[j]),f[i]=dp[i]/(A[i]*Ra[i]+B[i])",
            "//(B[i]/A[i])*f[j]+(-dp[i])=(-Ra[j]*f[j])",
            "//     k     * x  +   b    =     y",
            "#define X(i) (a[i].x)",
            "#define Y(i) (a[i].y)",
            "struct QAQ{",
            "\tLD k,x,y;int id;",
            "\tinline bool operator<(const QAQ &O)const{return dcmp(x-O.x)?x<O.x:y<O.y;}",
            "}a[N],b[N];",
            "inline bool cmp(QAQ A,QAQ B){return dcmp(A.k-B.k)<0;}",
            "inline LD slope(Re i,Re j){return X(i)==X(j)?(Y(j)>Y(i)?inf:-inf):(Y(j)-Y(i))/(X(j)-X(i));}",
            "inline void CDQ(Re L,Re R){",
            "\tif(L==R){",
            "\t\tRe j=a[L].id;",
            "//\t\tprintf(\"getdp(%d), dp=%.3Lf\\n\",j,dp[j]);",
            "\t\tif(j>1)dp[j]=max(dp[j-1],A[j]*dp[j]),f[j]=dp[j]/(A[j]*Ra[j]+B[j]);",
            "\t\ta[L].x=f[j],a[L].y=-Ra[j]*f[j];",
            "//\t\tprintf(\"k=%.3Lf, x=%.3Lf, y=%.3Lf\\n\",a[L].k,a[L].x,a[L].y);",
            "\t\treturn;",
            "\t}",
            "\tRe mid=(L+R)>>1,p1=L,p2=mid+1,h=1,t=0;",
            "\tfor(Re i=L;i<=R;++i)a[i].id<=mid?b[p1++]=a[i]:b[p2++]=a[i];",
            "\tfor(Re i=L;i<=R;++i)a[i]=b[i];",
            "\tCDQ(L,mid);",
            "\tfor(Re i=L;i<=mid;++i){",
            "\t\twhile(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i))--t;",
            "\t\tQ[++t]=i;",
            "\t}",
            "\tfor(Re i=mid+1,j,id;i<=R;++i){",
            "\t\twhile(h<t&&slope(Q[h],Q[h+1])<=a[i].k)++h;",
            "\t\tif(h<=t)id=a[i].id,j=Q[h],dp[id]=max(dp[id],-(a[j].y-a[i].k*a[j].x));",
            "\t}",
            "\tCDQ(mid+1,R);Re p=L-1;p1=L,p2=mid+1;",
            "\twhile(p1<=mid&&p2<=R)b[++p]=a[p1]<a[p2]?a[p1++]:a[p2++];",
            "\twhile(p1<=mid)b[++p]=a[p1++];while(p2<=R)b[++p]=a[p2++];",
            "\tfor(Re i=L;i<=R;++i)a[i]=b[i];",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(S);",
            "\tfor(Re i=1;i<=n;++i)in(A[i]),in(B[i]),in(Ra[i]),dp[i]=-inf;",
            "\tfor(Re i=1;i<=n;++i)a[i].k=B[i]/A[i],a[i].id=i;",
            "\tf[1]=(dp[1]=S)/(A[1]*Ra[1]+B[1]);",
            "//\tfor(Re i=2;i<=n;++i){",
            "//\t\tfor(Re j=1;j<i;++j)dp[i]=max(dp[i],f[j]*Ra[j]+f[j]*B[i]/A[i]);",
            "//\t\tdp[i]=max(dp[i-1],A[i]*dp[i]),f[i]=dp[i]/(A[i]*Ra[i]+B[i]);",
            "//\t}",
            "\tsort(a+1,a+n+1,cmp),CDQ(1,n);",
            "\tprintf(\"%.3Lf\",dp[n]);",
            "}",
            ""
        ],
        "description": "插入 货币兑换"
    },
    "锯木厂选址": {
        "prefix": "acm-5.1X",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LD long double",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const LL N=2e5+3,inf=1e18;",
            "int n,x,h=1,t,Q[N];LL ans=inf,Ans,D[N],S[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "// S严格递增",
            "// D严格递减",
            "//F[j]=max(D[i]*S[i]-D[i]*S[j]+D[j]*S[j])",
            "//D[i]*S[j] + F[i]-D[i]*S[i] = D[j]*S[j]",
            "// k  * x   +       b        =     y",
            "inline LL X(Re j){return S[j];}",
            "inline LL Y(Re j){return D[j]*S[j];}",
            "inline LD slope(Re i,Re j){return (LD)(Y(j)-Y(i))/(X(j)-X(i));}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n);",
            "\tfor(Re i=1;i<=n;++i)in(x),S[i]=S[i-1]+x,in(x),D[i+1]=D[i]+x;",
            "\tfor(Re i=1;i<=n+1;++i)D[i]=D[n+1]-D[i],Ans+=D[i]*(S[i]-S[i-1]);",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tLL tmp=-inf;",
            "\t\twhile(h<t&&slope(Q[h],Q[h+1])>=D[i])++h;",
            "\t\tif(h<=t)ans=min(ans,Ans-(D[i]*(S[i]-S[Q[h]])+D[Q[h]]*S[Q[h]]));",
            "\t\twhile(h<t&&slope(Q[t-1],i)>=slope(Q[t-1],Q[t]))--t;",
            "\t\tQ[++t]=i;",
            "//\t\tfor(Re j=1;j<i;++j)tmp=max(tmp,D[i]*(S[i]-S[j])+D[j]*S[j]);",
            "\t}",
            "\tprintf(\"%lld\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 锯木厂选址"
    },
    "高速公路": {
        "prefix": "acm-5.1x单调 k不单调，树上转移",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const LL N=1e6+3,inf=4e18;",
            "int n,m,x,y,z,o,h,t,P[N],Q[N],A[N],Fa[N],head[N];LL ans,dp[N],dis[N];",
            "struct QAQ{int w,to,next;}a[N];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "//dp[i]=min(dp[j]+P[i]*(dis[i]-dis[j])+A[i])",
            "//dp[i]=dp[j]+P[i]*dis[i]-P[i]*dis[j]+A[i]",
            "//P[i]*dis[j]+dp[i]-P[i]*dis[i]-A[i]=dp[j]",
            "//  k *  x   +          b           =  y",
            "inline LL Y(Re j){return dp[j];}",
            "inline LL X(Re j){return dis[j];}",
            "inline LD slope(Re i,Re j){return (LD)(Y(j)-Y(i))/(X(j)-X(i));}",
            "inline void dfs(Re x,Re fa){",
            "\tdp[x]=inf;Re h0=h,t0=t;",
            "\tRe l=h,r=t;",
            "\twhile(l<r){",
            "\t\tRe mid=l+r>>1;",
            "\t\tif(slope(Q[mid],Q[mid+1])<=P[x])l=mid+1;",
            "\t\telse r=mid;",
            "\t}",
            "\th=r;",
            "\tdp[x]=dp[Q[h]]+(LL)P[x]*(dis[x]-dis[Q[h]])+A[x];",
            "\tl=h,r=t;",
            "\twhile(l<r){",
            "\t\tRe mid=l+r+1>>1;",
            "\t\tif(slope(Q[mid-1],x)<=slope(Q[mid-1],Q[mid]))r=mid-1;",
            "\t\telse l=mid;",
            "\t}",
            "\tRe Qx0=Q[r+1];t=r,Q[++t]=x;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)dis[to=a[i].to]=dis[x]+a[i].w,dfs(to,x);",
            "\th=h0,Q[t]=Qx0,t=t0;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n);",
            "\tfor(Re i=2;i<=n;++i)in(x),in(z),in(P[i]),in(A[i]),add(x,i,z),Fa[i]=x;",
            "\tdp[1]=0,h=1,t=0,Q[++t]=1;",
            "\tfor(Re i=head[1],to;i;i=a[i].next)",
            "\t\tdis[to=a[i].to]=dis[1]+a[i].w,dfs(to,1);",
            "\tfor(Re i=2;i<=n;++i)printf(\"%lld\\n\",dp[i]);",
            "}",
            ""
        ],
        "description": "插入 高速公路"
    },
    "插头DP": {
        "prefix": "acm-5.4Eat the Trees",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=15,M=8192+3;",
            "int n,m,o,V,T,A[N][N];LL dp[2][M];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(T);",
            "\twhile(T--){",
            "\t\tin(n),in(m),V=(1<<m+1)-1;",
            "\t\tfor(Re i=1;i<=n;++i)",
            "\t\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\t\tin(A[i][j]);",
            "\t\tfor(Re j=0;j<=V;++j)dp[0][j]=dp[1][j]=0;",
            "\t\tdp[o][0]=1;",
            "\t\tfor(Re i=1;i<=n;++i){",
            "\t\t\to^=1;",
            "\t\t\tfor(Re s=0;s<=V;++s)dp[o][s]=(s&1)?0:dp[o^1][s>>1];",
            "\t\t\tfor(Re j=1;j<=m;++j){",
            "\t\t\t\to^=1;",
            "\t\t\t\tfor(Re s=0;s<=V;++s)dp[o][s]=0;",
            "\t\t\t\tfor(Re s=0;s<=V;++s)if(dp[o^1][s]){",
            "\t\t\t\t\tRe L=(s>>j-1)&1,U=(s>>j+1-1)&1;",
            "\t\t\t\t\tif(A[i][j]){// 撤销操作",
            "\t\t\t\t\t\tdp[o][s^(1<<j-1)^(1<<j+1-1)]+=dp[o^1][s];",
            "\t\t\t\t\t\tif(L!=U)dp[o][s]+=dp[o^1][s];",
            "\t\t\t\t\t}",
            "\t\t\t\t\telse{",
            "\t\t\t\t\t\tif(!L&&!U)dp[o][s]+=dp[o^1][s];",
            "\t\t\t\t\t}",
            "\t\t\t\t}",
            "\t\t\t}",
            "\t\t}",
            "\t\tprintf(\"%lld\\n\",dp[o][0]);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 插头DP"
    },
    "插头DP  (括号表示法)": {
        "prefix": "acm-5.4单回路",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=14,M=1594323+3;",
            "int n,m,o,V,edx,edy,Mi[N],A[N][N];LL ans,dp[2][M];char s[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),Mi[0]=1;",
            "\tfor(Re i=1;i<=m+1;++i)Mi[i]=Mi[i-1]*3;V=Mi[m+1]-1;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tscanf(\"%s\",s+1);",
            "\t\tfor(Re j=1;j<=m;++j)if(!(A[i][j]=(s[j]=='*')))edx=i,edy=j;",
            "\t}",
            "//\tprintf(\"edx=%d, edy=%d\\n\",edx,edy);",
            "\tdp[o][0]=1;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\to^=1;",
            "\t\tfor(Re s=0;s<=V;++s)dp[o][s]=s%3?0:dp[o^1][s/3];",
            "\t\tfor(Re j=1;j<=m;++j){",
            "\t\t\to^=1;",
            "\t\t\tfor(Re s=0;s<=V;++s)dp[o][s]=0;",
            "\t\t\tfor(Re s=0;s<=V;++s)if(dp[o^1][s]){",
            "\t\t\t\tRe L=s/Mi[j-1]%3,U=s/Mi[j+1-1]%3;",
            "\t\t\t\tif(A[i][j]){if(!L&&!U)dp[o][s]+=dp[o^1][s];}",
            "\t\t\t\telse if(!L&&!U)dp[o][s+Mi[j-1]+2*Mi[j+1-1]]+=dp[o^1][s];",
            "\t\t\t\telse if(!L&&U)dp[o][s]+=dp[o^1][s],dp[o][s+U*Mi[j-1]-U*Mi[j+1-1]]+=dp[o^1][s];",
            "\t\t\t\telse if(L&&!U)dp[o][s]+=dp[o^1][s],dp[o][s-L*Mi[j-1]+L*Mi[j+1-1]]+=dp[o^1][s];",
            "\t\t\t\telse if(L==1&&U==1){",
            "\t\t\t\t\tRe cnt=1;",
            "\t\t\t\t\tfor(Re k=j+2;k<=m;++k){",
            "\t\t\t\t\t\tif(s/Mi[k-1]%3==1)++cnt;",
            "\t\t\t\t\t\telse if(s/Mi[k-1]%3==2)--cnt;",
            "\t\t\t\t\t\tif(!cnt){dp[o][s-Mi[j-1]-Mi[j+1-1]-Mi[k-1]]+=dp[o^1][s];break;}",
            "\t\t\t\t\t}",
            "\t\t\t\t}",
            "\t\t\t\telse if(L==2&&U==2){",
            "\t\t\t\t\tRe cnt=1;",
            "\t\t\t\t\tfor(Re k=j-1;k>=1;--k){",
            "\t\t\t\t\t\tif(s/Mi[k-1]%3==1)--cnt;",
            "\t\t\t\t\t\telse if(s/Mi[k-1]%3==2)++cnt;",
            "\t\t\t\t\t\tif(!cnt){dp[o][s-2*Mi[j-1]-2*Mi[j+1-1]+Mi[k-1]]+=dp[o^1][s];break;}",
            "\t\t\t\t\t}",
            "\t\t\t\t}",
            "\t\t\t\telse if(L==2&&U==1)dp[o][s-2*Mi[j-1]-Mi[j+1-1]]+=dp[o^1][s];",
            "\t\t\t\telse if(L==1&&U==2)if(i==edx&&j==edy&&!(s-Mi[j-1]-2*Mi[j+1-1]))ans+=dp[o^1][s];",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "\tprintf(\"%lld\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 插头DP  (括号表示法)"
    },
    "插头DP  (括号表示法+优化状态枚举)": {
        "prefix": "acm-5.4单回路",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=14,M=1594323+3;",
            "int n,m,o,V,edx,edy,Mi[N],A[N][N];LL ans,dp[2][M];char s[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int st[2][M];",
            "inline void add(Re s,LL v){",
            "\tif(!dp[o][s])st[o][++st[o][0]]=s;",
            "\tdp[o][s]+=v;",
            "}",
            "inline void CL(){",
            "\tfor(Re i=1;i<=st[o][0];++i)dp[o][st[o][i]]=0;",
            "\tst[o][0]=0;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),Mi[0]=1;",
            "\tfor(Re i=1;i<=m+1;++i)Mi[i]=Mi[i-1]*3;V=Mi[m+1]-1;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tscanf(\"%s\",s+1);",
            "\t\tfor(Re j=1;j<=m;++j)if(!(A[i][j]=(s[j]=='*')))edx=i,edy=j;",
            "\t}",
            "//\tprintf(\"edx=%d, edy=%d\\n\",edx,edy);",
            "\tdp[o][st[o][++st[o][0]]=0]=1;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\to^=1,CL();",
            "\t\tfor(Re I=1;I<=st[o^1][0];++I)if(st[o^1][I]*3<=V&&dp[o^1][st[o^1][I]])",
            "\t\t\tdp[o][st[o][++st[o][0]]=st[o^1][I]*3]=dp[o^1][st[o^1][I]];",
            "\t\tfor(Re j=1;j<=m;++j){",
            "\t\t\to^=1,CL();",
            "\t\t\tfor(Re I=1;I<=st[o^1][0];++I)if(dp[o^1][st[o^1][I]]){",
            "\t\t\t\tRe s=st[o^1][I];LL v=dp[o^1][s];",
            "\t\t\t\tRe L=s/Mi[j-1]%3,U=s/Mi[j+1-1]%3;",
            "\t\t\t\tif(A[i][j]){if(!L&&!U)add(s,v);}",
            "\t\t\t\telse if(!L&&!U)add(s+Mi[j-1]+2*Mi[j+1-1],v);",
            "\t\t\t\telse if(!L&&U)add(s,v),add(s+U*Mi[j-1]-U*Mi[j+1-1],v);",
            "\t\t\t\telse if(L&&!U)add(s,v),add(s-L*Mi[j-1]+L*Mi[j+1-1],v);",
            "\t\t\t\telse if(L==1&&U==1){",
            "\t\t\t\t\tRe cnt=1;",
            "\t\t\t\t\tfor(Re k=j+2;k<=m;++k){",
            "\t\t\t\t\t\tif(s/Mi[k-1]%3==1)++cnt;",
            "\t\t\t\t\t\telse if(s/Mi[k-1]%3==2)--cnt;",
            "\t\t\t\t\t\tif(!cnt){add(s-Mi[j-1]-Mi[j+1-1]-Mi[k-1],v);break;}",
            "\t\t\t\t\t}",
            "\t\t\t\t}",
            "\t\t\t\telse if(L==2&&U==2){",
            "\t\t\t\t\tRe cnt=1;",
            "\t\t\t\t\tfor(Re k=j-1;k>=1;--k){",
            "\t\t\t\t\t\tif(s/Mi[k-1]%3==1)--cnt;",
            "\t\t\t\t\t\telse if(s/Mi[k-1]%3==2)++cnt;",
            "\t\t\t\t\t\tif(!cnt){add(s-2*Mi[j-1]-2*Mi[j+1-1]+Mi[k-1],v);break;}",
            "\t\t\t\t\t}",
            "\t\t\t\t}",
            "\t\t\t\telse if(L==2&&U==1)add(s-2*Mi[j-1]-Mi[j+1-1],v);",
            "\t\t\t\telse if(L==1&&U==2)if(i==edx&&j==edy&&!(s-Mi[j-1]-2*Mi[j+1-1]))ans+=v;",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "\tprintf(\"%lld\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 插头DP  (括号表示法+优化状态枚举)"
    },
    "地板": {
        "prefix": "acm-5.4三进制插头dp",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=103,M=177147+3,P=20110520;",
            "int n,m,o,V,Mi[N],A[N][N],A_[N][N],dp[2][M];char s[N];//0:没有插头 1:还没完成的插头 2:已经完成的插头",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void mo(Re &x){if(x>P)x-=P;}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m);",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tscanf(\"%s\",s+1);",
            "\t\tfor(Re j=1;j<=m;++j)A[i][j]=(s[j]=='*');",
            "\t}",
            "\tif(n<m){",
            "\t\tfor(Re i=1;i<=n;++i)",
            "\t\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\t\tA_[j][i]=A[i][j];",
            "\t\tswap(n,m);",
            "\t\tfor(Re i=1;i<=n;++i)",
            "\t\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\t\tA[i][j]=A_[i][j];",
            "\t}",
            "\tMi[0]=1;for(Re i=1;i<=m+1;++i)Mi[i]=Mi[i-1]*3;",
            "\tV=Mi[m+1]-1,dp[o][0]=1;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\to^=1;",
            "\t\tfor(Re s=0;s<=V;++s)dp[o][s]=s%3?0:dp[o^1][s/3];",
            "\t\tfor(Re j=1;j<=m;++j){",
            "\t\t\to^=1;",
            "\t\t\tfor(Re s=0;s<=V;++s)dp[o][s]=0;",
            "\t\t\tfor(Re s=0;s<=V;++s)if(dp[o^1][s]){",
            "\t\t\t\tRe L=s/Mi[j-1]%3,U=s/Mi[j+1-1]%3,ML=Mi[j-1],MU=Mi[j+1-1];",
            "\t\t\t\tif(A[i][j]){",
            "\t\t\t\t\tif(!L&&!U)mo(dp[o][s]+=dp[o^1][s]);",
            "\t\t\t\t}",
            "\t\t\t\telse{",
            "\t\t\t\t\tif(L==0&&U==0){",
            "\t\t\t\t\t\tmo(dp[o][s+ML]+=dp[o^1][s]);",
            "\t\t\t\t\t\tmo(dp[o][s+MU]+=dp[o^1][s]);",
            "\t\t\t\t\t\tmo(dp[o][s+2*ML+2*MU]+=dp[o^1][s]);",
            "\t\t\t\t\t}",
            "\t\t\t\t\tif(L==0&&U==1){",
            "\t\t\t\t\t\tmo(dp[o][s+MU]+=dp[o^1][s]);",
            "\t\t\t\t\t\tmo(dp[o][s+ML-MU]+=dp[o^1][s]);",
            "\t\t\t\t\t}",
            "\t\t\t\t\tif(L==0&&U==2){",
            "\t\t\t\t\t\tmo(dp[o][s+2*ML-2*MU]+=dp[o^1][s]);",
            "\t\t\t\t\t\tmo(dp[o][s-2*MU]+=dp[o^1][s]);",
            "\t\t\t\t\t}",
            "\t\t\t\t\tif(L==1&&U==0){",
            "\t\t\t\t\t\tmo(dp[o][s+ML]+=dp[o^1][s]);",
            "\t\t\t\t\t\tmo(dp[o][s-ML+MU]+=dp[o^1][s]);",
            "\t\t\t\t\t}",
            "\t\t\t\t\tif(L==1&&U==1)mo(dp[o][s-ML-MU]+=dp[o^1][s]);",
            "\t\t\t\t\tif(L==1&&U==2);",
            "\t\t\t\t\tif(L==2&&U==0){",
            "\t\t\t\t\t\tmo(dp[o][s-2*ML+2*MU]+=dp[o^1][s]);",
            "\t\t\t\t\t\tmo(dp[o][s-2*ML]+=dp[o^1][s]);",
            "\t\t\t\t\t}",
            "\t\t\t\t\tif(L==2&&U==1);",
            "\t\t\t\t\tif(L==2&&U==2);",
            "\t\t\t\t}",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "\tprintf(\"%d\\n\",dp[o][0]);",
            "}",
            ""
        ],
        "description": "插入 地板"
    },
    "数位DP  (Windy数)": {
        "prefix": "acm-5.3dp",
        "body": [
            "#include<cstdio>",
            "#include<cmath>",
            "#define R register int",
            "using namespace std;",
            "int i,j,k,a,b,l,ans,num[12],dp[12][10];",
            "inline int dpp(int len){",
            "    ans=0;",
            "    for(i=1;i<len;i++)",
            "        for(j=1;j<10;j++)",
            "            ans+=dp[i][j];",
            "    for(j=1;j<num[len];j++)ans+=dp[len][j];",
            "    for(i=len-1;i>0;i--){",
            "        for(j=0;j<num[i];j++)",
            "            if(abs(num[i+1]-j)>=2)ans+=dp[i][j];",
            "        if(abs(num[i]-num[i+1])<2)break;",
            "    }",
            "    if(!i)ans++;",
            "    return ans;",
            "}",
            "inline int sovle(int x){",
            "    l=0;",
            "    while(x)num[++l]=x%10,x/=10;",
            "    return dpp(l);",
            "}",
            "inline int sakura(){",
            "    scanf(\"%d%d\",&a,&b);",
            "    for(i=0;i<10;i++)dp[1][i]=1;",
            "    for(i=2;i<11;i++)",
            "        for(j=0;j<10;j++)",
            "            for(k=0;k<10;k++)",
            "                if(abs(j-k)>=2)",
            "                    dp[i][j]+=dp[i-1][k];",
            "    printf(\"%d\",sovle(b)-sovle(a-1));",
            "}",
            "int QAQWQ=sakura();",
            "int main(){}",
            ""
        ],
        "description": "插入 数位DP  (Windy数)"
    },
    "Crash的文明世界": {
        "prefix": "acm-4.5树形dp",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e4+3,M=153,P=10007;",
            "int n,m,x,y,o,K,jc[M],fto[M],head[N],S[M][M],f[N][M],g[N][M];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int dp=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')dp|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=dp?-x:x;",
            "}",
            "inline void dfs1(Re x,Re fa){",
            "\tf[x][0]=1;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa){",
            "\t\t\tdfs1(to,x),(f[x][0]+=f[to][0])%=P;",
            "\t\t\tfor(Re j=1;j<=K;++j)(f[x][j]+=(f[to][j]+f[to][j-1])%P)%=P;",
            "\t\t}",
            "}",
            "inline void dfs2(Re x,Re fa){",
            "\tif(fa){",
            "\t\tfto[0]=(g[fa][0]+f[fa][0]-f[x][0]+P)%P;",
            "\t\tfor(Re j=1;j<=K;++j)fto[j]=(g[fa][j]+f[fa][j]-(f[x][j]+f[x][j-1])%P+P)%P;",
            "\t\tg[x][0]=fto[0];",
            "\t\tfor(Re j=1;j<=K;++j)g[x][j]=(fto[j]+fto[j-1])%P;",
            "\t}",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa)dfs2(to,x);",
            "}",
            "inline void Stirling(Re N){",
            "\tfor(Re i=0;i<=N;++i)S[i][i]=1;",
            "\tfor(Re i=1;i<=N;++i)",
            "\t\tfor(Re j=1;j<i;++j)",
            "\t\t\tS[j][i]=(S[j-1][i-1]+j*S[j][i-1]%P)%P;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(K),m=n-1;",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tdfs1(1,0),dfs2(1,0),Stirling(K),jc[0]=1;",
            "\tfor(Re i=1;i<=K;++i)jc[i]=jc[i-1]*i%P;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tRe ans=0;",
            "\t\tfor(Re j=0;j<=K;++j)",
            "\t\t\t(ans+=S[j][K]*jc[j]%P*(f[i][j]+g[i][j])%P)%=P;",
            "\t\tprintf(\"%d\\n\",ans);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 Crash的文明世界"
    },
    "换根dp": {
        "prefix": "acm-4.5Great Cow Gathering",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const LL N=1e5+3,inf=1e18;",
            "int n,m,x,y,z,o,A[N],S[N],dis[N],size[N],head[N];LL ans=inf,f[N],g[N];",
            "struct QAQ{int w,to,next;}a[N<<1];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void dfs1(Re x,Re fa){",
            "\tsize[x]=1,S[x]=A[x];",
            "\tfor(Re i=head[x],to;i;i=a[i].next)if((to=a[i].to)!=fa)",
            "\t\tdis[to]=a[i].w,dfs1(to,x),S[x]+=S[to],size[x]+=size[to],f[x]+=f[to]+(LL)S[to]*a[i].w;",
            "}",
            "inline void dfs2(Re x,Re fa){",
            "\tif(fa)g[x]=g[fa]+f[fa]-f[x]-(LL)S[x]*dis[x]+(LL)(S[1]-S[x])*dis[x];",
            "\tfor(Re i=head[x],to;i;i=a[i].next)if((to=a[i].to)!=fa)dfs2(to,x);",
            "\tans=min(ans,f[x]+g[x]);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),m=n-1;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\twhile(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);",
            "\tdfs1(1,0),dfs2(1,0),printf(\"%lld\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 换根dp"
    },
    "树形dp": {
        "prefix": "acm-4.5没有上司的舞会",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define R register int",
            "using namespace std;",
            "int head[6010],a,b,t,i,j,n,f[6010][2],pan[6010];",
            "struct QAQ{int next,to;}Q[6010];",
            "inline void add(int x,int y){Q[++t].to=y,Q[t].next=head[x],head[x]=t;}",
            "inline void dfs(int w){",
            "    for(R k=head[w];k;k=Q[k].next){",
            "        int to=Q[k].to;",
            "        dfs(to);",
            "        f[w][0]+=max(f[to][0],f[to][1]);",
            "        f[w][1]+=f[to][0];",
            "    }",
            "}",
            "int main(){",
            "    scanf(\"%d\",&n);",
            "    for(i=1;i<=n;i++)scanf(\"%d\",&f[i][1]);",
            "    for(i=1;i<n;i++)scanf(\"%d%d\",&a,&b),pan[a]++,add(b,a);",
            "    for(i=1;i<=n;i++)",
            "        if(!pan[i]){",
            "            dfs(i);",
            "            printf(\"%d\\n\",max(f[i][0],f[i][1]));",
            "            return 0;",
            "        }",
            "}",
            ""
        ],
        "description": "插入 树形dp"
    },
    "保安站岗，皇宫看守": {
        "prefix": "acm-4.5树形dp",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define R register int",
            "using namespace std;",
            "struct QAQ{int to,next;}a[1505]; ",
            "int m,pan[1505],n,t,w[1505],dp[1505][3],head[1505];",
            "inline void add(int x,int y){a[++t].to=y,a[t].next=head[x],head[x]=t;}",
            "  //dp[i][0] 以及各种情况的具体转移方程和初始状态 ",
            "inline void dfs(int x){",
            "    R i,to,dd=0xfffffff;",
            "    dp[x][1]=w[x];dp[x][2]=0;dp[x][0]=0;",
            "    for(i=head[x];i;i=a[i].next){",
            "        dfs(to=a[i].to);",
            "        dd=min(dd,dp[to][1]-min(dp[to][0],dp[to][1]));",
            "        dp[x][0]+=min(dp[to][0],dp[to][1]);",
            "        dp[x][1]+=min(dp[to][1],dp[to][2]);",
            "        dp[x][2]+=min(dp[to][0],dp[to][1]);",
            "    }",
            "    dp[x][0]+=dd;",
            "}",
            "int main(){",
            "\tmemset(dp,127,sizeof(dp));",
            "    scanf(\"%d\",&n);",
            "    R i,j,a,k,r;",
            "    for(i=1;i<=n;i++){",
            "        scanf(\"%d%d%d\",&a,&k,&m);w[a]=k;",
            "        for(j=1;j<=m;j++)scanf(\"%d\",&r),pan[r]=1,add(a,r);",
            "    }",
            "    for(i=1;i<=n;i++)",
            "        if(!pan[i]){",
            "            dfs(i);",
            "            printf(\"%d\",min(dp[i][1],dp[i][0]));",
            "            return 0;",
            "        }",
            "}",
            ""
        ],
        "description": "插入 保安站岗，皇宫看守"
    },
    "树上背包优化O复杂度 (NOI Online 2 游戏)": {
        "prefix": "acm-4.5nk",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5003,P=998244353;",
            "int n,m,o,x,y,f[N],g[N],A[N],jc[N],head[N];char s[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "int sz1[N],sz0[N],lim[N],dp[N][N],tmp[N];",
            "inline void dfs0(Re x,Re fa){",
            "\tsz0[x]=(!A[x]),sz1[x]=A[x];",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa)dfs0(to,x),sz1[x]+=sz1[to],sz0[x]+=sz0[to];",
            "//\tlim[x]=min(sz1[x],size[x]-sz1[x]);",
            "}",
            "inline void dfs(Re x,Re fa){",
            "\tdp[x][0]=1;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa){",
            "\t\t\tdfs(to,x);",
            "\t\t\tfor(Re j=0;j<=lim[x]+lim[to];++j)tmp[j]=0;",
            "\t\t\tfor(Re j=lim[x];j>=0;--j)",
            "\t\t\t\tfor(Re k=lim[to];k>=0;--k)",
            "\t\t\t\t\t(tmp[j+k]+=(LL)dp[x][j]*dp[to][k]%P)%=P;",
            "\t\t\tlim[x]+=lim[to];",
            "\t\t\tfor(Re j=0;j<=lim[x];++j)dp[x][j]=tmp[j];",
            "\t\t}",
            "\t++lim[x];",
            "\tif(A[x])for(Re j=min(lim[x],sz0[x]);j>=1;--j)",
            "\t\t(dp[x][j]+=(LL)dp[x][j-1]*(sz0[x]-(j-1))%P)%=P;",
            "\telse for(Re j=min(lim[x],sz1[x]);j>=1;--j)",
            "\t\t(dp[x][j]+=(LL)dp[x][j-1]*(sz1[x]-(j-1))%P)%=P;",
            "\twhile(!dp[x][lim[x]])--lim[x];",
            "}",
            "inline int C(Re m,Re n){return (LL)jc[n]*inv(jc[m])%P*inv(jc[n-m])%P;}",
            "int main(){",
            "//\tfreopen(\"match.in\",\"r\",stdin);",
            "//\tfreopen(\"match.out\",\"w\",stdout);",
            "\tin(n),scanf(\"%s\",s+1),m=n-1,jc[0]=1;",
            "\tfor(Re i=1;i<=n;++i)A[i]=s[i]-'0',jc[i]=(LL)jc[i-1]*i%P;",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tdfs0(1,0),dfs(1,0);",
            "//\tfor(Re i=1;i<=n;++i)printf(\"lim[%d]=%d\\n\",i,lim[i]);",
            "//\tfor(Re i=0;i<=n/2;++i)printf(\"dp[%d]=%d\\n\",i,dp[1][i]);",
            "//\tfor(Re j=0;j<=lim[1];++j)printf(\"%d \",dp[1][j]);",
            "\tfor(Re j=0;j<=lim[1];++j)g[j]=(LL)dp[1][j]*jc[n/2-j]%P;",
            "\tfor(Re i=lim[1];i>=0;--i){",
            "\t\tf[i]=g[i];",
            "\t\tfor(Re j=i+1;j<=lim[1];++j)f[i]=(f[i]-(LL)C(i,j)*f[j]%P+P)%P;",
            "\t}",
            "\tfor(Re i=0;i<=n/2;++i)printf(\"%d\\n\",f[i]);",
            "\tfclose(stdin);",
            "\tfclose(stdout);",
            "\treturn 0;",
            "}",
            ""
        ],
        "description": "插入 树上背包优化O复杂度 (NOI Online 2 游戏)"
    },
    "树上背包优化O复杂度 (树上染色)": {
        "prefix": "acm-4.5nk",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=2003;",
            "int n,m,x,y,z,o,K,size[N],head[N];LL tmp[N],dp[N][N];",
            "struct QAQ{int w,to,next;}a[N<<1];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void dfs(Re x,Re fa){",
            "\tsize[x]=1,dp[x][0]=dp[x][1]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa){",
            "\t\t\tdfs(to,x);",
            "\t\t\tfor(Re j=0;j<=size[x]+size[to];++j)tmp[j]=dp[0][0];",
            "\t\t\tfor(Re j=size[x];j>=0;--j)",
            "\t\t\t\tif(dp[x][j]>=0)for(Re k=size[to];k>=0;--k)",
            "\t\t\t\t\tif(dp[to][k]>=0)",
            "\t\t\t\t\t\ttmp[j+k]=max(tmp[j+k],dp[x][j]+dp[to][k]+",
            "\t\t\t\t\t\t\t(LL)a[i].w*((LL)k*(K-k)+(LL)(size[to]-k)*(n-size[to]-(K-k)))",
            "\t\t\t\t\t\t);",
            "\t\t\tsize[x]+=size[to];",
            "\t\t\tfor(Re j=0;j<=size[x];++j)dp[x][j]=tmp[j];",
            "\t\t}",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(K),m=n-1;",
            "\twhile(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);",
            "\tmemset(dp,-20,sizeof(dp));",
            "\tdfs(1,0),printf(\"%lld\\n\",dp[1][K]);",
            "}",
            ""
        ],
        "description": "插入 树上背包优化O复杂度 (树上染色)"
    },
    "01背包": {
        "prefix": "acm-5.2采药",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "int T,n,i,j,v[110],w[110],f[1010];",
            "int main(){",
            "    scanf(\"%d%d\",&T,&n);",
            "    for(i=1;i<=n;i++)",
            "        scanf(\"%d%d\",&v[i],&w[i]);",
            "    for(i=1;i<=n;i++)",
            "        for(j=T;j>=v[i];j--)",
            "            f[j]=std::max(f[j],f[j-v[i]]+w[i]);",
            "    printf(\"%d\",f[T]);",
            "    return 0;",
            "}",
            ""
        ],
        "description": "插入 01背包"
    },
    "二维费用": {
        "prefix": "acm-5.2找啊找啊找GF",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "using namespace std;",
            "int tmp,T1,T2,x,y,n,i,j,k,v1[105],v2[105],w[105],dp[105][105],ans[105][105];",
            "int main(){",
            "    scanf(\"%d\",&n);",
            "    for(i=1;i<=n;i++)scanf(\"%d%d%d\",&v1[i],&v2[i],&w[i]);",
            "    scanf(\"%d%d\",&T1,&T2);",
            "    for(i=1;i<=n;++i)",
            "        for(j=T1;j>=v1[i];--j)",
            "            for(k=T2;k>=v2[i];--k){",
            "            \tif(dp[j][k]<(tmp=dp[j-v1[i]][k-v2[i]]+1)){",
            "            \t\tdp[j][k]=tmp;",
            "            \t\tans[j][k]=ans[j-v1[i]][k-v2[i]]+w[i];",
            "\t\t\t\t}",
            "\t\t\t\telse if(dp[j][k]==tmp)ans[j][k]=min(ans[j][k],ans[j-v1[i]][k-v2[i]]+w[i]);",
            "            }",
            "    printf(\"%d\",ans[T1][T2]);",
            "}",
            ""
        ],
        "description": "插入 二维费用"
    },
    "分组背包": {
        "prefix": "acm-5.2金明的预算方案",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "using namespace std;",
            "int T,n,i,j,a[65],s,t,r1,r2,r[65][3],v[65],w[65],f[32010];",
            "int main(){",
            "    scanf(\"%d%d\",&T,&n);",
            "    v[0]=0xfffffff;",
            "    for(i=1;i<=n;i++){",
            "        scanf(\"%d%d%d\",&v[i],&s,&a[i]);",
            "        if(a[i])r[a[i]][++r[a[i]][0]]=i;w[i]=v[i]*s;",
            "    }",
            "    for(i=1;i<=n;i++)",
            "        for(j=T;j>=v[i]&&(!a[i]);j--){",
            "            t=j-v[i],r1=r[i][1],r2=r[i][2];",
            "            f[j]=max(f[j],f[t]+w[i]);",
            "            if(v[r1]<=t)f[j]=max(f[j],f[t-v[r1]]+w[i]+w[r1]);",
            "            if(v[r2]<=t)f[j]=max(f[j],f[t-v[r2]]+w[i]+w[r2]);",
            "            if(v[r1]+v[r2]<=t)f[j]=max(f[j],f[t-v[r1]-v[r2]]+w[i]+w[r1]+w[r2]);",
            "        }",
            "    printf(\"%d\",f[T]);",
            "}",
            ""
        ],
        "description": "插入 分组背包"
    },
    "多人背包": {
        "prefix": "acm-5.2kth_knapsack",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "int ans,T,n,i,j,k,K,a,b,t,re[45],v[210],w[210],f[5010][45];",
            "int main(){",
            "    scanf(\"%d%d%d\",&K,&T,&n);",
            "    memset(f,-127,sizeof(f));f[0][1]=0;",
            "    for(i=1;i<=n;i++)",
            "        scanf(\"%d%d\",&v[i],&w[i]);",
            "    for(i=1;i<=n;i++)",
            "        for(j=T;j>=v[i];j--){",
            "            a=b=1,t=0;",
            "            while(t<=K){",
            "                if(f[j][a]>=f[j-v[i]][b]+w[i])re[++t]=f[j][a++];",
            "                else re[++t]=f[j-v[i]][b++]+w[i];",
            "            }",
            "            for(k=1;k<=K;k++)f[j][k]=re[k];",
            "        }",
            "    for(i=1;i<=K;i++)ans+=f[T][i];",
            "    printf(\"%d\",ans);",
            "    return 0;",
            "}",
            ""
        ],
        "description": "插入 多人背包"
    },
    "多重背包  (宝物筛选)": {
        "prefix": "acm-5.2二进制优化",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=103,M=4e4+3;",
            "int n,m,x,y,z,V,ans,v[N*17],w[N*17],dp[M];",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "int main(){",
            "\tin(m),in(V);",
            "\tmemset(dp,-127,sizeof(dp));",
            "\tdp[0]=0;",
            "\twhile(m--){",
            "\t\tin(x),in(y),in(z);Re p=1;",
            "\t\twhile(z>=p)v[++n]=y*p,w[n]=x*p,z-=p,p<<=1;",
            "\t\tif(z)v[++n]=y*z,w[n]=x*z;",
            "\t}",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=V;j>=v[i];--j)\t",
            "\t\t\tdp[j]=max(dp[j],dp[j-v[i]]+w[i]);",
            "\tfor(Re i=0;i<=V;++i)ans=max(ans,dp[i]);",
            "\tprintf(\"%d\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 多重背包  (宝物筛选)"
    },
    "完全背包": {
        "prefix": "acm-5.2货币系统",
        "body": [
            "#include<bits/stdc++.h>",
            "using namespace std;",
            "int T,n,ans,a[105],dp[30005];",
            "int main(){",
            "    scanf(\"%d\",&T);",
            "    while(T--){",
            "    \tmemset(dp,-127,sizeof(dp));",
            "    \tscanf(\"%d\",&n);dp[0]=ans=0;",
            "\t\tfor(int i=1;i<=n;i++)scanf(\"%d\",&a[i]);",
            "\t\tfor(int i=1;i<=n;i++)",
            "\t\t    for(int j=a[i];j<=25000;j++)",
            "\t\t        dp[j]=max(dp[j],dp[j-a[i]]+1);",
            "\t\tfor(int i=1;i<=n;++i)ans+=dp[a[i]]==1;",
            "\t\tprintf(\"%d\\n\",ans);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 完全背包"
    },
    "混合背包": {
        "prefix": "acm-5.2樱花",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "using namespace std;",
            "int x,a,b,c,d,T,n,i,j,t,f[1010],v[100010],w[100010];",
            "int main(){",
            "\tscanf(\"%d:%d%d:%d%d\",&a,&b,&c,&d,&n);",
            "\tT=c*60+d-a*60-b;",
            "\tfor(i=1;i<=n;i++){",
            "\t\tscanf(\"%d%d%d\",&a,&b,&c);",
            "\t\tif(!c){",
            "\t\t\tfor(j=0;j+a<=T;j++)",
            "\t\t\t\tf[j+a]=max(f[j+a],f[j]+b);",
            "\t\t\tcontinue;",
            "\t\t}",
            "\t\tx=1;",
            "\t\twhile(c>=x){v[++t]=x*a,w[t]=x*b,c-=x,x<<=1;}",
            "\t\tv[++t]=c*a,w[t]=c*b;",
            "\t}",
            "\tfor(i=1;i<=t;i++)",
            "\t\tfor(j=T;j>=v[i];j--)",
            "\t\t\tf[j]=max(f[j],f[j-v[i]]+w[i]);",
            "\tprintf(\"%d\",f[T]);",
            "\treturn 0;",
            "}",
            ""
        ],
        "description": "插入 混合背包"
    },
    "拓扑排序": {
        "prefix": "acm-3.3add",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "using namespace std;",
            "const int N=5003,M=5e5+3,inf=2e9,P=80112002;",
            "int n,m,x,y,o,ans,dp[N],ru[N],chu[N],head[N];",
            "struct QAQ{int to,next;}a[M];queue<int>Q;",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "",
            "int main(){",
            "\tin(n),in(m);",
            "\twhile(m--)in(x),in(y),add(x,y),++ru[y],++chu[x];",
            "\tfor(Re i=1;i<=n;++i)if(!ru[i])dp[i]=1,Q.push(i);",
            "\twhile(!Q.empty()){",
            "\t\tRe x=Q.front();Q.pop();",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next){",
            "\t\t\t(dp[to=a[i].to]+=dp[x])%=P;",
            "\t\t\tif(!--ru[to])Q.push(to);",
            "\t\t}",
            "\t}",
            "\tfor(Re i=1;i<=n;++i)if(!chu[i])(ans+=dp[i])%=P;",
            "\tprintf(\"%d\\n\",ans%P);",
            "}",
            ""
        ],
        "description": "插入 拓扑排序"
    },
    "斯坦纳树  (游览计划)": {
        "prefix": "acm-4.3方格图",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=12;",
            "int n,m,ct,A[N][N],B[N][N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Steiner_Tree{",
            "\tstruct PRE{int i,j,s;PRE(Re I=0,Re J=0,Re S=0){i=I,j=J,s=S;}}pre[N][N][1024+3];",
            "\tint vis[N][N],dp[N][N][1024+3],wx[4]={-1,0,1,0},wy[4]={0,1,0,-1};",
            "\tstruct QAQ{int x,y;QAQ(Re X=0,Re Y=0){x=X,y=Y;}};",
            "\tqueue<QAQ>Q;",
            "\tinline void SPFA(Re s){",
            "\t\twhile(!Q.empty()){",
            "\t\t\tQAQ now=Q.front();Q.pop();",
            "\t\t\tRe x=now.x,y=now.y;vis[x][y]=0;",
            "\t\t\tfor(Re o=0;o<4;++o){",
            "\t\t\t\tRe nx=x+wx[o],ny=y+wy[o];",
            "\t\t\t\tif(nx<1||nx>n||ny<1||ny>m)continue;",
            "\t\t\t\tif(dp[nx][ny][s]>dp[x][y][s]+B[nx][ny]){",
            "\t\t\t\t\tdp[nx][ny][s]=dp[x][y][s]+B[nx][ny],pre[nx][ny][s]=PRE(x,y,s);",
            "\t\t\t\t\tif(!vis[nx][ny])Q.push(QAQ(nx,ny)),vis[nx][ny]=1;",
            "\t\t\t\t}",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "\tint Ans[N][N];",
            "\tinline void dfs(Re i,Re j,Re s){",
            "\t\tAns[i][j]=1;PRE to=pre[i][j][s];",
            "\t\tif(to.s){",
            "\t\t\tdfs(to.i,to.j,to.s);",
            "\t\t\tif(to.i==i&&to.j==j)dfs(to.i,to.j,s^to.s);",
            "\t\t}",
            "\t}",
            "\tinline void sakura(){",
            "\t\tmemset(dp,63,sizeof(dp));",
            "\t\tRe V=(1<<ct)-1,inf=dp[0][0][0];",
            "\t\tfor(Re i=1;i<=n;++i)",
            "\t\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\t\tif(A[i][j])dp[i][j][1<<A[i][j]-1]=0;",
            "\t\tfor(Re s=0;s<=V;++s){",
            "\t\t\tfor(Re i=1;i<=n;++i)",
            "\t\t\t\tfor(Re j=1;j<=m;++j){",
            "\t\t\t\t\tfor(Re t=(s-1)&s,tmp;t;t=(t-1)&s)",
            "\t\t\t\t\t\tif((tmp=dp[i][j][t]+dp[i][j][s^t]-B[i][j])<dp[i][j][s])",
            "\t\t\t\t\t\t\tdp[i][j][s]=tmp,pre[i][j][s]=PRE(i,j,t);",
            "\t\t\t\t\tif(dp[i][j][s]!=inf)Q.push(QAQ(i,j)),vis[i][j]=1;",
            "\t\t\t\t}",
            "\t\t\tSPFA(s);",
            "\t\t}",
            "\t\tRe ans=2e9,x,y;",
            "\t\tfor(Re i=1;i<=n;++i)",
            "\t\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\t\tif(A[i][j])ans=dp[x=i][y=j][V];",
            "\t\tprintf(\"%d\\n\",ans);",
            "\t\tdfs(x,y,V);",
            "\t\tfor(Re i=1;i<=n;puts(\"\"),++i)",
            "\t\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\t\tputchar(A[i][j]?'x':(Ans[i][j]?'o':'_'));",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m);",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=m;++j){",
            "\t\t\tin(B[i][j]);",
            "\t\t\tif(!B[i][j])A[i][j]=++ct;",
            "\t\t}",
            "\tT1.sakura();",
            "}",
            ""
        ],
        "description": "插入 斯坦纳树  (游览计划)"
    },
    "斯坦纳树": {
        "prefix": "acm-4.3普通无向图",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=103,M=503;",
            "int n,m,o,x,y,z,K,ans,pan[N],head[N],dp[N][1024+3];queue<int>Q;",
            "struct QAQ{int w,to,next;}a[M<<1];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void SPFA(Re s){",
            "\twhile(!Q.empty()){",
            "\t\tRe x=Q.front();Q.pop();pan[x]=0;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(dp[x][s]+a[i].w<dp[to=a[i].to][s]){",
            "\t\t\t\tdp[to][s]=dp[x][s]+a[i].w;",
            "\t\t\t\tif(!pan[to])Q.push(to),pan[to]=1;",
            "\t\t\t}",
            "\t}",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),in(K);",
            "\twhile(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);",
            "\tmemset(dp,63,sizeof(dp));Re inf=dp[0][0];",
            "\tfor(Re i=1;i<=K;++i)in(x),dp[x][1<<i-1]=0,ans=x;",
            "\tRe V=(1<<K)-1;",
            "\tfor(Re s=0;s<=V;++s){",
            "\t\tfor(Re i=1;i<=n;++i){",
            "\t\t\tfor(Re t=(s-1)&s;t;t=(t-1)&s)",
            "\t\t\t\tdp[i][s]=min(dp[i][s],dp[i][t]+dp[i][s^t]);",
            "\t\t\tif(dp[i][s]!=inf)Q.push(i),pan[i]=1;",
            "\t\t}",
            "\t\tSPFA(s);",
            "\t}",
            "\tprintf(\"%d \",dp[ans][V]);",
            "}",
            ""
        ],
        "description": "插入 斯坦纳树"
    },
    "二分图—最大匹配": {
        "prefix": "acm-3.4add",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "const int N=1003;",
            "int o,n,m,e,x,y,ans,pan[N],head[N],match[N];",
            "struct QAQ{int to,next;}a[N*N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline int dfs(Re x){",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!pan[to=a[i].to]){",
            "\t\t\tpan[to]=1;",
            "\t\t\tif(!match[to]||dfs(match[to])){",
            "\t\t\t\tmatch[to]=x;return 1;",
            "\t\t\t}",
            "\t\t}",
            "\treturn 0;",
            "}",
            "int main(){",
            "\tin(n),in(m),in(e);",
            "\twhile(e--){",
            "\t\tin(x),in(y);",
            "\t\tif(x<=n&&y<=m)add(x,y);",
            "\t}",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tmemset(pan,0,sizeof(pan));",
            "\t\tans+=dfs(i);",
            "\t}",
            "\tprintf(\"%d\",ans);",
            "}",
            ""
        ],
        "description": "插入 二分图—最大匹配"
    },
    "二分图判定": {
        "prefix": "acm-3.4染色法",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=2003,M=1e6+3;",
            "int n,m,x,y,h,t,o,T,O,Q[N],head[N],color[N];",
            "struct QAQ{int to,next;}a[M<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int judge(){",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tif(!color[i]){",
            "\t\t\th=1,t=0,Q[++t]=i,color[i]=1;",
            "\t\t\twhile(h<=t){",
            "\t\t\t\tRe x=Q[h++];",
            "\t\t\t\tfor(Re j=head[x],to;j;j=a[j].next)",
            "\t\t\t\t\tif(!color[to=a[j].to])color[to]=3-color[x],Q[++t]=to;",
            "\t\t\t\t\telse if(color[to]==color[x])return 0;",
            "\t\t\t}",
            "\t\t}",
            "\treturn 1;",
            "}",
            "int main(){",
            "\tin(T);",
            "\twhile(T--){",
            "\t\tmemset(color,0,sizeof(color));",
            "\t\tmemset(head,0,sizeof(head));",
            "\t\tin(n),in(m),o=0;",
            "\t\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\t\tprintf(\"Scenario #%d:\\n\",++O);",
            "\t\tputs(judge()?\"No suspicious bugs found!\\n\":\"Suspicious bugs found!\\n\");",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 二分图判定"
    },
    "2-SAT": {
        "prefix": "acm-3.3tarjan",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "const int N=2e6+3,M=2e6+3;",
            "int n,m,p1,p2,x1,x2,Q_o,ip[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Tarjan{",
            "\tint o,t,dfn_o,Q[N],low[N],dfn[N],pan[N],head[N];",
            "\tstruct QAQ{int to,next;}a[M];",
            "\tinline int min(Re a,Re b){return a<b?a:b;}",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void tarjan(Re x){",
            "\t\tlow[x]=dfn[x]=++dfn_o,Q[++t]=x,pan[x]=1;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(!dfn[to=a[i].to])tarjan(to),low[x]=min(low[x],low[to]);",
            "\t\t\telse if(pan[to])low[x]=min(low[x],dfn[to]);",
            "\t\tif(low[x]==dfn[x]){",
            "\t\t\t++Q_o;",
            "\t\t\twhile(1){",
            "\t\t\t\tip[Q[t]]=Q_o,pan[Q[t]]=0;",
            "\t\t\t\tif(x==Q[t--])break;",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "\tinline void SuoPoint(){for(Re i=1;i<=2*n;++i)if(!dfn[i])tarjan(i);}",
            "}T1;",
            "int main(){",
            "\tin(n),in(m);",
            "\twhile(m--)in(p1),in(x1),in(p2),in(x2),T1.add(p1+(x1^1)*n,p2+x2*n),T1.add(p2+(x2^1)*n,p1+x1*n);",
            "\tT1.SuoPoint();",
            "\tfor(Re i=1;i<=n;++i)if(ip[i]==ip[i+n])return !printf(\"IMPOSSIBLE\");",
            "\tputs(\"POSSIBLE\");",
            "\tfor(Re i=1;i<=n;++i)printf(\"%d \",ip[i]>ip[i+n]);",
            "}"
        ],
        "description": "插入 2-SAT"
    },
    "割点 tanjan": {
        "prefix": "acm-3.3min",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "const int N=2e4+3,M=2e5+3;",
            "int n,m,x,y,ans,cut[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Cut_Point{",
            "\tint o,dfn_o,low[N],dfn[N],head[N];",
            "\tstruct QAQ{int to,next;}a[M];",
            "\tinline int min(Re a,Re b){return a<b?a:b;}",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void tarjan(Re x,Re root){",
            "\t\tRe son=0;dfn[x]=low[x]=++dfn_o;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(!dfn[to=a[i].to]){",
            "\t\t\t\ttarjan(to,root),++son;",
            "\t\t\t\tlow[x]=min(low[x],low[to]);",
            "\t\t\t\tcut[x]|=(x!=root&&low[to]>=dfn[x]);",
            "\t\t\t}",
            "\t\t\telse low[x]=min(low[x],dfn[to]);",
            "\t\tcut[x]|=(x==root&&son>1),ans+=cut[x];",
            "\t}",
            "\tinline void cut_point(){",
            "\t\tfor(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i,i);",
            "\t}",
            "}T1;",
            "int main(){",
            "\tin(n),in(m);",
            "\twhile(m--)in(x),in(y),T1.add(x,y),T1.add(y,x);",
            "\tT1.cut_point();",
            "\tprintf(\"%d\\n\",ans);",
            "\tfor(Re i=1;i<=n;++i)if(cut[i])printf(\"%d \",i);",
            "}"
        ],
        "description": "插入 割点 tanjan"
    },
    "割边,桥": {
        "prefix": "acm-3.3旅游航道",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=3e4+3,M=3e4+3;",
            "int n,m,x,y,ans;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Tarjan{",
            "\tint o,dfn_o,dfn[N],low[N],head[N],bridge[M<<1];",
            "\tstruct QAQ{int to,next;}a[M<<1];",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void CL(){",
            "\t\tmemset(bridge,0,sizeof(bridge));",
            "\t\tmemset(head,0,sizeof(head));",
            "\t\tmemset(low,0,sizeof(low));",
            "\t\tmemset(dfn,0,sizeof(dfn));",
            "\t\tdfn_o=ans=0,o=1;",
            "\t}",
            "\tinline void tarjan(Re x,Re p){",
            "\t\tdfn[x]=low[x]=++dfn_o;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(!dfn[to=a[i].to]){",
            "\t\t\t\ttarjan(to,i);",
            "\t\t\t\tlow[x]=min(low[x],low[to]);",
            "\t\t\t\tif(low[to]>dfn[x])bridge[i]=bridge[i^1]=1,++ans;",
            "\t\t\t}",
            "\t\t\telse if(i!=(p^1))low[x]=min(low[x],dfn[to]);",
            "\t}",
            "\tinline void get_bridg(){for(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i,-1);}",
            "}T1;",
            "int main(){",
            "    while(scanf(\"%d%d\",&n,&m)&&n&&m){",
            "\t    T1.CL();",
            "\t    while(m--)in(x),in(y),T1.add(x,y),T1.add(y,x);",
            "\t    T1.get_bridg();",
            "\t    printf(\"%d\\n\",ans);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 割边,桥"
    },
    "欧拉回路  (Hierholzer)": {
        "prefix": "acm-3.3无向+有向",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "const int N=1e5+3,M=2e5+3;",
            "int n,m,x,y,m_,op;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Euler_Circle__Undirected_Graph{// 无向图欧拉路",
            "\tint o,du[N],cur[N],ans[M],pan[M<<1],head[N];",
            "\tstruct QAQ{int to,next;}a[M<<1];",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void dfs(Re x){",
            "\t\tfor(Re i=head[x];i;i=head[x]){",
            "\t\t\thead[x]=a[i].next;// 当前弧优化",
            "\t\t\tif(!pan[i]){",
            "\t\t\t\tpan[i]=pan[i^1]=1;",
            "\t\t\t\tdfs(a[i].to);",
            "\t\t\t\tans[++ans[0]]=(i&1)?-i/2:i/2;",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "\tinline void sakura(){",
            "\t\tin(n),in(m),m_=m,o=1;",
            "\t\twhile(m_--)in(x),in(y),add(x,y),add(y,x),++du[x],++du[y];",
            "\t\tfor(Re i=1;i<=n;cur[i]=head[i],++i)if(du[i]&1){puts(\"NO\");return;}",
            "\t\tfor(Re i=1;i<=n;++i)if(du[i]){dfs(i);break;}",
            "\t\tif(ans[0]!=m){puts(\"NO\");return;}",
            "\t\tputs(\"YES\");",
            "\t\tfor(Re i=ans[0];i>=1;--i)printf(\"%d \",ans[i]);",
            "\t}",
            "}T1;",
            "struct Euler_Circle__Directed_Graph{// 无向图欧拉路",
            "\tint o,ru[N],chu[N],cur[N],ans[M],head[N];",
            "\tstruct QAQ{int to,next;}a[M<<1];",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void dfs(Re x){",
            "\t\tfor(Re i=head[x];i;i=head[x]){",
            "\t\t\thead[x]=a[i].next;// 当前弧优化",
            "\t\t\tdfs(a[i].to);",
            "\t\t\tans[++ans[0]]=i;",
            "\t\t}",
            "\t}",
            "\tinline void sakura(){",
            "\t\tin(n),in(m),m_=m;",
            "\t\twhile(m_--)in(x),in(y),add(x,y),++ru[y],++chu[x];",
            "\t\tfor(Re i=1;i<=n;cur[i]=head[i],++i)if(ru[i]!=chu[i]){puts(\"NO\");return;}",
            "\t\tfor(Re i=1;i<=n;++i)if(chu[i]){dfs(i);break;}",
            "\t\tif(ans[0]!=m){puts(\"NO\");return;}",
            "\t\tputs(\"YES\");",
            "\t\tfor(Re i=ans[0];i>=1;--i)printf(\"%d \",ans[i]);",
            "\t}",
            "}T2;",
            "int main(){",
            "\tin(op);",
            "\tif(op==1)T1.sakura();",
            "\tif(op==2)T2.sakura();",
            "}",
            ""
        ],
        "description": "插入 欧拉回路  (Hierholzer)"
    },
    "欧拉路,欧拉回路": {
        "prefix": "acm-3.3骑马修栅栏",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=1030;",
            "int n,x,y,mi=2e9,st=2e9,as,du[N],ans[N],r[N][N];",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "inline void dfs(Re x){",
            "\tfor(Re i=1;i<=500;++i)",
            "\t\tif(r[x][i]){",
            "\t\t\t--r[x][i],--r[i][x];",
            "\t\t\tdfs(i);",
            "\t\t}",
            "\tans[++as]=x;",
            "}",
            "int main(){",
            "\tin(n);",
            "\tfor(Re i=1;i<=n;++i)in(x),in(y),++r[x][y],++r[y][x],++du[x],++du[y],mi=min(mi,min(x,y));",
            "\tfor(Re i=1;i<=500;++i)if(du[i]&1)st=min(st,i);",
            "\tif(st==2e9)st=mi;",
            "\tdfs(st);",
            "\tfor(Re i=as;i;--i)printf(\"%d\\n\",ans[i]);",
            "}",
            ""
        ],
        "description": "插入 欧拉路,欧拉回路"
    },
    "缩点—强联通分量": {
        "prefix": "acm-3.3Tarjan",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "const int N=1e4+3,M=1e5+3;",
            "int n,m,x,y,Q_o,ans,A[N],ru[N],gs[N],ip[N],dp[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int min(Re a,Re b){return a<b?a:b;}",
            "inline int max(Re a,Re b){return a>b?a:b;}",
            "struct Tarjan{",
            "\tint o,t,dfn_o,Q[N],low[N],dfn[N],pan[N],head[N];",
            "\tstruct QAQ{int x,to,next;}a[M];",
            "\tinline void add(Re x,Re y){a[++o].x=x,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void tarjan(Re x){",
            "\t\tdfn[x]=low[x]=++dfn_o,Q[++t]=x,pan[x]=1;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(!dfn[to=a[i].to])tarjan(to),low[x]=min(low[x],low[to]);",
            "\t\t\telse if(pan[to])low[x]=min(low[x],dfn[to]);",
            "\t\tif(low[x]==dfn[x]){",
            "\t\t\t++Q_o;",
            "\t\t\twhile(1){",
            "\t\t\t\tip[Q[t]]=Q_o,gs[Q_o]+=A[Q[t]],pan[Q[t]]=0;",
            "\t\t\t\tif(x==Q[t--])break;",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "\tinline void SuoPoint(){for(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i);}",
            "}T1;",
            "struct Tuopu{",
            "\tint o,ru[N],pan[N],head[N];std::queue<int>Q;",
            "\tstruct QAQ{int to,next;}a[M<<1];",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void creat(){",
            "\t\tfor(Re i=1;i<=T1.o;++i)",
            "\t\t\tif((x=ip[T1.a[i].x])!=(y=ip[T1.a[i].to]))",
            "\t\t\t\t++ru[y],add(x,y);",
            "\t}",
            "\tinline void tuopu(){",
            "\t\tfor(Re i=1;i<=Q_o;++i)if(!ru[i])dp[i]=gs[i],Q.push(i);",
            "\t\twhile(!Q.empty()){",
            "\t\t\tRe x=Q.front();Q.pop();",
            "\t\t\tfor(Re i=head[x],to;i;i=a[i].next){",
            "\t\t\t\tto=a[i].to;",
            "\t\t\t\tdp[to]=max(dp[to],dp[x]+gs[to]);",
            "\t\t\t\tif(!(--ru[to]))Q.push(to);",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "}T2;",
            "int main(){",
            "\tin(n),in(m);",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\twhile(m--)in(x),in(y),T1.add(x,y);",
            "\tT1.SuoPoint(),T2.creat(),T2.tuopu();",
            "\tfor(Re i=1;i<=Q_o;++i)ans=max(ans,dp[i]);",
            "\tprintf(\"%d\",ans);",
            "}",
            ""
        ],
        "description": "插入 缩点—强联通分量"
    },
    "缩点—点双连通分量": {
        "prefix": "acm-3.3矿场搭建",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<vector>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1003,M=503;",
            "int n,m,x,y,T,Q_o,tmp,ans1,cut[N];LL ans2;",
            "std::vector<int>dcc[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int max(Re a,Re b){return a>b?a:b;}",
            "struct Tarjan{",
            "\tint o,t,dfn_o,Q[N],dfn[N],low[N],head[N];",
            "\tstruct QAQ{int to,next;}a[M<<1];",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void CL(){",
            "\t\tmemset(head,0,sizeof(head));",
            "\t\tmemset(low,0,sizeof(low));",
            "\t\tmemset(dfn,0,sizeof(dfn));",
            "\t\tmemset(cut,0,sizeof(cut));",
            "\t\tdfn_o=t=o=0;",
            "\t}",
            "\tinline void tarjan(Re x,Re rt){",
            "\t\tRe son=0;Q[++t]=x,dfn[x]=low[x]=++dfn_o;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(!dfn[to=a[i].to]){",
            "\t\t\t\ttarjan(to,rt),++son;",
            "\t\t\t\tlow[x]=min(low[x],low[to]);",
            "\t\t\t\tif(low[to]>=dfn[x]){",
            "\t\t\t\t\tif(x!=rt)cut[x]=1;",
            "\t\t\t\t\telse cut[x]|=son>1;",
            "\t\t\t\t\t++Q_o;",
            "\t\t\t\t\twhile(1){",
            "\t\t\t\t\t\tdcc[Q_o].push_back(Q[t]);",
            "\t\t\t\t\t\tif(to==Q[t--])break;",
            "\t\t\t\t\t}",
            "\t\t\t\t\tdcc[Q_o].push_back(x);",
            "\t\t\t\t}",
            "\t\t\t}",
            "\t\t\telse low[x]=min(low[x],dfn[to]);",
            "\t}",
            "\tinline void SuoPoint(){for(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i,i);}",
            "}T1;",
            "int main(){",
            "    while(scanf(\"%d\",&m)&&m){",
            "\t    for(Re i=1;i<=Q_o;++i)dcc[i].clear();",
            "\t    T1.CL(),Q_o=ans1=n=0,ans2=1;",
            "\t    while(m--)in(x),in(y),T1.add(x,y),T1.add(y,x),n=max(n,max(x,y));",
            "\t    T1.SuoPoint();",
            "\t    for(Re i=1;i<=Q_o;++i){",
            "\t    \ttmp=0,n=dcc[i].size();",
            "\t    \tfor(Re j=0;j<n;++j)tmp+=cut[dcc[i][j]];",
            "\t    \tif(!tmp)ans1+=2,ans2*=(n-1)*n/2;",
            "\t    \telse if(tmp<2)ans1+=1,ans2*=(n-1);",
            "\t    }",
            "\t    printf(\"Case %d: %d %lld\\n\",++T,ans1,ans2);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 缩点—点双连通分量"
    },
    "缩点—边双连通分量": {
        "prefix": "acm-3.3Redundant Paths",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=5003,M=10003;",
            "int n,m,x,y,Q_o,leaf,ip[N],du[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Tarjan{",
            "\tint o,dfn_o,dfn[N],low[N],head[N],bridge[M<<1];",
            "\tstruct QAQ{int to,next;}a[M<<1];",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void tarjan(Re x,Re p){",
            "\t\tdfn[x]=low[x]=++dfn_o;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(!dfn[to=a[i].to]){",
            "\t\t\t\ttarjan(to,i);",
            "\t\t\t\tlow[x]=min(low[x],low[to]);",
            "\t\t\t\tif(low[to]>dfn[x])bridge[i]=bridge[i^1]=1;",
            "\t\t\t}",
            "\t\t\telse if(i!=(p^1))low[x]=min(low[x],dfn[to]);",
            "\t}",
            "\tinline void dfs(Re x){",
            "\t\tip[x]=Q_o;",
            "\t\tfor(Re i=head[x];i;i=a[i].next)",
            "\t\t\tif(!ip[a[i].to]&&!bridge[i])dfs(a[i].to);",
            "\t}",
            "\tinline void SuoPoint(){",
            "\t\tfor(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i,-1);",
            "\t\tfor(Re i=1;i<=n;++i)if(!ip[i])++Q_o,dfs(i);",
            "\t}",
            "}T1;",
            "int main(){",
            "    in(n),in(m),T1.o=1;",
            "    while(m--)in(x),in(y),T1.add(x,y),T1.add(y,x);",
            "    T1.SuoPoint();",
            "    for(Re i=2;i<=T1.o;i+=2)",
            "    \tif((x=ip[T1.a[i].to])!=(y=ip[T1.a[i^1].to]))++du[x],++du[y];",
            "    for(Re i=1;i<=Q_o;++i)leaf+=(du[i]==1);",
            "    printf(\"%d\",leaf+1>>1);",
            "}",
            ""
        ],
        "description": "插入 缩点—边双连通分量"
    },
    "严格次小生成树": {
        "prefix": "acm-3.2add",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e5+3,M=5e5+3,logN=19,inf=2e9;",
            "int T,n,m,o,root,fa[N],head[N],Tree[M],M1[N][23],M2[N][23];LL MinTree;",
            "struct QAQ{int w,to,next;}a[M<<1];",
            "struct QWQ{int x,y,w;inline bool operator<(QWQ O)const{return w<O.w;}}A[M];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "struct LCA{",
            "\tint deep[N],ant[N][23];",
            "\tinline void dfs(Re x,Re fa){",
            "\t\tdeep[x]=deep[fa]+1,ant[x][0]=fa;",
            "\t\tfor(Re i=1;(1<<i)<=deep[x];++i){",
            "\t\t\tant[x][i]=ant[ant[x][i-1]][i-1];",
            "\t\t\tM1[x][i]=max(M1[x][i-1],M1[ant[x][i-1]][i-1]);",
            "\t\t\tM2[x][i]=max(M2[x][i-1],M2[ant[x][i-1]][i-1]);",
            "\t\t\tif(M1[x][i-1]!=M1[ant[x][i-1]][i-1])",
            "\t\t\t\tM2[x][i]=max(M2[x][i],min(M1[x][i-1],M1[ant[x][i-1]][i-1]));",
            "\t\t}",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=fa)M1[to][0]=a[i].w,M2[to][0]=-inf,dfs(to,x);",
            "\t}",
            "\tinline int lca(Re x,Re y){",
            "\t\tif(deep[x]>deep[y])swap(x,y);",
            "\t\tfor(Re i=logN;i>=0;--i)if(deep[x]<=deep[y]-(1<<i))y=ant[y][i];",
            "\t\tif(x==y)return y;",
            "\t\tfor(Re i=logN;i>=0;--i)",
            "\t\t\tif(ant[x][i]^ant[y][i])x=ant[x][i],y=ant[y][i];",
            "\t\treturn ant[x][0];",
            "\t}",
            "\tinline int ask_max(Re x,Re Ant,Re w){",
            "\t\tRe ans=-inf;",
            "\t\tfor(Re i=logN;i>=0;--i)",
            "\t\t\tif(deep[ant[x][i]]>=deep[Ant]){",
            "\t\t\t\tif(w!=M1[x][i])ans=max(ans,M1[x][i]);",
            "\t\t\t\telse ans=max(ans,M2[x][i]);",
            "\t\t\t\tx=ant[x][i];",
            "\t\t\t}",
            "\t\treturn ans;",
            "\t}",
            "}T1;",
            "inline int find(Re x){return x==fa[x]?x:fa[x]=find(fa[x]);}",
            "inline void kruscal(){",
            "\tsort(A+1,A+m+1);",
            "\tfor(Re i=1;i<=n;++i)fa[i]=i;",
            "\tfor(Re i=1;i<=m;++i){",
            "\t\tRe x=A[i].x,y=A[i].y,w=A[i].w;",
            "\t\tif(find(x)!=find(y)){",
            "\t\t\tMinTree+=w,Tree[i]=1;",
            "\t\t\tadd(x,y,w),add(y,x,w);",
            "\t\t\tfa[find(x)]=find(y);",
            "\t\t}",
            "\t}",
            "}",
            "int main(){",
            "\tin(n),in(m),root=1;",
            "\tfor(Re i=1;i<=m;++i)in(A[i].x),in(A[i].y),in(A[i].w);",
            "\tkruscal();",
            "\tM1[root][0]=0,M2[root][0]=-inf,T1.dfs(root,0);",
            "\tLL ans=1e17;",
            "\tfor(Re i=1;i<=m;++i)",
            "\t\tif(!Tree[i]){",
            "\t\t\tRe x=A[i].x,y=A[i].y,w=A[i].w;",
            "\t\t\tRe lca=T1.lca(x,y);",
            "\t\t\tans=min(ans,MinTree+w-max(T1.ask_max(x,lca,w),T1.ask_max(y,lca,w)));",
            "\t\t}",
            "\tprintf(\"%lld\",ans);",
            "}",
            ""
        ],
        "description": "插入 严格次小生成树"
    },
    "曼哈顿距离最小生成树": {
        "prefix": "acm-3.2Object Clustering",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "using namespace std;",
            "const LL N=1e4+3;",
            "inline void in(Re &x){",
            "\tint f=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=f?-x:x;",
            "}",
            "LL n,m,x,y,t,K,Ans,b[N];",
            "struct QAQ{LL x,y,v;inline bool operator<(const QAQ &O)const{return v<O.v;}}a[N<<3];",
            "struct Point{LL x,y,id;inline bool operator<(const Point &O)const{return x!=O.x?x<O.x:y<O.y;}}P[N];",
            "inline LL Abs(LL a){return a<0?-a:a;}",
            "inline LL Dis(Re x,Re y){return Abs(P[x].x-P[y].x)+Abs(P[x].y-P[y].y);}",
            "struct BIT{",
            "\tLL n,C[N],id[N];",
            "\tinline void CL(){memset(C,127,sizeof(C));}",
            "\tinline void add(Re x,Re v,Re ID){while(x){if(v<C[x])C[x]=v,id[x]=ID;x-=x&-x;}}",
            "\tinline LL ask(Re x){Re Min=1e18,ID=0;while(x<=n){if(C[x]<Min)Min=C[x],ID=id[x];x+=x&-x;}return ID;}",
            "}TR;",
            "inline LL find_(Re x){",
            "\tRe l=1,r=t;",
            "\twhile(l<r){",
            "\t\tRe mid=(l+r+1)>>1;",
            "\t\tif(b[mid]<=x)l=mid;",
            "\t\telse r=mid-1;",
            "\t}",
            "\treturn l;",
            "}",
            "LL fa[N];",
            "inline LL find(Re x){return fa[x]==x?x:fa[x]=find(fa[x]);}",
            "inline void kruscal(){",
            "\tfor(Re O=1;O<=4;++O){",
            "\t\tif(!(O&1))for(Re i=1;i<=n;++i)swap(P[i].x,P[i].y);",
            "\t\telse if(O==3)for(Re i=1;i<=n;++i)P[i].x*=-1;",
            "\t\tsort(P+1,P+n+1);",
            "\t\tfor(Re i=1;i<=n;++i)b[i]=P[i].y-P[i].x;",
            "\t\tsort(b+1,b+n+1),t=unique(b+1,b+n+1)-b-1;",
            "\t\tTR.n=t,TR.CL();",
            "\t\tfor(Re i=n;i>=1;--i){",
            "\t\t\tRe I=find_(P[i].y-P[i].x),j=TR.ask(I);",
            "\t\t\tif(j)a[++m]=(QAQ){P[i].id,P[j].id,Dis(i,j)};",
            "\t\t\tTR.add(I,P[i].x+P[i].y,i);",
            "\t\t}",
            "\t}",
            "\tsort(a+1,a+m+1);",
            "\tfor(Re i=1;i<=n;++i)fa[i]=i;",
            "\tfor(Re i=1,t=0;i<=m&&t<n-1;++i)if((x=find(a[i].x))!=(y=find(a[i].y))){",
            "\t\tfa[x]=y,Ans+=a[i].v;",
            "\t\tif(++t==K)printf(\"%lld\\n\",a[i].v);",
            "\t}",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(K),K=n-1-K+1;",
            "\tfor(Re i=1;i<=n;++i)in(P[i].x),in(P[i].y),P[i].id=i;",
            "\tkruscal();",
            "}",
            ""
        ],
        "description": "插入 曼哈顿距离最小生成树"
    },
    "最小生成树": {
        "prefix": "acm-3.2Prim",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "using namespace std;",
            "const int N=5003,M=2e5+3,inf=2e9;",
            "int x,y,z,n,m,o,ans,pan[N],dis[N],head[N];",
            "struct QAQ{int w,to,next;}a[M<<1];",
            "struct QWQ{int x,d;inline bool operator<(QWQ o)const{return d>o.d;};};",
            "priority_queue<QWQ>Q;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void Prim(){",
            "\tfor(Re i=0;i<=n;++i)pan[i]=0,dis[i]=inf;",
            "\tRe t=0;Q.push((QWQ){1,dis[1]=0});",
            "\twhile(!Q.empty()&t<n){",
            "\t\tRe x=Q.top().x;Q.pop();",
            "\t\tif(pan[x])continue;",
            "\t\tpan[x]=1,++t,ans+=dis[x];",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(dis[to=a[i].to]>a[i].w)Q.push((QWQ){to,dis[to]=a[i].w});",
            "\t}",
            "}",
            "int main(){",
            "\tin(n),in(m);",
            "\twhile(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);",
            "\tPrim();",
            "\tprintf(\"%d\",ans);",
            "}",
            ""
        ],
        "description": "插入 最小生成树"
    },
    "dijkstra  (信使)": {
        "prefix": "acm-3.1n^2",
        "body": [
            "#include<bits/stdc++.h>",
            "using namespace std;",
            "int i,j,ans,a,b,z,n,m,pan[110],w,mi,f[110][110],dis[110];",
            "int main(){",
            "    scanf(\"%d%d\",&n,&m);",
            "    for(i=1;i<=n;i++)",
            "        for(j=1;j<=n;j++)",
            "            f[i][j]=0xfffffff;",
            "    for(i=1;i<=n;i++)dis[i]=0xfffffff;",
            "    for(i=1;i<=m;i++){",
            "        scanf(\"%d%d%d\",&a,&b,&z);",
            "        f[a][b]=f[b][a]=z;",
            "    }",
            "    for(i=1;i<=n;i++)dis[i]=f[1][i];",
            "    dis[1]=0;pan[1]=1;",
            "    for(i=1;i<=n;i++){",
            "        w=0;mi=0xfffffff;",
            "        for(j=1;j<=n;j++)if(!pan[j]&&dis[j]<mi)mi=dis[w=j];",
            "        if(!w)break;pan[w]=1;",
            "        for(j=1;j<=n;j++)dis[j]=min(dis[j],dis[w]+f[w][j]);",
            "    }",
            "    for(i=1;i<=n;i++)ans=max(ans,dis[i]);",
            "    if(ans==0xfffffff)printf(\"-1\");",
            "    else printf(\"%d\",ans);",
            "    return 0;",
            "}",
            ""
        ],
        "description": "插入 dijkstra  (信使)"
    },
    "最小环  (Sightseeing Trip)": {
        "prefix": "acm-3.1Floyed",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=103,inf=1e8;",
            "int n,m,x,y,z,ans,Ans[N],a[N][N],g[N][N],dis[N][N];",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "inline void get(Re i,Re j){",
            "\tRe k=g[i][j];if(!k)return;",
            "\tget(i,k),Ans[++Ans[0]]=k,get(k,j);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m);",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=n;++j)",
            "\t\t\tdis[i][j]=a[i][j]=inf;",
            "\tfor(Re i=1;i<=n;++i)dis[i][i]=a[i][i]=0;",
            "\twhile(m--)in(x),in(y),in(z),dis[x][y]=dis[y][x]=a[x][y]=a[y][x]=min(a[x][y],z);",
            "\tans=inf;",
            "\tfor(Re k=1;k<=n;++k){",
            "\t\tfor(Re i=1;i<k;++i)",
            "\t\t\tfor(Re j=i+1,tmp;j<k;++j)\t",
            "\t\t\t\tif((tmp=dis[i][j]+a[j][k]+a[k][i])<ans){",
            "\t\t\t\t\tans=tmp,Ans[0]=0;",
            "\t\t\t\t\tAns[++Ans[0]]=i;",
            "\t\t\t\t\tget(i,j);",
            "\t\t\t\t\tAns[++Ans[0]]=j;",
            "\t\t\t\t\tAns[++Ans[0]]=k;",
            "\t\t\t\t}",
            "\t\tfor(Re i=1;i<=n;++i)",
            "\t\t\tfor(Re j=1,tmp;j<=n;++j)",
            "\t\t\t\tif((tmp=dis[i][k]+dis[k][j])<dis[i][j])\t",
            "\t\t\t\t\tdis[i][j]=tmp,g[i][j]=k;",
            "\t}",
            "\tif(ans==inf)puts(\"No solution.\");",
            "\telse for(Re i=1;i<=Ans[0];++i)printf(\"%d \",Ans[i]); ",
            "}",
            ""
        ],
        "description": "插入 最小环  (Sightseeing Trip)"
    },
    "最短路": {
        "prefix": "acm-3.1SPFA",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e4+5,M=5e5+5,inf=2147483647;",
            "int x,y,z,n,m,o,to,st,dis[N],pan[N],head[N];",
            "struct QAQ{int w,to,next;}a[M<<1];",
            "queue<int>Q;",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z){a[++o].to=y,a[o].w=z,a[o].next=head[x],head[x]=o;}",
            "inline void SPFA(Re st){",
            "\tfor(Re i=0;i<=n;++i)dis[i]=inf;",
            "\tdis[st]=0,pan[st]=1,Q.push(st);",
            "\twhile(!Q.empty()){",
            "\t\tx=Q.front(),Q.pop();",
            "\t\tpan[x]=0;",
            "\t\tfor(Re i=head[x];i;i=a[i].next)",
            "\t\t\tif(dis[to=a[i].to]>dis[x]+a[i].w){",
            "\t\t\t\tdis[to]=dis[x]+a[i].w;",
            "\t\t\t\tif(!pan[to])pan[to]=1,Q.push(to);",
            "\t\t\t}",
            "\t}",
            "}",
            "int main(){",
            "\tin(n),in(m),in(st);",
            "\twhile(m--)in(x),in(y),in(z),add(x,y,z);",
            "\tSPFA(st);",
            "\tfor(Re i=1;i<=n;++i)printf(\"%d \",dis[i]);",
            "}",
            ""
        ],
        "description": "插入 最短路"
    },
    "次短路": {
        "prefix": "acm-3.1SPFA",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "using namespace std;",
            "const int N=5003,M=1e5+3,inf=1e9;",
            "int n,m,x,y,z,o,pan[N],head[N],dis[N][2];",
            "struct QAQ{int w,to,next;}a[M<<1];queue<int>Q;",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    Re fu=0;x=0;char ch=getchar();",
            "    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void SPFA(Re st){",
            "    for(Re i=0;i<=n;++i)dis[i][0]=dis[i][1]=inf;",
            "    dis[st][0]=0,pan[st]=1,Q.push(st);",
            "    while(!Q.empty()){",
            "        Re x=Q.front();Q.pop();pan[x]=0;",
            "        for(Re i=head[x],to,tmp;i;i=a[i].next){",
            "            if(dis[to=a[i].to][0]>(tmp=dis[x][0]+a[i].w)){",
            "                dis[to][1]=dis[to][0];",
            "                dis[to][0]=tmp;",
            "                if(!pan[to])pan[to]=1,Q.push(to);",
            "            }",
            "            if(dis[to][1]>(tmp=dis[x][0]+a[i].w)&&tmp>dis[to][0]){",
            "                dis[to][1]=tmp;",
            "                if(!pan[to])pan[to]=1,Q.push(to);",
            "            }",
            "            if(dis[to][1]>(tmp=dis[x][1]+a[i].w)){",
            "                dis[to][1]=tmp;",
            "                if(!pan[to])pan[to]=1,Q.push(to);",
            "            }",
            "        }",
            "    }",
            "}",
            "int main(){",
            "    in(n),in(m);",
            "    while(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);",
            "    SPFA(1);",
            "    printf(\"%d\\n\",dis[n][1]);",
            "}",
            ""
        ],
        "description": "插入 次短路"
    },
    "DFS序+分治": {
        "prefix": "acm-4.3Lomsat gelral",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "int o,n,m,x,y,t,tmp,dfn_O,A[N],Q[N],cnt[N],dfn[N],idx[N],size[N],head[N];LL ans,Ans[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void dfs(Re x,Re fa){",
            "    idx[dfn[x]=++dfn_O]=x,size[x]=1;",
            "    for(Re i=head[x],to;i;i=a[i].next)",
            "        if((to=a[i].to)!=fa)dfs(to,x),size[x]+=size[to];",
            "}",
            "inline void CL(){",
            "    while(t)cnt[Q[t--]]=0;ans=tmp=0;",
            "}",
            "inline void insert(Re x){",
            "    ++cnt[Q[++t]=A[x]];",
            "    if(cnt[A[x]]>tmp)tmp=cnt[ans=A[x]];",
            "    else if(cnt[A[x]]==tmp)ans+=A[x];",
            "}",
            "inline void sakura(Re L,Re R){",
            "    if(L==R){if(size[idx[L]]==1)Ans[idx[L]]=A[idx[L]];return;}",
            "    Re mid=L+R>>1;",
            "    sakura(L,mid),sakura(mid+1,R);",
            "    Re p=mid;CL();",
            "    for(Re i=mid,j;i>=L&&(j=i+size[idx[i]]-1)<=R;--i){",
            "        insert(idx[i]);",
            "        if(j<=mid)continue;",
            "        while(p<j)insert(idx[++p]);",
            "        Ans[idx[i]]=ans;",
            "    }",
            "}",
            "int main(){",
            "//  freopen(\"123.txt\",\"r\",stdin);",
            "    in(n),m=n-1;",
            "    for(Re i=1;i<=n;++i)in(A[i]);",
            "    while(m--)in(x),in(y),add(x,y),add(y,x);",
            "    dfs(1,0),sakura(1,n);",
            "    for(Re i=1;i<=n;++i)printf(\"%lld \",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 DFS序+分治"
    },
    "Dsu on tree": {
        "prefix": "acm-4.3Lomsat gelral",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "int o,n,m,x,y,t,K,tmp,A[N],Q[N],cnt[N],son[N],size[N],head[N];LL ans,Ans[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void dfs(Re x,Re fa){",
            "\tsize[x]=1;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa){",
            "\t\t\tdfs(to,x),size[x]+=size[to];",
            "\t\t\tif(size[to]>size[son[x]])son[x]=to;",
            "\t\t}",
            "}",
            "inline void CL(){",
            "\twhile(t)cnt[Q[t--]]=0;ans=tmp=0;",
            "}",
            "inline void insert(Re x){",
            "\t++cnt[Q[++t]=A[x]];",
            "\tif(cnt[A[x]]>tmp)tmp=cnt[ans=A[x]];",
            "\telse if(cnt[A[x]]==tmp)ans+=A[x];",
            "}",
            "inline void addson(Re x,Re fa){",
            "\tinsert(x);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa)addson(to,x);",
            "}",
            "inline void sakura(Re x,Re fa){",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa&&to!=son[x])sakura(to,x),CL();",
            "\tif(son[x])sakura(son[x],x);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa&&to!=son[x])addson(to,x);",
            "\tinsert(x),Ans[x]=ans;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),m=n-1;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tdfs(1,0),sakura(1,0);",
            "\tfor(Re i=1;i<=n;++i)printf(\"%lld \",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 Dsu on tree"
    },
    "Prufer序列": {
        "prefix": "acm-4.3get_prufer",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e6+3;",
            "int n,op,fa[N],pf[N],son[N];LL ans;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline LL get_prufer(){",
            "\tfor(Re i=1;i<=n-1;++i)in(fa[i]),++son[fa[i]];",
            "\tfor(Re i=1,j=1;i<=n-2;++i,++j){",
            "\t\twhile(son[j])++j;pf[i]=fa[j];",
            "\t\twhile(i<=n-2&&!--son[pf[i]]&&pf[i]<j)pf[i+1]=fa[pf[i]],++i;",
            "\t}",
            "//\tprintf(\"Prufer: \");for(Re i=1;i<=n-2;++i)printf(\"%d \",pf[i]);puts(\"\");",
            "\tfor(Re i=1;i<=n-2;++i)ans^=(LL)i*pf[i];",
            "\treturn ans;",
            "}",
            "inline LL get_fa(){",
            "\tfor(Re i=1;i<=n-2;++i)in(pf[i]),++son[pf[i]];pf[n-1]=n;",
            "\tfor(Re i=1,j=1;i<=n-1;++i,++j){",
            "\t\twhile(son[j])++j;fa[j]=pf[i];",
            "\t\twhile(i<=n-1&&!--son[pf[i]]&&pf[i]<j)fa[pf[i]]=pf[i+1],++i;",
            "\t}",
            "//\tprintf(\"fa: \");for(Re i=1;i<=n-1;++i)printf(\"%d \",fa[i]);puts(\"\");",
            "\tfor(Re i=1;i<=n-1;++i)ans^=(LL)i*fa[i];",
            "\treturn ans;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(op),printf(\"%lld\\n\",op<2?get_prufer():get_fa());",
            "}",
            ""
        ],
        "description": "插入 Prufer序列"
    },
    "基环树": {
        "prefix": "acm-4.3Island 求基环树森林直径之和",
        "body": [
            "#pragma comment(linker, \"/STACK:102400000,102400000\")",
            "#include<cstdio>",
            "#define Re register int",
            "const int N=1e6+3;",
            "#define LL long long",
            "int n,m,x,y,o=1,h,t,st,cnt,In[N],cir[N],pan[N],head[N];LL ans,tmp,Q[N<<1],S[N<<1],dp[N<<1],dis[N];",
            "struct QAQ{int w,to,next;}a[N<<1];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline LL max(LL a,LL b){return a>b?a:b;}",
            "inline int find_circle(Re x,Re p){",
            "\tif(In[x]){st=x,cir[++cnt]=x,pan[x]=1;return 1;}",
            "\tIn[x]=1;",
            "\tfor(Re i=head[x];i;i=a[i].next)",
            "\t\tif(i!=(p^1)&&find_circle(a[i].to,i)){",
            "\t\t\tpan[x]=1;",
            "\t\t\tif(x==st){S[0]=S[1]-a[i].w;return 0;}",
            "\t\t\tcir[++cnt]=x,S[cnt]=S[cnt-1]+a[i].w;",
            "\t\t\treturn 1;",
            "\t\t}",
            "\treturn 0;",
            "}",
            "inline void Tree_dp(Re x){",
            "\tpan[x]=1;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!pan[to=a[i].to]){",
            "\t\t\tTree_dp(to);",
            "\t\t\ttmp=max(tmp,dis[x]+a[i].w+dis[to]);",
            "\t\t\tdis[x]=max(dis[x],dis[to]+a[i].w);",
            "\t\t}",
            "}",
            "inline LL pp(Re j){return dp[j]-S[j];}",
            "inline LL sakura(Re root){",
            "\tS[0]=cnt=st=0;find_circle(root,0);",
            "\tLL ans1=0,ans2=0;tmp=0;",
            "\tfor(Re i=1;i<=cnt;++i){",
            "\t\ttmp=0,Tree_dp(cir[i]),ans1=max(ans1,tmp);",
            "\t\tdp[i+cnt]=dp[i]=dis[cir[i]];",
            "\t\tS[i+cnt]=S[i+cnt-1]+S[i]-S[i-1];",
            "\t}",
            "\th=1,t=0,Q[++t]=1;//ans=max(dp[i]+dp[j]+S[i]-S[j]) i-j+1<=cnt i-cnt+1<=j<i",
            "\tfor(Re i=2;i<=(cnt<<1);++i){",
            "\t\twhile(h<=t&&Q[h]<i-cnt+1)++h;",
            "\t\tif(h<=t)ans2=max(ans2,dp[i]+S[i]+pp(Q[h]));",
            "\t\twhile(h<=t&&pp(Q[t])<=pp(i))--t;",
            "\t\tQ[++t]=i;",
            "\t}",
            "\treturn max(ans1,ans2);",
            "}",
            "int main(){",
            "\tin(n);",
            "\tfor(Re i=1;i<=n;++i)in(x),in(y),add(i,x,y),add(x,i,y);",
            "\tfor(Re i=1;i<=n;++i)if(!pan[i])ans+=sakura(i);",
            "\tprintf(\"%lld\",ans);",
            "}"
        ],
        "description": "插入 基环树"
    },
    "最近公共祖先LCA": {
        "prefix": "acm-4.3树剖",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e5+3;",
            "int n,m,x,y,T,root;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Killed_Tree{",
            "\tstruct QAQ{int to,next;}a[N<<1];",
            "\tint o,head[N];",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tint id_o,id[N],fa[N],son[N],top[N],deep[N],size[N];",
            "\tinline void dfs1(Re x,Re Fa){",
            "\t\tsize[x]=1,deep[x]=deep[fa[x]=Fa]+1;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=Fa){",
            "\t\t\t\tdfs1(to,x);",
            "\t\t\t\tsize[x]+=size[to];",
            "\t\t\t\tif(size[to]>size[son[x]])son[x]=to;",
            "\t\t\t}",
            "\t}",
            "\tinline void dfs2(Re x,Re rt){",
            "\t\tid[x]=++id_o,top[x]=rt;",
            "\t\tif(!son[x])return;",
            "\t\tdfs2(son[x],rt);",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=fa[x]&&to!=son[x])dfs2(to,to);",
            "\t}",
            "\tinline void kill(Re rt){dfs1(rt,0),dfs2(rt,rt);}",
            "\tinline int lca(Re x,Re y){",
            "\t\twhile(top[x]!=top[y]){",
            "\t\t\tif(deep[top[x]]<deep[top[y]])swap(x,y);",
            "\t\t\tx=fa[top[x]];",
            "\t\t}",
            "\t\tif(deep[x]>deep[y])swap(x,y);",
            "\t\treturn x;",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),in(root),m=n-1;",
            "\twhile(m--)in(x),in(y),T1.add(x,y),T1.add(y,x);",
            "\tT1.kill(root);",
            "\twhile(T--)in(x),in(y),printf(\"%d\\n\",T1.lca(x,y));",
            "}",
            ""
        ],
        "description": "插入 最近公共祖先LCA"
    },
    "树的直径": {
        "prefix": "acm-4.3dp",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e4+3,M=3e5+3;",
            "int n,m,x,y,o,head[N];",
            "struct QAQ{int w,to,next;}a[N<<1];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "struct Tree_Diam_DP1{",
            "\tint ans,dis[N];",
            "\tinline void dfs(Re x,Re fa){",
            "\t\tfor(Re i=head[x],to,tmp;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=fa){",
            "\t\t\t\tdfs(to,x);",
            "\t\t\t\tans=max(ans,dis[x]+dis[to]+a[i].w);",
            "\t\t\t\tdis[x]=max(dis[x],dis[to]+a[i].w);",
            "\t\t\t}",
            "\t}",
            "\tinline int sakura(){dfs(1,0);return ans;}",
            "}T1;",
            "struct Tree_Diam_DP2{",
            "\tint ans,dis[N][2];",
            "\tinline void dfs(Re x,Re fa){",
            "\t\tfor(Re i=head[x],to,tmp;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=fa){",
            "\t\t\t\tdfs(to,x);",
            "\t\t\t\tif(dis[x][0]<(tmp=dis[to][0]+a[i].w))dis[x][1]=dis[x][0],dis[x][0]=tmp;",
            "\t\t\t\telse dis[x][1]=max(dis[x][1],tmp);",
            "\t\t\t}",
            "\t\tans=max(ans,dis[x][1]+dis[x][0]);",
            "\t}",
            "\tinline int sakura(){dfs(1,0);return ans;}",
            "}T2;",
            "int main(){",
            "\tin(n),m=n-1;",
            "    while(m--)in(x),in(y),add(x,y,1),add(y,x,1);",
            "    printf(\"%d\\n\",T1.sakura());",
            "//    printf(\"%d\\n\",T2.sakura());",
            "}",
            ""
        ],
        "description": "插入 树的直径"
    },
    "树的重心": {
        "prefix": "acm-4.3add",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=2e4+3,inf=2e9;",
            "int n,m,x,y,o,T,head[N];",
            "struct QAQ{int w,to,next;}a[N<<1];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "struct Tree_Diam_DP1{",
            "\tint ans,dp[N],size[N];",
            "\tinline void dfs(Re x,Re fa){",
            "\t\tsize[x]=1,dp[x]=0;",
            "\t\tfor(Re i=head[x],to,tmp;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=fa){",
            "\t\t\t\tdfs(to,x),size[x]+=size[to];",
            "\t\t\t\tdp[x]=max(dp[x],size[to]);",
            "\t\t\t}",
            "\t\tif(n-size[x])dp[x]=max(dp[x],n-size[x]);",
            "\t}",
            "\tinline void sakura(){",
            "\t\tdfs(1,0),dp[ans=0]=inf;",
            "\t\tfor(Re i=1;i<=n;++i)if(dp[i]<dp[ans])ans=i;",
            "\t}",
            "}T1;",
            "int main(){",
            "\tin(T);",
            "\twhile(T--){",
            "\t\tmemset(head,0,sizeof(head));",
            "\t\tin(n),m=n-1,o=0;",
            "\t    while(m--)in(x),in(y),add(x,y,1),add(y,x,1);",
            "\t    T1.sakura();",
            "\t\tprintf(\"%d %d\\n\",T1.ans,T1.dp[T1.ans]);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 树的重心"
    },
    "虚树": {
        "prefix": "acm-4.3Kingdom and its Cities",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,logN=17;",
            "int n,m,x,y,o,T,dfn_o,dfn[N],deep[N],head[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct LCA{",
            "\tint ant[N][20];",
            "\tinline void dfs(Re x,Re fa){",
            "\t\tdeep[x]=deep[ant[x][0]=fa]+1,dfn[x]=++dfn_o;",
            "\t\tfor(Re j=1;(1<<j)<=deep[x];++j)ant[x][j]=ant[ant[x][j-1]][j-1];",
            "\t\tfor(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);",
            "\t}",
            "\tinline int lca(Re x,Re y){",
            "\t\tif(deep[x]<deep[y])swap(x,y);",
            "\t\tfor(Re j=logN;j>=0;--j)if(deep[ant[x][j]]>=deep[y])x=ant[x][j];",
            "\t\tif(x==y)return x;",
            "\t\tfor(Re j=logN;j>=0;--j)if(ant[x][j]!=ant[y][j])x=ant[x][j],y=ant[y][j];",
            "\t\treturn ant[x][0];",
            "\t}",
            "}T1;",
            "inline bool cmp(Re x,Re y){return dfn[x]<dfn[y];}",
            "struct Virtual_Tree{",
            "\tint t,o,ans,A[N],Q[N],key[N],head[N];",
            "\tstruct QAQ{int to,next;}a[N<<1];",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void insert(Re x){// 撤销操作",
            "\t\tRe lca=T1.lca(Q[t],x);",
            "\t\twhile(t>1&&deep[Q[t-1]]>deep[lca])add(Q[t-1],Q[t]),--t;",
            "\t\tif(t&&deep[Q[t]]>deep[lca])add(lca,Q[t--]);",
            "\t\tif(!t||Q[t]!=lca)Q[++t]=lca;",
            "\t\tQ[++t]=x;",
            "\t}",
            "\tinline void dfs(Re x){// 撤销操作",
            "\t\tif(key[x])",
            "\t\t\tfor(Re i=head[x],to;i;i=a[i].next){",
            "\t\t\t\tdfs(to=a[i].to);",
            "\t\t\t\tif(key[to])key[to]=0,++ans;",
            "\t\t\t}",
            "\t\telse{",
            "\t\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\t\tdfs(to=a[i].to),key[x]+=key[to],key[to]=0;",
            "\t\t\tif(key[x]>1)key[x]=0,++ans;",
            "\t\t}",
            "\t\thead[x]=0;",
            "\t}",
            "\tinline void sakura(){",
            "\t\tin(m);Re flag=1;ans=o=t=0;",
            "\t\tfor(Re i=1;i<=m;++i)in(A[i]),key[A[i]]=1;",
            "\t\tfor(Re i=1;i<=m&&flag;++i)flag&=(!key[T1.ant[A[i]][0]]);",
            "\t\tif(!flag){",
            "\t\t\tfor(Re i=1;i<=m;++i)key[A[i]]=0;",
            "\t\t\tputs(\"-1\");return;",
            "\t\t}",
            "\t\tsort(A+1,A+m+1,cmp),Q[++t]=1;",
            "\t\tfor(Re i=1+(A[1]==1);i<=m;++i)insert(A[i]);",
            "\t\twhile(t>1)add(Q[t-1],Q[t]),--t;",
            "\t\tdfs(1),key[1]=0;",
            "\t\tprintf(\"%d\\n\",ans);",
            "\t}",
            "}T2;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),m=n-1;",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tT1.dfs(1,0),in(T);",
            "\twhile(T--)T2.sakura();",
            "}",
            ""
        ],
        "description": "插入 虚树"
    },
    "天天爱跑步": {
        "prefix": "acm-4.3mid",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#define pl tr[p].lp ",
            "#define pr tr[p].rp",
            "#define mid (L+R>>1)",
            "#define Re register int",
            "const int N=3e5+3,logN=19;",
            "int x,y,n,m,T,o,lca,w[N],pt[N],ans[N],head[N],deep[N];",
            "struct QWQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    x=0;char c=getchar();",
            "    while(c<'0'||c>'9')c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "}",
            "struct Segmemt_Tree{",
            "\tstruct QAQ{int g,lp,rp;}tr[N*36];int cnt;",
            "\tinline void change(Re &p,Re L,Re R,Re x,Re v){",
            "\t\tif(!p)p=++cnt;",
            "\t\tif(L==R){tr[p].g+=v;return;}",
            "\t\tif(x<=mid)change(pl,L,mid,x,v);",
            "\t    else change(pr,mid+1,R,x,v);",
            "\t}",
            "\tinline int merge(Re p,Re q){",
            "\t    if(!p)return q;if(!q)return p;",
            "\t    tr[p].g+=tr[q].g;",
            "\t    pl=merge(pl,tr[q].lp);",
            "\t\tpr=merge(pr,tr[q].rp);",
            "\t    return p;",
            "\t}",
            "\tinline int ask(Re p,Re L,Re R,Re x){",
            "\t    if(!p)return 0;",
            "\t    if(L==R)return tr[p].g;",
            "\t    if(x<=mid)return ask(pl,L,mid,x);",
            "\t    else return ask(pr,mid+1,R,x);",
            "\t}",
            "}T1;",
            "struct LCA{",
            "\tint ant[N][23];",
            "\tinline void dfs(Re x,Re fa){",
            "\t\tdeep[x]=deep[fa]+1,ant[x][0]=fa;",
            "\t\tfor(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];",
            "\t\tfor(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);",
            "\t}",
            "\tinline int lca(Re x,Re y){",
            "\t\tif(deep[x]>deep[y])std::swap(x,y);",
            "\t\tfor(Re i=logN;i>=0;--i)if(deep[x]<=deep[y]-(1<<i))y=ant[y][i];",
            "\t\tif(x==y)return y;",
            "\t\tfor(Re i=logN;i>=0;--i)",
            "\t\t\tif(ant[x][i]==ant[y][i])continue;",
            "\t\t\telse x=ant[x][i],y=ant[y][i];",
            "\t\treturn ant[x][0];",
            "\t}",
            "}T2;",
            "inline void dfs(Re x,Re fa){",
            "    for(Re i=head[x],to;i;i=a[i].next)",
            "    \tif((to=a[i].to)!=fa)",
            "        \tdfs(to,x),pt[x]=T1.merge(pt[x],pt[to]);",
            "\tans[x]+=T1.ask(pt[x],1,n<<1,n+deep[x]-w[x]);",
            "    if(w[x]&&deep[x]+w[x]<=n)ans[x]+=T1.ask(pt[x],1,n<<1,n+deep[x]+w[x]);",
            "}",
            "int main(){",
            "\tin(n),in(T),m=n-1;",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tfor(Re i=1;i<=n;++i)in(w[i]);",
            "\tT2.dfs(1,0);",
            "\twhile(T--){",
            "\t\tin(x),in(y),lca=T2.lca(x,y);",
            "\t\tT1.change(pt[x],1,n<<1,n+deep[x],1);",
            "        T1.change(pt[y],1,n<<1,n+deep[lca]*2-deep[x],1);",
            "        T1.change(pt[lca],1,n<<1,n+deep[x],-1);",
            "        T1.change(pt[T2.ant[lca][0]],1,n<<1,n+deep[lca]*2-deep[x],-1);",
            "\t}",
            "\tdfs(1,0);",
            "\tfor(Re i=1;i<=n;++i)printf(\"%d \",ans[i]);",
            "}",
            ""
        ],
        "description": "插入 天天爱跑步"
    },
    "树的直径升级版 每个点可到的最远距离computer": {
        "prefix": "acm-4.3HDU",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define R register int",
            "using namespace std;",
            "int n,b,c,d,t,longson[10005],d1[10005],d2[10005],df[10005],head[10005];",
            "struct QAQ{int to,next,w;}a[20005];",
            "inline void add(int x,int y,int w){a[++t].to=y,a[t].w=w,a[t].next=head[x],head[x]=t;}",
            "inline void dfs(int x,int pa){",
            "\tfor(R i=head[x];i;i=a[i].next){",
            "\t\tR s,to=a[i].to;",
            "\t\tif(to==pa)continue;",
            "\t\tdfs(to,x);s=d1[to]+a[i].w;",
            "\t\tif(s>d1[x])d2[x]=d1[x],d1[x]=s,longson[x]=to;",
            "\t\telse d2[x]=max(d2[x],s);",
            "\t}",
            "}",
            "inline void dfsf(int x,int pa){",
            "\tfor(R i=head[x];i;i=a[i].next){",
            "\t\tR to=a[i].to;",
            "\t\tif(to==pa)continue;",
            "\t\tif(longson[x]==to)df[to]=a[i].w+max(d2[x],df[x]);",
            "\t\telse df[to]=a[i].w+max(d1[x],df[x]);",
            "\t\tdfsf(to,x);",
            "\t}",
            "}",
            "inline int sakura(){",
            "\twhile(~scanf(\"%d\",&n)){",
            "\t\tmemset(longson,0,sizeof(longson));",
            "\t\tmemset(head,0,sizeof(head));",
            "\t\tmemset(d1,0,sizeof(d1));",
            "\t\tmemset(d2,0,sizeof(d2));",
            "\t\tmemset(df,0,sizeof(df));",
            "\t\tmemset(a,0,sizeof(a));t=0;",
            "\t\tfor(R i=2;i<=n;i++){",
            "\t\t\tscanf(\"%d%d\",&b,&c);",
            "\t\t\tadd(i,b,c),add(b,i,c);",
            "\t\t}",
            "\t\tdfs(1,0);dfsf(1,0);",
            "\t\tfor(R i=1;i<=n;i++)printf(\"%d\\n\",max(d1[i],df[i]));",
            "\t}",
            "\treturn 0;",
            "}",
            "int QAQWQ=sakura();",
            "int main(){}",
            ""
        ],
        "description": "插入 树的直径升级版 每个点可到的最远距离computer"
    },
    "雪松果树": {
        "prefix": "acm-4.3Dsu on tree",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e6+5,logN=14;",
            "int o,n,m,x,y,t,T,A[N],Q[N],Ans[N],cnt[N],son[N],deep[N],size[N],head[N];",
            "struct QAQ{int to,next;}a[N];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "struct Query{",
            "\tint o,head[N];",
            "\tstruct QAQ{int to,id,next;}a[N];",
            "\tinline void add(Re x,Re y,Re id){a[++o].to=y,a[o].id=id,a[o].next=head[x],head[x]=o;}",
            "}QT;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct LCA{",
            "\tint ant[N][15];",
            "\tinline void dfs(Re x,Re fa){",
            "\t\tdeep[x]=deep[ant[x][0]=fa]+1;",
            "\t\tfor(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];",
            "\t\tfor(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);",
            "\t}",
            "\tinline int kant(Re x,Re k){",
            "\t\tfor(Re i=logN;i>=0;--i)",
            "\t\t\tif((1<<i)<=k)k-=(1<<i),x=ant[x][i];",
            "\t\treturn x;",
            "\t}",
            "}T1;",
            "inline void dfs(Re x,Re fa){",
            "\tsize[x]=1,deep[x]=deep[fa]+1;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa){",
            "\t\t\tdfs(to,x),size[x]+=size[to];",
            "\t\t\tif(size[to]>size[son[x]])son[x]=to;",
            "\t\t}",
            "}",
            "inline void CL(){",
            "\twhile(t)cnt[Q[t--]]=0;",
            "}",
            "inline void insert(Re x){",
            "\t++cnt[Q[++t]=deep[x]];",
            "}",
            "inline void addson(Re x,Re fa){",
            "\tinsert(x);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa)addson(to,x);",
            "}",
            "inline void sakura(Re x,Re fa){",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa&&to!=son[x])sakura(to,x),CL();",
            "\tif(son[x])sakura(son[x],x);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa&&to!=son[x])addson(to,x);",
            "\tinsert(x);",
            "\tfor(Re i=QT.head[x];i;i=QT.a[i].next)",
            "\t\tAns[QT.a[i].id]=cnt[deep[x]+QT.a[i].to];",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T);",
            "\tfor(Re i=2;i<=n;++i)in(x),add(x,i);",
            "\tT1.dfs(1,0);",
            "\tfor(Re i=1;i<=T;++i)in(x),in(y),QT.add(T1.kant(x,y),y,i);",
            "\tdfs(1,0),sakura(1,n);",
            "\tfor(Re i=1;i<=T;++i)printf(\"%d \",max(Ans[i]-1,0));",
            "}",
            ""
        ],
        "description": "插入 雪松果树"
    },
    "Qtree7": {
        "prefix": "acm-4.3LCT维护同色连通块最大点权",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,inf=2e9;",
            "int n,m,x,y,o,T,op,A[N],co[N],fa[N],head[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Queue{",
            "\tpriority_queue<int>Q,D;",
            "\tinline void insert(Re x){Q.push(x);}",
            "\tinline void erase(Re x){if(Q.top()==x)Q.pop();else D.push(x);}",
            "\tinline int top(){",
            "\t\twhile(!Q.empty()&&!D.empty()&&Q.top()==D.top())Q.pop(),D.pop();",
            "\t\treturn Q.empty()?-inf:Q.top();",
            "\t}",
            "};",
            "struct Link_Cut_Tree{",
            "\t#define pl tr[p].ps[0]",
            "\t#define pr tr[p].ps[1]",
            "\t#define pf tr[p].fa",
            "\tstruct QAQ{int fa,max,ps[2];}tr[N];Queue si[N];",
            "\tinline void pushup(Re p){",
            "\t\ttr[p].max=max(max(A[p],si[p].top()),max(tr[pl].max,tr[pr].max));",
            "\t}",
            "\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\tinline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}",
            "\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\tinline void rotate(Re p){",
            "\t\tRe fa=pf,fas=which(p);",
            "\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\tRe x=tr[p].ps[fas^1];",
            "\t\tif(nort(fa))tr[pa].ps[pas]=p;pf=pa;",
            "\t\tconnect(x,fa,fas),connect(fa,p,fas^1);",
            "\t\tpushup(fa),pushup(p);",
            "\t}",
            "\tinline void splay(Re p){",
            "\t\tfor(Re fa;nort(p);rotate(p))",
            "\t\t\tif(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);",
            "\t}",
            "\tinline void access(Re p){",
            "\t\tfor(Re son=0;p;son=p,p=pf)",
            "\t\t\tsplay(p),si[p].insert(tr[pr].max),pr=son,si[p].erase(tr[pr].max),pushup(p);",
            "\t}",
            "\tinline void link(Re p,Re fa){",
            "\t\taccess(p),splay(p),access(fa),splay(fa),si[pf=fa].insert(tr[p].max),pushup(fa);",
            "\t}",
            "\tinline void cut(Re p,Re fa){",
            "\t\taccess(p),splay(p),splay(fa),pf=tr[fa].ps[1]=0,pushup(fa);",
            "\t}",
            "\tinline int ask(Re p){",
            "\t\taccess(p),splay(p);while(pl)p=pl;splay(p);return tr[pr].max;",
            "\t}",
            "\tinline void change(Re p,Re v){",
            "\t\taccess(p),splay(p),A[p]=v,pushup(p);",
            "\t}",
            "}LCT[2];",
            "inline void dfs(Re x,Re Fa){",
            "\tLCT[0].tr[x].max=LCT[1].tr[x].max=A[x];",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=Fa)dfs(to,x);",
            "\tLCT[co[x]].link(x,fa[x]=Fa);",
            "}",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    in(n),m=n-1,LCT[0].tr[0].max=LCT[1].tr[0].max=-inf;",
            "    while(m--)in(x),in(y),add(x,y),add(y,x);",
            "    for(Re i=1;i<=n;++i)in(co[i]);",
            "    for(Re i=1;i<=n;++i)in(A[i]);",
            "    in(T),dfs(1,n+1);",
            "    while(T--){",
            "    \tin(op),in(x);",
            "    \tif(op<1)printf(\"%d\\n\",LCT[co[x]].ask(x));",
            "    \telse if(op<2)LCT[co[x]].cut(x,fa[x]),LCT[co[x]^=1].link(x,fa[x]);",
            "    \telse in(y),LCT[co[x]].change(x,y);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 Qtree7"
    },
    "[RCOI] XOR  (LCT 计算原树信息)": {
        "prefix": "acm-4.3TLE 30pt",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=1e6+3,M=2e6+3;",
            "int n,m,x,y,T,op,HYJ,Ans,root,A[N];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Link_Cut_Tree{",
            "\t#define pl tr[p].ps[0]",
            "\t#define pr tr[p].ps[1]",
            "\t#define pf tr[p].fa",
            "\tint Q[N];",
            "\tstruct QAQ{int fa,si,ans,tag,shi,yuan,ps[2];}tr[N];",
            "\tinline void pushup(Re p){",
            "\t\ttr[p].shi=A[p]^tr[pl].shi^tr[pr].shi;",
            "\t\ttr[p].ans=A[p]^tr[p].si^tr[pl].ans^tr[pr].ans;",
            "\t}",
            "\tinline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}",
            "\tinline void pushdown(Re p){",
            "\t\tif(tr[p].tag){",
            "\t\t\tif(pl)updata(pl);",
            "\t\t\tif(pr)updata(pr);",
            "\t\t\ttr[p].tag=0;",
            "\t\t}",
            "\t}",
            "\tinline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}",
            "\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\tinline void rotate(Re p){",
            "\t\tRe fa=pf,fas=which(p);",
            "\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\tRe x=tr[p].ps[fas^1];",
            "\t\tif(nort(fa))tr[pa].ps[pas]=p;pf=pa;",
            "\t\tconnect(x,fa,fas),connect(fa,p,fas^1);",
            "\t\tpushup(fa),pushup(p);",
            "\t}",
            "\tinline void splay(Re p){",
            "\t\tRe x=p,t=0;Q[++t]=x;",
            "\t\twhile(nort(x))Q[++t]=x=tr[x].fa;",
            "\t\twhile(t)pushdown(Q[t--]);",
            "\t\tfor(Re fa;nort(p);rotate(p))",
            "\t\t\tif(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);",
            "\t}",
            "\tinline int access(Re p){",
            "\t\tRe son=0;",
            "\t\tfor(;p;son=p,p=pf)",
            "\t\t\tsplay(p),tr[p].si^=tr[pr].ans,tr[p].si^=tr[pr=son].ans,pushup(p);",
            "\t\treturn son;",
            "\t}",
            "\tinline void makeroot(Re p){access(p),splay(p),updata(p);}",
            "\tinline int findroot(Re p){",
            "\t\taccess(p),splay(p),pushdown(p);",
            "\t\twhile(pl)pushdown(p=pl);",
            "\t\treturn p;",
            "\t}",
            "\tinline void split(Re x,Re y){makeroot(x),access(y),splay(y);}",
            "\tinline void link(Re x,Re y){",
            "\t\tmakeroot(x);",
            "\t\tif(findroot(y)!=x)tr[tr[x].fa=y].si^=tr[x].ans,pushup(y);",
            "\t}",
            "\tinline int lca(Re x,Re y){access(x);return access(y);}",
            "\t",
            "\tinline int ask_son(Re p){access(p);return tr[pr].ans^tr[p].si^A[p];}",
            "}LCT;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(HYJ),in(T),m=n-1,T+=HYJ,root=1;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\twhile(m--)in(x),in(y),LCT.link(x,y);",
            "\tLCT.makeroot(root);",
            "//\tAns=0;for(Re i=1;i<=n;++i)Ans^=LCT.ask_son(i);",
            "//\tprintf(\"%d\\n\",Ans);return 0;",
            "\twhile(T--){",
            "\t\tin(op),in(x);",
            "//\t\tif(op<2)LCT.makeroot(root=x),printf(\"%d\\n\",Ans);",
            "\t\tif(op<2){",
            "\t\t\tLCT.makeroot(root=x);Ans=0;",
            "\t\t\tfor(Re i=1;i<=n;++i)Ans^=LCT.ask_son(i);",
            "\t\t\tprintf(\"%d\\n\",Ans);",
            "\t\t}",
            "\t\telse if(op<3)in(y),LCT.access(x),LCT.splay(x),A[x]=y,LCT.pushup(x);",
            "\t\telse if(op<4)in(y),printf(\"%d\\n\",LCT.lca(x,y));",
            "\t\telse if(op<5)in(y),LCT.split(x,y),printf(\"%d\\n\",LCT.tr[y].shi),LCT.makeroot(root);",
            "\t\telse printf(\"%d\\n\",LCT.ask_son(x));",
            "\t\tLCT.makeroot(root);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 [RCOI] XOR  (LCT 计算原树信息)"
    },
    "LCT 动态树": {
        "prefix": "acm-4.3pushup",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=1e5+3;",
            "int n,x,y,T,op,a[N];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Link_Cut_Tree{",
            "\t#define pl tr[p].ps[0]",
            "\t#define pr tr[p].ps[1]",
            "\t#define pf tr[p].fa",
            "\tint Q[N];",
            "\tstruct QAQ{int fa,ans,tag,ps[2];}tr[N];",
            "\tinline void pushup(Re p){",
            "\t\ttr[p].ans=a[p]^tr[pl].ans^tr[pr].ans;",
            "\t}",
            "\tinline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}",
            "\tinline void pushdown(Re p){",
            "\t\tif(tr[p].tag){",
            "\t\t\tif(pl)updata(pl);",
            "\t\t\tif(pr)updata(pr);",
            "\t\t\ttr[p].tag=0;",
            "\t\t}",
            "\t}",
            "\tinline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}",
            "\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\tinline void rotate(Re p){",
            "\t\tRe fa=pf,fas=which(p);",
            "\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\tRe x=tr[p].ps[fas^1];",
            "\t\tif(nort(fa))tr[pa].ps[pas]=p;pf=pa;",
            "\t\tconnect(x,fa,fas),connect(fa,p,fas^1);",
            "\t\tpushup(fa),pushup(p);",
            "\t}",
            "\tinline void splay(Re p){",
            "\t\tRe x=p,t=0;Q[++t]=x;",
            "\t\twhile(nort(x))Q[++t]=x=tr[x].fa;",
            "\t\twhile(t)pushdown(Q[t--]);",
            "\t\tfor(Re fa;nort(p);rotate(p))",
            "\t\t\tif(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);",
            "\t}",
            "\tinline void access(Re p){",
            "\t\tfor(Re son=0;p;son=p,p=pf)",
            "\t\t\tsplay(p),pr=son,pushup(p);",
            "\t}",
            "\tinline void makeroot(Re p){access(p),splay(p),updata(p);}",
            "\tinline int findroot(Re p){",
            "\t\taccess(p),splay(p),pushdown(p);",
            "\t\twhile(pl)pushdown(p=pl);",
            "\t\treturn p;",
            "\t}",
            "\tinline void split(Re x,Re y){makeroot(x),access(y),splay(y);}",
            "\tinline void link(Re x,Re y){makeroot(x);if(findroot(y)!=x)tr[x].fa=y;}",
            "\tinline void cut(Re x,Re y){",
            "\t\tmakeroot(x);",
            "\t\tif(findroot(y)==x&&tr[x].fa==y&&!tr[x].ps[1])",
            "\t\t\ttr[x].fa=tr[y].ps[0]=0,pushup(y);",
            "\t}",
            "}LCT;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T);",
            "\tfor(Re i=1;i<=n;++i)in(a[i]);",
            "\twhile(T--){",
            "\t\tin(op),in(x),in(y);",
            "\t\tif(!op)LCT.split(x,y),printf(\"%d\\n\",LCT.tr[y].ans);",
            "\t\telse if(op<2)LCT.link(x,y);",
            "\t\telse if(op<3)LCT.cut(x,y);",
            "\t\telse LCT.splay(x),a[x]=y,LCT.pushup(x);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 LCT 动态树"
    },
    "动态DP  (带修树上最大点权独立集)": {
        "prefix": "acm-4.3树剖",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Mat Matrix",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "const LL inf=1e18;",
            "int n,m,o,x,y,T,A[N],head[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Matrix{",
            "\tLL a[3][3];Mat(){a[1][1]=a[1][2]=a[2][1]=a[2][2]=-inf;}",
            "\tinline Mat operator*(const Mat &O)const{",
            "\t\tMat A;",
            "\t\tfor(Re i=1;i<=2;++i)",
            "\t\t\tfor(Re j=1;j<=2;++j)",
            "\t\t\t\tfor(Re k=1;k<=2;++k)",
            "\t\t\t\t\tA.a[i][j]=max(A.a[i][j],a[i][k]+O.a[k][j]);",
            "\t\treturn A;",
            "\t}",
            "}G[N];",
            "int idx[N];",
            "struct killed_Tree{",
            "\tstruct Segment_Tree{",
            "\t\t#define pl (p<<1)",
            "\t\t#define pr (p<<1|1)",
            "\t\t#define mid ((L+R)>>1)",
            "\t\tMat tr[N<<2];",
            "\t\tinline void pushup(Re p){tr[p]=tr[pl]*tr[pr];}",
            "\t\tinline void build(Re p,Re L,Re R){",
            "\t\t\tif(L==R){tr[p]=G[idx[L]];return;}",
            "\t\t\tbuild(pl,L,mid),build(pr,mid+1,R);",
            "\t\t\tpushup(p);",
            "\t\t}",
            "\t\tinline void change(Re p,Re L,Re R,Re x,Mat &v){",
            "\t\t\tif(L==R){tr[p]=v;return;}",
            "\t\t\tif(x<=mid)change(pl,L,mid,x,v);",
            "\t\t\telse change(pr,mid+1,R,x,v);",
            "\t\t\tpushup(p);",
            "\t\t}",
            "\t\tinline Mat ask(Re p,Re L,Re R,Re l,Re r){",
            "\t\t\tif(l<=L&&R<=r)return tr[p];",
            "\t\t\tif(r<=mid)return ask(pl,L,mid,l,r);",
            "\t\t\telse if(l>mid)return ask(pr,mid+1,R,l,r);",
            "\t\t\telse return ask(pl,L,mid,l,r)*ask(pr,mid+1,R,l,r);",
            "\t\t}",
            "\t}TR;",
            "\tint id_O,fa[N],st[N],ed[N],son[N],top[N],deep[N],size[N];LL f[N][2],g[N][2];",
            "\tinline void dfs1(Re x,Re Fa){",
            "\t\tdeep[x]=deep[fa[x]=Fa]+1,size[x]=1;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=Fa){",
            "\t\t\t\tdfs1(to,x),size[x]+=size[to];",
            "\t\t\t\tif(size[to]>size[son[x]])son[x]=to;",
            "\t\t\t}",
            "\t}",
            "\tinline void dfs2(Re x,Re rt){",
            "\t\tidx[st[x]=++id_O]=x,ed[rt]=max(ed[rt],id_O),top[x]=rt;",
            "\t\tf[x][0]=g[x][0]=0,f[x][1]=g[x][1]=A[x];",
            "\t\tif(son[x])dfs2(son[x],rt),f[x][0]+=max(f[son[x]][0],f[son[x]][1]),f[x][1]+=f[son[x]][0];",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=fa[x]&&to!=son[x]){",
            "\t\t\t\tdfs2(to,to);",
            "\t\t\t\tf[x][0]+=max(f[to][0],f[to][1]),f[x][1]+=f[to][0];",
            "\t\t\t\tg[x][0]+=max(f[to][0],f[to][1]),g[x][1]+=f[to][0];",
            "\t\t\t}",
            "\t\tG[x].a[1][1]=G[x].a[1][2]=g[x][0];",
            "\t\tG[x].a[2][1]=g[x][1],G[x].a[2][2]=-inf;",
            "\t}",
            "\tinline LL ask(){Mat F=TR.ask(1,1,n,st[1],ed[1]);return max(F.a[1][1],F.a[2][1]);}",
            "\tinline void change(Re x,Re v){//�޸�x�ĵ�Ȩ",
            "\t\tG[x].a[2][1]+=v-A[x],A[x]=v;//�޸�G[x][1]",
            "\t\twhile(x){",
            "\t\t\tMat F1=TR.ask(1,1,n,st[top[x]],ed[top[x]]);",
            "\t\t\tTR.change(1,1,n,st[x],G[x]);",
            "\t\t\tMat F2=TR.ask(1,1,n,st[top[x]],ed[top[x]]);",
            "\t\t\tx=fa[top[x]];",
            "\t\t\tG[x].a[1][1]+=max(F2.a[1][1],F2.a[2][1])-max(F1.a[1][1],F1.a[2][1]),G[x].a[1][2]=G[x].a[1][1];",
            "\t\t\tG[x].a[2][1]+=F2.a[1][1]-F1.a[1][1];",
            "\t\t}",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),m=n-1;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tT1.dfs1(1,0),T1.dfs2(1,1),T1.TR.build(1,1,n);",
            "\twhile(T--)in(x),in(y),T1.change(x,y),printf(\"%lld\\n\",T1.ask());",
            "}",
            ""
        ],
        "description": "插入 动态DP  (带修树上最大点权独立集)"
    },
    "大融合": {
        "prefix": "acm-4.3LCT 计算虚子树信息",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=1e5+3;",
            "int n,x,y,T;char op;",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Link_Cut_Tree{",
            "\t#define pl tr[p].ps[0]",
            "\t#define pr tr[p].ps[1]",
            "\t#define pf tr[p].fa",
            "\tint Q[N];",
            "\tstruct QAQ{int fa,si,ans,tag,ps[2];}tr[N];",
            "\tinline void pushup(Re p){",
            "\t\ttr[p].ans=1+tr[p].si+tr[pl].ans+tr[pr].ans;",
            "\t}",
            "\tinline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}",
            "\tinline void pushdown(Re p){",
            "\t\tif(tr[p].tag){",
            "\t\t\tif(pl)updata(pl);",
            "\t\t\tif(pr)updata(pr);",
            "\t\t\ttr[p].tag=0;",
            "\t\t}",
            "\t}",
            "\tinline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}",
            "\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\tinline void rotate(Re p){",
            "\t\tRe fa=pf,fas=which(p);",
            "\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\tRe x=tr[p].ps[fas^1];",
            "\t\tif(nort(fa))tr[pa].ps[pas]=p;pf=pa;",
            "\t\tconnect(x,fa,fas),connect(fa,p,fas^1);",
            "\t\tpushup(fa),pushup(p);",
            "\t}",
            "\tinline void splay(Re p){",
            "\t\tRe x=p,t=0;Q[++t]=x;",
            "\t\twhile(nort(x))Q[++t]=x=tr[x].fa;",
            "\t\twhile(t)pushdown(Q[t--]);",
            "\t\tfor(Re fa;nort(p);rotate(p))",
            "\t\t\tif(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);",
            "\t}",
            "\tinline void access(Re p){",
            "\t\tfor(Re son=0;p;son=p,p=pf)",
            "\t\t\tsplay(p),tr[p].si+=tr[pr].ans,tr[p].si-=tr[pr=son].ans,pushup(p);",
            "\t}",
            "\tinline void makeroot(Re p){access(p),splay(p),updata(p);}",
            "\tinline int findroot(Re p){",
            "\t\taccess(p),splay(p),pushdown(p);",
            "\t\twhile(pl)pushdown(p=pl);",
            "\t\treturn p;",
            "\t}",
            "\tinline void split(Re x,Re y){makeroot(x),access(y),splay(y);}",
            "\tinline void link(Re x,Re y){",
            "\t\tmakeroot(x);",
            "\t\tif(findroot(y)!=x)tr[tr[x].fa=y].si+=tr[x].ans,pushup(y);",
            "\t}",
            "\tinline void cut(Re x,Re y){",
            "\t\tmakeroot(x);",
            "\t\tif(findroot(y)==x&&tr[x].fa==y&&!tr[x].ps[1])",
            "\t\t\ttr[x].fa=tr[y].ps[0]=0,pushup(y);",
            "\t}",
            "\tinline int ask(Re x,Re y){split(x,y);return (tr[x].si+1)*(tr[y].si+1);}",
            "}LCT;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T);",
            "\twhile(T--){",
            "\t\tscanf(\" %c\",&op),in(x),in(y);",
            "\t\tif(op=='A')LCT.link(x,y);",
            "\t\tif(op=='Q')printf(\"%d\\n\",LCT.ask(x,y));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 大融合"
    },
    "水管局长": {
        "prefix": "acm-4.3LCT动态维护MST",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1003,M=1e5+3;",
            "int n,m,x,y,z,T,op,id,id_O,v[N+M],vis[N+M],Ans[M],ID[N][N];",
            "struct Query{int op,x,y;}Q[M];",
            "inline void in(int &x){",
            "    Re fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Link_Cut_Tree{",
            "\t#define pl tr[p].ps[0]",
            "\t#define pr tr[p].ps[1]",
            "\t#define pf tr[p].fa",
            "\tint Q[N+M];",
            "\tstruct QAQ{int mx,fa,tag,ps[2];}tr[N+M];",
            "\tinline void pushup(Re p){",
            "\t\ttr[p].mx=p;",
            "\t\tif(pl&&v[tr[pl].mx]>v[tr[p].mx])tr[p].mx=tr[pl].mx;",
            "\t\tif(pr&&v[tr[pr].mx]>v[tr[p].mx])tr[p].mx=tr[pr].mx;",
            "\t}",
            "\tinline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}",
            "\tinline void pushdown(Re p){",
            "\t\tif(tr[p].tag){",
            "\t\t\tif(pl)updata(pl);",
            "\t\t\tif(pr)updata(pr);",
            "\t\t\ttr[p].tag=0;",
            "\t\t}",
            "\t}",
            "\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\tinline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}",
            "\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\tinline void rotate(Re p){",
            "\t\tRe fa=pf,fas=which(p);",
            "\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\tRe x=tr[p].ps[fas^1];",
            "\t\tif(nort(fa))tr[pa].ps[pas]=p;pf=pa;",
            "\t\tconnect(x,fa,fas),connect(fa,p,fas^1);",
            "\t\tpushup(fa),pushup(p); ",
            "\t}",
            "\tinline void splay(Re p){",
            "\t\tRe x=p,t=0;Q[++t]=x;",
            "\t\twhile(nort(x))Q[++t]=x=tr[x].fa;",
            "\t\twhile(t)pushdown(Q[t--]);",
            "\t\tfor(Re fa;nort(p);rotate(p))",
            "\t\t\tif(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);",
            "\t}",
            "\tinline void access(Re p){",
            "\t\tfor(Re son=0;p;son=p,p=pf)",
            "\t\t\tsplay(p),pr=son,pushup(p);",
            "\t}",
            "\tinline void makeroot(Re x){access(x),splay(x),updata(x);}",
            "\tinline int findroot(Re p){",
            "\t\taccess(p),splay(p),pushdown(p);",
            "\t\twhile(pl)pushdown(p=pl);",
            "\t\treturn p;",
            "\t}",
            "\tinline void split(Re x,Re y){makeroot(x),access(y),splay(y);}",
            "\tinline void link(Re x,Re y){makeroot(x);if(findroot(y)!=x)tr[x].fa=y;}",
            "\tinline void cut(Re x,Re y){",
            "\t\tmakeroot(x);",
            "\t\tif(findroot(y)==x&&tr[x].fa==y&&!tr[x].ps[1])",
            "\t\t\ttr[x].fa=tr[y].ps[0]=0,pushup(y);",
            "\t}",
            "\tinline void MST_link(Re x,Re y,Re id){",
            "\t\tmakeroot(x);",
            "\t\tif(findroot(y)!=x)link(x,id),link(id,y);",
            "\t\telse{",
            "\t\t\tsplit(x,y);Re mx=tr[y].mx;",
            "\t\t\tif(v[id]<v[mx]){",
            "\t\t\t\tsplay(mx);",
            "\t\t\t\ttr[tr[mx].ps[0]].fa=tr[tr[mx].ps[1]].fa=0;",
            "\t\t\t\ttr[mx].ps[0]=tr[mx].ps[1]=tr[mx].fa=0;",
            "\t\t\t\tlink(x,id),link(id,y);",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "\tinline int MST_path(Re x,Re y){split(x,y);return v[tr[y].mx];}",
            "}LCT;",
            "struct Kruscal{",
            "\tint fa[N];",
            "\tstruct QAQ{int x,y,z;inline bool operator<(const QAQ &O)const{return z<O.z;}}a[M];",
            "\tinline int find(Re x){return x==fa[x]?x:fa[x]=find(fa[x]);}",
            "\tinline void sakura(){",
            "\t\tfor(Re i=1;i<=n;++i)fa[i]=i;",
            "\t\tfor(Re i=1;i<=m;++i)in(x),in(y),in(z),v[ID[x][y]=ID[y][x]=++id_O+n]=z,a[i]=(QAQ){x,y,z};",
            "\t\tfor(Re i=1;i<=T;++i)in(op),in(x),in(y),vis[ID[x][y]]|=op>1,Q[i]=(Query){op,x,y};",
            "\t\tsort(a+1,a+m+1);",
            "\t\tfor(Re i=1,t=0;t<n-1&&i<=m;++i)",
            "\t\t\tif(!vis[ID[x=a[i].x][y=a[i].y]]&&find(x)!=find(y))",
            "\t\t\t\tfa[find(x)]=find(y),++t,LCT.MST_link(x,y,ID[x][y]);",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),in(T),T1.sakura();",
            "\tfor(Re i=T;i>=1;--i){",
            "\t\tRe op=Q[i].op,x=Q[i].x,y=Q[i].y;",
            "\t\tif(op&1)Ans[++Ans[0]]=LCT.MST_path(x,y);",
            "\t\telse LCT.MST_link(x,y,ID[x][y]);",
            "\t}",
            "\tfor(Re i=Ans[0];i>=1;--i)printf(\"%d\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 水管局长"
    },
    "遥远的国度": {
        "prefix": "acm-4.3LCT维护原子树信息",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<set>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,inf=2e9;",
            "int n,x,y,z,T,op,root,X[N],Y[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Link_Cut_Tree{",
            "\t#define pl tr[p].ps[0]",
            "\t#define pr tr[p].ps[1]",
            "\t#define pf tr[p].fa",
            "\t#define pv tr[p].v",
            "\tint Q[N];",
            "\tstruct QAQ{int v,fa,si,shi,ans,add,tag,ans0,ps[2];multiset<int>SI;}tr[N];",
            "\tinline void pushup(Re p){",
            "\t\ttr[p].shi=min(pv,min(tr[pl].shi,tr[pr].shi));",
            "\t\ttr[p].si=min(*tr[p].SI.begin(),min(tr[pl].si,tr[pr].si));",
            "\t\ttr[p].ans=min(tr[p].shi,tr[p].si);",
            "\t}",
            "\tinline void updata(Re p){tr[p].tag^=1,swap(pl,pr);}",
            "\tinline void updata(Re p,Re v){tr[p].add=1,tr[p].shi=pv=v,tr[p].ans=min(tr[p].shi,tr[p].si);}",
            "\tinline void pushdown(Re p){",
            "\t\tif(tr[p].tag){",
            "\t\t\tif(pl)updata(pl);",
            "\t\t\tif(pr)updata(pr);",
            "\t\t\ttr[p].tag=0;",
            "\t\t}",
            "\t\tif(tr[p].add){",
            "\t\t\tif(pl)updata(pl,pv);",
            "\t\t\tif(pr)updata(pr,pv);",
            "\t\t\ttr[p].add=0;",
            "\t\t}",
            "\t}",
            "\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\tinline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}",
            "\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\tinline void rotate(Re p){",
            "\t\tRe fa=pf,fas=which(p);",
            "\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\tRe x=tr[p].ps[fas^1];",
            "\t\tif(nort(fa))tr[pa].ps[pas]=p;pf=pa;",
            "\t\tconnect(x,fa,fas),connect(fa,p,fas^1);",
            "\t\tpushup(fa),pushup(p);",
            "\t}",
            "\tinline void splay(Re p){",
            "\t\tRe x=p,t=0;Q[++t]=x;",
            "\t\twhile(nort(x))Q[++t]=x=tr[x].fa;",
            "\t\twhile(t)pushdown(Q[t--]);",
            "\t\tfor(Re fa;nort(p);rotate(p))",
            "\t\t\tif(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);",
            "\t}",
            "\tinline void access(Re p){",
            "\t\tfor(Re son=0;p;son=p,p=pf){",
            "\t\t\tsplay(p);",
            "\t\t\tif(pr)tr[p].SI.insert(tr[pr].ans);",
            "\t\t\tpr=son;",
            "\t\t\tif(pr)tr[p].SI.erase(tr[p].SI.lower_bound(tr[pr].ans));",
            "\t\t\tpushup(p);",
            "\t\t}",
            "\t}",
            "\tinline void makeroot(Re p){access(p),splay(p),updata(p);}",
            "\tinline void link(Re x,Re y){makeroot(x),access(y),splay(y),tr[tr[x].fa=y].SI.insert(tr[x].ans);}",
            "\tinline void change(Re x,Re y,Re z){makeroot(x),access(y),splay(y),updata(y,z);}",
            "\tinline int ask_son(Re p){access(p),splay(p);return min(pv,*tr[p].SI.begin());}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),T1.tr[0].shi=T1.tr[0].si=inf;",
            "\tfor(Re i=1;i<n;++i)in(X[i]),in(Y[i]);",
            "\tfor(Re i=1;i<=n;++i)in(T1.tr[i].v),T1.tr[i].SI.insert(inf),T1.pushup(i);",
            "\tfor(Re i=1;i<n;++i)T1.link(X[i],Y[i]);",
            "\tin(root),T1.makeroot(root);",
            "\twhile(T--){",
            "\t\tin(op),in(x);",
            "\t\tif(op<2)T1.makeroot(root=x);",
            "\t\telse if(op<3)in(y),in(z),T1.change(x,y,z),T1.makeroot(root);",
            "\t\telse printf(\"%d\\n\",T1.ask_son(x));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 遥远的国度"
    },
    "长链剖分优化dp": {
        "prefix": "acm-4.3Dominant Indices",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e6+3;",
            "int n,m,x,y,o,Sz[N],son[N],Ans[N],dep[N],head[N];int *SZ=Sz,*dp[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void dfs1(Re x,Re fa){",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa){",
            "\t\t\tdfs1(to,x);",
            "\t\t\tif(dep[to]>dep[son[x]])son[x]=to;",
            "\t\t}",
            "\tdep[x]=dep[son[x]]+1;",
            "}",
            "inline void dfs2(Re x,Re fa){",
            "\tdp[x][0]=1;",
            "\tif(son[x])dp[son[x]]=dp[x]+1,dfs2(son[x],x),Ans[x]=Ans[son[x]]+1;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa&&to!=son[x]){",
            "\t\t\tdp[to]=SZ,SZ+=dep[to],dfs2(to,x);",
            "\t\t\tfor(Re j=1;j<=dep[to];++j){",
            "\t\t\t\tdp[x][j]+=dp[to][j-1];",
            "\t\t\t\tif(dp[x][j]>dp[x][Ans[x]])Ans[x]=j;",
            "\t\t\t\telse if(dp[x][j]==dp[x][Ans[x]])Ans[x]=min(Ans[x],j);",
            "\t\t\t}",
            "\t\t}",
            "\tif(dp[x][Ans[x]]==1)Ans[x]=0;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),m=n-1;",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tdfs1(1,0),dp[1]=SZ,SZ+=dep[1],dfs2(1,0);",
            "\tfor(Re i=1;i<=n;++i)printf(\"%d\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 长链剖分优化dp"
    },
    "Distance in Tree": {
        "prefix": "acm-4.3长度等于K的路径数",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e4+3,inf=2e9;",
            "int n,m,o,x,y,K,head[N];LL Ans;",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int rt,sum,cnt,tmp[N],dis[N],vis[N],maxp[N],size[N];",
            "inline void getrt(Re x,Re fa){",
            "\tsize[x]=1,maxp[x]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)",
            "\t\t\tgetrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);",
            "\tmaxp[x]=max(maxp[x],sum-size[x]);",
            "\tif(maxp[x]<maxp[rt])rt=x;",
            "}",
            "inline void getdis(Re x,Re fa){",
            "\tif(dis[fa]+1>K)return;",
            "\ttmp[++cnt]=dis[x]=dis[fa]+1;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)getdis(to,x);",
            "}",
            "inline int calc(Re x,Re d){",
            "\tRe ans=0;cnt=0,tmp[++cnt]=dis[x]=d;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to])getdis(to,x);",
            "\tsort(tmp+1,tmp+cnt+1);",
            "\tRe L=cnt+1,R=cnt;",
            "\tfor(Re i=1;i<=cnt&&i<R;++i){",
            "\t\twhile(tmp[i]+tmp[L-1]>=K)--L;",
            "\t\twhile(R>=L&&tmp[i]+tmp[R]>K)--R;",
            "\t\tif(L<=R&&i<R&&tmp[i]+tmp[L]==K&&tmp[i]+tmp[R]==K)ans+=(R-max(L,i+1)+1);",
            "\t}",
            "\treturn ans;",
            "}",
            "inline void sakura(Re x){",
            "\tRe now=sum;vis[x]=1,Ans+=calc(x,0);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to])",
            "\t\t\tAns-=calc(to,1),sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,x),sakura(rt);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(K),m=n-1;",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tsum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);",
            "\tprintf(\"%lld\\n\",Ans);",
            "}",
            ""
        ],
        "description": "插入 Distance in Tree"
    },
    "Qtree4": {
        "prefix": "acm-4.3点分树+可删堆",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,logN=18,inf=1e9;",
            "int n,m,x,y,z,o,T,Cnt,A[N],ans[N],head[N];char op;",
            "struct QAQ{int w,to,next;}a[N<<1];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct LCA{",
            "\tint O,lg[N<<1],fir[N],idx[N<<1],idd[N<<1],dis[N],deep[N],f[N<<1][20],ans[N<<1][20];",
            "\tinline void dfs(Re x,Re fa,Re w){",
            "\t\tidx[fir[x]=++O]=x,idd[O]=deep[x]=deep[fa]+1,dis[x]=dis[fa]+w;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=fa)dfs(to,x,a[i].w),idx[++O]=x,idd[O]=deep[x];",
            "\t}",
            "\tinline void build(Re rt){",
            "\t\tdfs(rt,0,0),lg[0]=-1;",
            "\t\tfor(Re i=1;i<=O;++i)f[i][0]=idd[i],ans[i][0]=idx[i],lg[i]=lg[i>>1]+1;",
            "\t\tfor(Re j=1;j<=logN;++j)",
            "\t\t\tfor(Re i=1;i+(1<<j)-1<=O;++i)",
            "\t\t\t\tif(f[i][j-1]<f[i+(1<<j-1)][j-1])f[i][j]=f[i][j-1],ans[i][j]=ans[i][j-1];",
            "\t\t\t\telse f[i][j]=f[i+(1<<j-1)][j-1],ans[i][j]=ans[i+(1<<j-1)][j-1];",
            "\t}",
            "\tinline int lca(Re x,Re y){",
            "\t\tRe L=fir[x],R=fir[y];",
            "\t\tif(L>R)swap(L,R);",
            "\t\tRe m=lg[R-L+1];",
            "\t\treturn f[L][m]<f[R-(1<<m)+1][m]?ans[L][m]:ans[R-(1<<m)+1][m];",
            "\t}",
            "}T0;",
            "inline int Dis(Re x,Re y){return T0.dis[x]+T0.dis[y]-(T0.dis[T0.lca(x,y)]<<1);}",
            "struct Queue{",
            "\tpriority_queue<int>Q,D;",
            "\tinline int top(){",
            "\t\twhile(!Q.empty()&&!D.empty()&&Q.top()==D.top())Q.pop(),D.pop();",
            "\t\treturn Q.empty()?-inf:Q.top();",
            "\t}",
            "\tinline int sec(){",
            "\t\tRe x=top();if(x==-inf)return x;",
            "\t\tQ.pop();Re ans=top();Q.push(x);",
            "\t\treturn ans;",
            "\t}",
            "\tinline void erase(Re x){if(Q.top()==x)Q.pop();else D.push(x);}",
            "\tinline void insert(Re x){Q.push(x);}",
            "\tinline int empty(){",
            "\t\twhile(!Q.empty()&&!D.empty()&&Q.top()==D.top())Q.pop(),D.pop();",
            "\t\treturn Q.empty();",
            "\t}",
            "}Ans,Q[N],dis[N];",
            "int rt,sum,Fa[N],vis[N],size[N],maxp[N];",
            "inline void getrt(Re x,Re fa){",
            "\tsize[x]=1,maxp[x]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)",
            "\t\t\tgetrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);",
            "\tmaxp[x]=max(maxp[x],sum-size[x]);",
            "\tif(maxp[x]<maxp[rt])rt=x;",
            "}",
            "inline void getdis(Re x,Re fa,Re rt){",
            "\tdis[rt].insert(Dis(x,Fa[rt]));",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)getdis(to,x,rt);",
            "}",
            "inline void sakura(Re x){",
            "\tRe now=sum;vis[x]=1,getdis(x,0,x);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]){",
            "\t\t\tsum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0);",
            "\t\t\tFa[to=rt]=x,sakura(rt),Q[x].insert(dis[to].top());",
            "\t\t}",
            "\tQ[x].insert(0),Ans.insert(ans[x]=max(0,Q[x].top()+Q[x].sec()));",
            "}",
            "inline void insert(Re x){",
            "\tAns.erase(ans[x]),Q[x].insert(0),Ans.insert(ans[x]=max(0,Q[x].top()+Q[x].sec()));",
            "\tfor(Re fa=x;Fa[fa];fa=Fa[fa]){",
            "\t\tRe pa=Fa[fa];",
            "\t\tAns.erase(ans[pa]);",
            "\t\tif(!dis[fa].empty())Q[pa].erase(dis[fa].top());",
            "\t\t",
            "\t\tdis[fa].insert(Dis(x,pa));",
            "\t\t",
            "\t\tQ[pa].insert(dis[fa].top());",
            "\t\tAns.insert(ans[pa]=max(0,Q[pa].top()+Q[pa].sec()));",
            "\t}",
            "}",
            "inline void erase(Re x){",
            "\tAns.erase(ans[x]),Q[x].erase(0),Ans.insert(ans[x]=max(0,Q[x].top()+Q[x].sec()));",
            "\tfor(Re fa=x;Fa[fa];fa=Fa[fa]){",
            "\t\tRe pa=Fa[fa];",
            "\t\tAns.erase(ans[pa]);",
            "\t\tQ[pa].erase(dis[fa].top());",
            "\t\t",
            "\t\tdis[fa].erase(Dis(x,pa));",
            "\t\t",
            "\t\tif(!dis[fa].empty())Q[pa].insert(dis[fa].top());",
            "\t\tAns.insert(ans[pa]=max(0,Q[pa].top()+Q[pa].sec()));",
            "\t}",
            "}",
            "inline void change(Re x){",
            "\tif(A[x])insert(x),A[x]=0,++Cnt;",
            "\telse erase(x),A[x]=1,--Cnt;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),m=n-1,Cnt=n;",
            "\twhile(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);",
            "\tin(T),T0.build(1),sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);",
            "\twhile(T--){",
            "\t\tscanf(\" %c\",&op);",
            "\t\tif(op=='C')in(x),change(x);",
            "\t\telse if(!Cnt)puts(\"They have disappeared.\");",
            "\t\telse printf(\"%d\\n\",Cnt<2?0:Ans.top());",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 Qtree4"
    },
    "Race": {
        "prefix": "acm-4.3长度等于K的路径最小边数",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=2e5+3,INF=1e6+3,inf=2e9;",
            "int n,m,o,x,y,z,K,Ans,head[N];",
            "struct QAQ{int w,to,next;}a[N<<1];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int rt,sum,dd[N],ddd[N],dep[N],Min[INF],tmp[N],dis[N],vis[N],maxp[N],size[N];",
            "inline void getrt(Re x,Re fa){",
            "\tsize[x]=1,maxp[x]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)",
            "\t\t\tgetrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);",
            "\tmaxp[x]=max(maxp[x],sum-size[x]);",
            "\tif(maxp[x]<maxp[rt])rt=x;",
            "}",
            "inline void getdis(Re x,Re fa,Re w){",
            "\tif(dis[fa]+w>K)return;",
            "\tdd[++dd[0]]=dis[x]=dis[fa]+w,ddd[dd[0]]=dep[x]=dep[fa]+1;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)getdis(to,x,a[i].w);",
            "}",
            "inline void calc(Re x){",
            "\tdis[x]=dep[x]=tmp[0]=0,Min[tmp[++tmp[0]]=0]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]){",
            "\t\t\tdd[0]=0,getdis(to,x,a[i].w);",
            "\t\t\tfor(Re i=1;i<=dd[0];++i)Ans=min(Ans,ddd[i]+Min[K-dd[i]]);",
            "\t\t\tfor(Re i=1;i<=dd[0];++i)Min[dd[i]]=min(Min[dd[i]],ddd[i]),tmp[++tmp[0]]=dd[i];",
            "\t\t}",
            "\tfor(Re i=1;i<=tmp[0];++i)Min[tmp[i]]=inf;",
            "}",
            "inline void sakura(Re x){",
            "\tRe now=sum;vis[x]=1,calc(x);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to])",
            "\t\t\tsum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,x),sakura(rt);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(K),m=n-1;",
            "\tfor(Re i=0;i<=K;++i)Min[i]=inf;",
            "\twhile(m--)in(x),in(y),in(z),++x,++y,add(x,y,z),add(y,x,z);",
            "\tAns=inf,sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);",
            "\tprintf(\"%d\\n\",(Ans==inf)?-1:Ans);",
            "}",
            ""
        ],
        "description": "插入 Race"
    },
    "点分树-在线求原树距离-BIT": {
        "prefix": "acm-4.3求距离小于等于K的点权值之和 震波",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<vector>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,inf=2e9,logN=17;",
            "int n,m,o,x,y,T,op,lastans,A[N],deep[N],head[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct LCA{",
            "\tint fa[N],top[N],son[N],size[N];",
            "\tinline void dfs1(Re x,Re Fa){",
            "\t\tsize[x]=1,deep[x]=deep[fa[x]=Fa]+1;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=Fa){",
            "\t\t\t\tdfs1(to,x),size[x]+=size[to];",
            "\t\t\t\tif(size[son[x]]<size[to])son[x]=to;",
            "\t\t\t}",
            "\t}",
            "\tinline void dfs2(Re x,Re rt){",
            "\t\ttop[x]=rt;",
            "\t\tif(!son[x])return;",
            "\t\tdfs2(son[x],rt);",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=fa[x]&&to!=son[x])dfs2(to,to);",
            "\t}",
            "\tinline void build(){dfs1(1,0),dfs2(1,1);}",
            "\tinline int lca(Re x,Re y){",
            "\t\twhile(top[x]!=top[y]){",
            "\t\t\tif(deep[top[x]]<deep[top[y]])swap(x,y);",
            "\t\t\tx=fa[top[x]];",
            "\t\t}",
            "\t\tif(deep[x]>deep[y])swap(x,y);",
            "\t\treturn x;",
            "\t}",
            "}T1;",
            "inline int Dis(Re x,Re y){return deep[x]+deep[y]-(deep[T1.lca(x,y)]<<1);}",
            "struct BIT{",
            "\tint n;vector<int>C;",
            "\tinline void build(Re N){C.resize((n=N)+1);}",
            "\tinline void add(Re x,Re v){++x;while(x<=n)C[x]+=v,x+=x&-x;}",
            "\tinline int ask(Re x){++x,x=min(x,n);Re ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}",
            "}TR1[N],TR2[N];",
            "int rt,sum,fa[N],vis[N],maxp[N],size[N];",
            "inline void getrt(Re x,Re fa){",
            "\tsize[x]=1,maxp[x]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)",
            "\t\t\tgetrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);",
            "\tmaxp[x]=max(maxp[x],sum-size[x]);",
            "\tif(maxp[x]<maxp[rt])rt=x;",
            "}",
            "inline void sakura(Re x,Re Fa){",
            "\tRe now=sum;vis[x]=1,fa[x]=Fa;",
            "\tTR1[x].build(now/2+1),TR2[x].build(now+1);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to])",
            "\t\t\tsum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0),sakura(rt,x);",
            "}",
            "inline void change(Re x,Re v){",
            "\tTR1[x].add(0,v);//subtree(x)",
            "\tfor(Re i=x;fa[i];i=fa[i]){",
            "\t\tRe tmp=Dis(x,fa[i]);",
            "\t\tTR1[fa[i]].add(tmp,v);",
            "\t\tTR2[i].add(tmp,v);",
            "\t}",
            "}",
            "inline int ask(Re x,Re K){",
            "\tRe ans=TR1[x].ask(K);//subtree(x)",
            "\tfor(Re i=x;fa[i];i=fa[i]){",
            "\t\tRe tmp=Dis(x,fa[i]);if(tmp>K)continue;",
            "\t\tans+=TR1[fa[i]].ask(K-tmp);",
            "\t\tans-=TR2[i].ask(K-tmp);",
            "\t}",
            "\treturn ans;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),m=n-1;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tT1.build(),sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt,0);",
            "\tfor(Re i=1;i<=n;++i)change(i,A[i]);",
            "\twhile(T--){",
            "\t\tin(op),in(x),in(y),x^=lastans,y^=lastans;",
            "\t\tif(op)change(x,y-A[x]),A[x]=y;",
            "\t\telse printf(\"%d\\n\",lastans=ask(x,y));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 点分树-在线求原树距离-BIT"
    },
    "点分树-在线求原树距离-Seg": {
        "prefix": "acm-4.3求距离小于等于K的点权值之和 震波",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,inf=2e9,logN=17;",
            "int n,m,o,x,y,T,op,lastans,A[N],deep[N],head[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct LCA{",
            "\tint fa[N],top[N],son[N],size[N];",
            "\tinline void dfs1(Re x,Re Fa){",
            "\t\tsize[x]=1,deep[x]=deep[fa[x]=Fa]+1;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=Fa){",
            "\t\t\t\tdfs1(to,x),size[x]+=size[to];",
            "\t\t\t\tif(size[son[x]]<size[to])son[x]=to;",
            "\t\t\t}",
            "\t}",
            "\tinline void dfs2(Re x,Re rt){",
            "\t\ttop[x]=rt;",
            "\t\tif(!son[x])return;",
            "\t\tdfs2(son[x],rt);",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif((to=a[i].to)!=fa[x]&&to!=son[x])dfs2(to,to);",
            "\t}",
            "\tinline void build(){dfs1(1,0),dfs2(1,1);}",
            "\tinline int lca(Re x,Re y){",
            "\t\twhile(top[x]!=top[y]){",
            "\t\t\tif(deep[top[x]]<deep[top[y]])swap(x,y);",
            "\t\t\tx=fa[top[x]];",
            "\t\t}",
            "\t\tif(deep[x]>deep[y])swap(x,y);",
            "\t\treturn x;",
            "\t}",
            "}T1;",
            "inline int Dis(Re x,Re y){return deep[x]+deep[y]-(deep[T1.lca(x,y)]<<1);}",
            "int pt[N<<1];",
            "struct Segment_Tree{",
            "\t#define pl tr[p].lp",
            "\t#define pr tr[p].rp",
            "\t#define mid (L+R>>1)",
            "\tint O;",
            "\tstruct QAQ{int S,lp,rp;}tr[N*60];",
            "\tinline void change(Re &p,Re L,Re R,Re x,Re v){",
            "\t\tif(!p)p=++O;",
            "\t\tif(L==R){tr[p].S+=v;return;}",
            "\t\tif(x<=mid)change(pl,L,mid,x,v);",
            "\t\telse change(pr,mid+1,R,x,v);",
            "\t\ttr[p].S=tr[pl].S+tr[pr].S;",
            "\t}",
            "\tinline int ask(Re p,Re L,Re R,Re l,Re r){",
            "\t\tif(!p)return 0;",
            "\t\tif(l<=L&&R<=r)return tr[p].S;",
            "\t\tRe ans=0;",
            "\t\tif(l<=mid)ans+=ask(pl,L,mid,l,r);",
            "\t\tif(r>mid)ans+=ask(pr,mid+1,R,l,r);",
            "\t\treturn ans;",
            "\t}",
            "}TR;",
            "int rt,sum,fa[N],vis[N],maxp[N],size[N];",
            "inline void getrt(Re x,Re fa){",
            "\tsize[x]=1,maxp[x]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)",
            "\t\t\tgetrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);",
            "\tmaxp[x]=max(maxp[x],sum-size[x]);",
            "\tif(maxp[x]<maxp[rt])rt=x;",
            "}",
            "inline void sakura(Re x,Re Fa){",
            "\tRe now=sum;vis[x]=1,fa[x]=Fa;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to])",
            "\t\t\tsum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0),sakura(rt,x);",
            "}",
            "inline void change(Re x,Re v){",
            "\tTR.change(pt[x],0,n,0,v);",
            "\tfor(Re i=x;fa[i];i=fa[i]){",
            "\t\tRe tmp=Dis(x,fa[i]);",
            "\t\tTR.change(pt[fa[i]],0,n,tmp,v);",
            "\t\tTR.change(pt[i+n],0,n,tmp,v);",
            "\t}",
            "}",
            "inline int ask(Re x,Re K){",
            "\tRe ans=TR.ask(pt[x],0,n,0,K);",
            "\tfor(Re i=x;fa[i];i=fa[i]){",
            "\t\tRe tmp=Dis(x,fa[i]);if(tmp>K)continue;",
            "\t\tans+=TR.ask(pt[fa[i]],0,n,0,K-tmp);",
            "\t\tans-=TR.ask(pt[i+n],0,n,0,K-tmp);",
            "\t}",
            "\treturn ans;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),m=n-1;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tT1.build(),sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt,0);",
            "\tfor(Re i=1;i<=n;++i)change(i,A[i]);",
            "\twhile(T--){",
            "\t\tin(op),in(x),in(y),x^=lastans,y^=lastans;",
            "\t\tif(op)change(x,y-A[x]),A[x]=y;",
            "\t\telse printf(\"%d\\n\",lastans=ask(x,y));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 点分树-在线求原树距离-Seg"
    },
    "点分树-预处理原树距离-BIT": {
        "prefix": "acm-4.3求距离小于等于K的点权值之和 震波",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<vector>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,inf=2e9,logN=17;",
            "int n,m,o,x,y,T,op,lastans,A[N],head[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct BIT{",
            "\tint n;vector<int>C;",
            "\tinline void build(Re N){C.resize((n=N)+1);}",
            "\tinline void add(Re x,Re v){++x;while(x<=n)C[x]+=v,x+=x&-x;}",
            "\tinline int ask(Re x){++x,x=min(x,n);Re ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}",
            "}TR1[N],TR2[N];",
            "int rt,sum,gs[N],vis[N],maxp[N],size[N],frt[N][20],fdis[N][20];",
            "inline void getrt(Re x,Re fa){",
            "\tsize[x]=1,maxp[x]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)",
            "\t\t\tgetrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);",
            "\tmaxp[x]=max(maxp[x],sum-size[x]);",
            "\tif(maxp[x]<maxp[rt])rt=x;",
            "}",
            "inline void getdis(Re x,Re rt,Re fa,Re d){",
            "\tfrt[x][++gs[x]]=rt,fdis[x][gs[x]]=d;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)getdis(to,rt,x,d+1);",
            "}",
            "inline void sakura(Re x){",
            "\tRe now=sum;vis[x]=1,getdis(x,x,0,0);",
            "\tTR1[x].build(now/2+1),TR2[x].build(now+1);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to])",
            "\t\t\tsum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0),sakura(rt);",
            "}",
            "inline void change(Re x,Re v){",
            "\tTR1[x].add(0,v);//subtree(x)",
            "\tfor(Re i=gs[x];i>=2;--i){",
            "\t\tRe tmp=fdis[x][i-1];",
            "\t\tTR1[frt[x][i-1]].add(tmp,v);",
            "\t\tTR2[frt[x][i]].add(tmp,v);",
            "\t}",
            "}",
            "inline int ask(Re x,Re K){",
            "\tRe ans=TR1[x].ask(K);//subtree(x)",
            "\tfor(Re i=gs[x];i>=2;--i){",
            "\t\tRe tmp=fdis[x][i-1];if(tmp>K)continue;",
            "\t\tans+=TR1[frt[x][i-1]].ask(K-tmp);",
            "\t\tans-=TR2[frt[x][i]].ask(K-tmp);",
            "\t}",
            "\treturn ans;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),m=n-1;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tsum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);",
            "\tfor(Re i=1;i<=n;++i)change(i,A[i]);",
            "\twhile(T--){",
            "\t\tin(op),in(x),in(y),x^=lastans,y^=lastans;",
            "\t\tif(op)change(x,y-A[x]),A[x]=y;",
            "\t\telse printf(\"%d\\n\",lastans=ask(x,y));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 点分树-预处理原树距离-BIT"
    },
    "点分树-预处理原树距离-Seg": {
        "prefix": "acm-4.3求距离小于等于K的点权值之和 震波",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,inf=2e9,logN=17;",
            "int n,m,o,x,y,T,op,lastans,A[N],head[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int pt[N<<1];",
            "struct Segment_Tree{",
            "\t#define pl tr[p].lp",
            "\t#define pr tr[p].rp",
            "\t#define mid (L+R>>1)",
            "\tint O;",
            "\tstruct QAQ{int S,lp,rp;}tr[N*60];",
            "\tinline void change(Re &p,Re L,Re R,Re x,Re v){",
            "\t\tif(!p)p=++O;",
            "\t\tif(L==R){tr[p].S+=v;return;}",
            "\t\tif(x<=mid)change(pl,L,mid,x,v);",
            "\t\telse change(pr,mid+1,R,x,v);",
            "\t\ttr[p].S=tr[pl].S+tr[pr].S;",
            "\t}",
            "\tinline int ask(Re p,Re L,Re R,Re l,Re r){",
            "\t\tif(!p)return 0;",
            "\t\tif(l<=L&&R<=r)return tr[p].S;",
            "\t\tRe ans=0;",
            "\t\tif(l<=mid)ans+=ask(pl,L,mid,l,r);",
            "\t\tif(r>mid)ans+=ask(pr,mid+1,R,l,r);",
            "\t\treturn ans;",
            "\t}",
            "}TR;",
            "int rt,sum,gs[N],vis[N],maxp[N],size[N],frt[N][20],fdis[N][20];",
            "inline void getrt(Re x,Re fa){",
            "\tsize[x]=1,maxp[x]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)",
            "\t\t\tgetrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);",
            "\tmaxp[x]=max(maxp[x],sum-size[x]);",
            "\tif(maxp[x]<maxp[rt])rt=x;",
            "}",
            "inline void getdis(Re x,Re rt,Re fa,Re d){",
            "\tfrt[x][++gs[x]]=rt,fdis[x][gs[x]]=d;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)getdis(to,rt,x,d+1);",
            "}",
            "inline void sakura(Re x){",
            "\tRe now=sum;vis[x]=1,getdis(x,x,0,0);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to])",
            "\t\t\tsum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0),sakura(rt);",
            "}",
            "inline void change(Re x,Re v){",
            "\tTR.change(pt[x],0,n,0,v);",
            "\tfor(Re i=gs[x];i>=2;--i){",
            "\t\tRe tmp=fdis[x][i-1];",
            "\t\tTR.change(pt[frt[x][i-1]],0,n,tmp,v);",
            "\t\tTR.change(pt[frt[x][i]+n],0,n,tmp,v);",
            "\t}",
            "}",
            "inline int ask(Re x,Re K){",
            "\tRe ans=TR.ask(pt[x],0,n,0,K);",
            "\tfor(Re i=gs[x];i>=2;--i){",
            "\t\tRe tmp=fdis[x][i-1];if(tmp>K)continue;",
            "\t\tans+=TR.ask(pt[frt[x][i-1]],0,n,0,K-tmp);",
            "\t\tans-=TR.ask(pt[frt[x][i]+n],0,n,0,K-tmp);",
            "\t}",
            "\treturn ans;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),m=n-1;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tsum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);",
            "\tfor(Re i=1;i<=n;++i)change(i,A[i]);",
            "\twhile(T--){",
            "\t\tin(op),in(x),in(y),x^=lastans,y^=lastans;",
            "\t\tif(op)change(x,y-A[x]),A[x]=y;",
            "\t\telse printf(\"%d\\n\",lastans=ask(x,y));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 点分树-预处理原树距离-Seg"
    },
    "点分治  (询问是否有长度等于K的路径)": {
        "prefix": "acm-4.3分各子树求解",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e4+3,M=103,INF=1e7+3,inf=2e9;",
            "int n,m,o,x,y,z,T,maxK,K[M],Ans[M],head[N];",
            "struct QAQ{int w,to,next;}a[N<<1];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int rt,sum,dd[N],vis[N],tmp[N],dis[N],maxp[N],size[N];bool judge[INF];",
            "inline void getrt(Re x,Re fa){",
            "\tsize[x]=1,maxp[x]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)",
            "\t\t\tgetrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);",
            "\tmaxp[x]=max(maxp[x],sum-size[x]);",
            "\tif(maxp[x]<maxp[rt])rt=x;",
            "}",
            "inline void getdis(Re x,Re fa,Re w){",
            "\tif(dis[fa]+w>maxK)return;",
            "\tdd[++dd[0]]=dis[x]=dis[fa]+w;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)getdis(to,x,a[i].w);",
            "}",
            "inline void calc(Re x){",
            "\ttmp[0]=0,judge[tmp[++tmp[0]]=0]=1;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]){",
            "\t\t\tdis[x]=dd[0]=0,getdis(to,x,a[i].w);",
            "\t\t\tfor(Re j=1;j<=dd[0];++j)",
            "\t\t\t\tfor(Re k=1;k<=T;++k)",
            "\t\t\t\t\tif(K[k]>=dd[j])Ans[k]|=judge[K[k]-dd[j]];",
            "\t\t\tfor(Re j=1;j<=dd[0];++j)judge[tmp[++tmp[0]]=dd[j]]=1;",
            "\t\t}",
            "\tfor(Re i=1;i<=tmp[0];++i)judge[tmp[i]]=0;",
            "}",
            "inline void sakura(Re x){",
            "\tRe now=sum;vis[x]=1,calc(x);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to])",
            "\t\t\tsum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,x),sakura(rt);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),m=n-1;",
            "\twhile(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);",
            "\tfor(Re i=1;i<=T;++i)in(K[i]),maxK=max(maxK,K[i]);",
            "\tsum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);",
            "\tfor(Re i=1;i<=T;++i)puts(Ans[i]?\"AYE\":\"NAY\");",
            "}",
            ""
        ],
        "description": "插入 点分治  (询问是否有长度等于K的路径)"
    },
    "点分治  (长度小于等于K的路径数 Tree)": {
        "prefix": "acm-4.3容斥",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=4e4+3,inf=2e9;",
            "int n,m,o,x,y,z,K,head[N];LL Ans;",
            "struct QAQ{int w,to,next;}a[N<<1];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int rt,sum,cnt,tmp[N],dis[N],vis[N],maxp[N],size[N];",
            "inline void getrt(Re x,Re fa){",
            "\tsize[x]=1,maxp[x]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)",
            "\t\t\tgetrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);",
            "\tmaxp[x]=max(maxp[x],sum-size[x]);",
            "\tif(maxp[x]<maxp[rt])rt=x;",
            "}",
            "inline void getdis(Re x,Re fa,Re w){",
            "\tif(dis[fa]+w>K)return;",
            "\ttmp[++cnt]=dis[x]=dis[fa]+w;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)getdis(to,x,a[i].w);",
            "}",
            "inline int calc(Re x,Re d){",
            "\tRe ans=0;cnt=0,tmp[++cnt]=dis[x]=d;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to])getdis(to,x,a[i].w);",
            "\tsort(tmp+1,tmp+cnt+1);",
            "\tRe R=cnt;",
            "\tfor(Re i=1;i<=cnt&&i<R;++i){",
            "\t\twhile(i<R&tmp[i]+tmp[R]>K)--R;",
            "\t\tif(i<R)ans+=(R-(i+1)+1);",
            "\t}",
            "\treturn ans;",
            "}",
            "inline void sakura(Re x){",
            "\tRe now=sum;vis[x]=1,Ans+=calc(x,0);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to])",
            "\t\t\tAns-=calc(to,a[i].w),sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,x),sakura(rt);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),m=n-1;",
            "\twhile(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);",
            "\tin(K);",
            "\tsum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);",
            "\tprintf(\"%lld\\n\",Ans);",
            "}",
            ""
        ],
        "description": "插入 点分治  (长度小于等于K的路径数 Tree)"
    },
    "幻想乡战略游戏": {
        "prefix": "acm-4.3点分树",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<vector>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,inf=2e9;",
            "int n,m,o,x,y,z,T,root,A[N],head[N];",
            "struct QAQ{int w,to,next;}a[N<<1];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct TREE{",
            "\tint o,head[N];",
            "\tstruct QAQ{int rt,to,next;}a[N];",
            "\tinline void add(Re x,Re y,Re z){a[++o].rt=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "}T0;",
            "int rt,sum,Sv[N],gs[N],vis[N],size[N],maxp[N],frt[N][20],fdis[N][20];LL Sdv1[N],Sdv2[N];",
            "inline void getrt(Re x,Re fa){",
            "\tsize[x]=1,maxp[x]=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)",
            "\t\t\tgetrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);",
            "\tmaxp[x]=max(maxp[x],sum-size[x]);",
            "\tif(maxp[x]<maxp[rt])rt=x;",
            "}",
            "inline void getdis(Re x,Re rt,Re fa,Re d){",
            "\tif(x!=rt)frt[x][++gs[x]]=rt,fdis[x][gs[x]]=d;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to]&&to!=fa)getdis(to,rt,x,d+a[i].w);",
            "}",
            "inline void sakura(Re x){",
            "\tRe now=sum;vis[x]=1,getdis(x,x,0,0);",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif(!vis[to=a[i].to])",
            "\t\t\tsum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0),T0.add(x,to,rt),sakura(rt);",
            "}",
            "inline void change(Re x,Re v){",
            "\tSdv1[x]+=v*0,Sv[x]+=v;",
            "\tfor(Re i=gs[x];i>=2;--i){",
            "\t\tRe tmp=fdis[x][i-1];",
            "\t\tSdv1[frt[x][i-1]]+=(LL)v*tmp;",
            "\t\tSdv2[frt[x][i]]+=(LL)v*tmp;",
            "\t\tSv[frt[x][i-1]]+=v;",
            "\t}",
            "}",
            "inline LL ask(Re x){",
            "\tLL ans=Sdv1[x];",
            "\tfor(Re i=gs[x];i>=2;--i){",
            "\t\tRe tmp=fdis[x][i-1];",
            "\t\tans+=Sdv1[frt[x][i-1]];",
            "\t\tans-=Sdv2[frt[x][i]];",
            "\t\tans+=(LL)(Sv[frt[x][i-1]]-Sv[frt[x][i]])*tmp;",
            "\t}",
            "\treturn ans;",
            "}",
            "inline LL find(Re x){",
            "\tLL tmp=ask(x);",
            "\tfor(Re i=T0.head[x];i;i=T0.a[i].next)",
            "\t\tif(ask(T0.a[i].to)<tmp)return find(T0.a[i].rt);",
            "\treturn tmp;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),m=n-1;",
            "\twhile(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);",
            "\tsum=n,maxp[rt=0]=inf,getrt(1,0),sakura(root=rt);",
            "\tfor(Re i=1;i<=n;++i)frt[i][++gs[i]]=i;",
            "\twhile(T--)in(x),in(y),change(x,y),printf(\"%lld\\n\",find(root));",
            "}",
            ""
        ],
        "description": "插入 幻想乡战略游戏"
    },
    "线段树优化建边+Dijkstra最短路": {
        "prefix": "acm-3.7Legacy",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "const LL inf=1e18;",
            "int n,m,x,y,w,l,r,o,op,st,head[N<<3];bool pan[N<<3];LL dis[N<<3];",
            "struct QAQ{int w,to,next;}a[(N<<3)+(N<<2)+N*18*2];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tint O;",
            "\tstruct QAQ{int in,out;}tr[N<<2];",
            "\tinline void build(Re p,Re L,Re R){",
            "\t\tif(L==R){tr[p].in=tr[p].out=L;return;}",
            "\t\ttr[p].in=++O,tr[p].out=++O,add(tr[p].in,tr[p].out,0);",
            "\t\tbuild(pl,L,mid),build(pr,mid+1,R);",
            "\t\tadd(tr[p].in,tr[pl].in,0),add(tr[p].in,tr[pr].in,0);",
            "\t\tadd(tr[pl].out,tr[p].out,0),add(tr[pr].out,tr[p].out,0);",
            "\t}",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re w,Re op){",
            "\t\tif(l<=L&&R<=r){",
            "\t\t\tif(op)add(tr[p].out,x,w);",
            "\t\t\telse add(x,tr[p].in,w);",
            "\t\t\treturn;",
            "\t\t}",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,x,w,op);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,x,w,op);",
            "\t}",
            "}TR;",
            "struct QWQ{int x;LL d;inline bool operator<(const QWQ &O)const{return d>O.d;}};",
            "priority_queue<QWQ>Q;",
            "inline void dijkstra(Re st){",
            "\tfor(Re i=1;i<=TR.O;++i)dis[i]=inf;",
            "\tQ.push((QWQ){st,dis[st]=0});",
            "\twhile(!Q.empty()){",
            "\t\tRe x=Q.top().x;Q.pop();",
            "\t\tif(pan[x])continue;",
            "\t\tpan[x]=0;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(dis[to=a[i].to]>dis[x]+a[i].w)",
            "\t\t\t\tQ.push((QWQ){to,dis[to]=dis[x]+a[i].w});",
            "\t}",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),in(st);",
            "\tTR.O=n,TR.build(1,1,n);",
            "\twhile(m--){",
            "\t\tin(op),in(x);",
            "\t\tif(op<2)in(y),in(w),TR.change(1,1,n,y,y,x,w,0);",
            "\t\telse if(op<3)in(l),in(r),in(w),TR.change(1,1,n,l,r,x,w,0);",
            "\t\telse in(l),in(r),in(w),TR.change(1,1,n,l,r,x,w,1);",
            "\t}",
            "\tdijkstra(st);",
            "\tfor(Re i=1;i<=n;++i)printf(\"%lld \",dis[i]==inf?-1:dis[i]);",
            "}",
            ""
        ],
        "description": "插入 线段树优化建边+Dijkstra最短路"
    },
    "线段树优化建边+Dinic最大流": {
        "prefix": "acm-3.7Last chance",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5003+3,M=25e4+3,inf=2e9;",
            "int n,m,x,y,z,O,op,st,ed,X[N],Y[N],Z[N],Ans[N],cnt[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Network_Flow{",
            "\tint o,h,t,maxflow,Q[N*3],dis[N*3],cur[N*3],head[N*3];",
            "\tstruct QAQ{int to,next,flow;}a[M<<1];",
            "\tinline void add_(Re x,Re y,Re flow){a[++o].to=y,a[o].flow=flow,a[o].next=head[x],head[x]=o;}",
            "\tinline void add(Re x,Re y,Re flow){add_(x,y,flow),add_(y,x,0);}",
            "\tinline int bfs(Re st,Re ed){",
            "\t\tfor(Re i=0;i<=ed;++i)dis[i]=0,cur[i]=head[i];",
            "\t\th=1,t=0,dis[Q[++t]=st]=1;",
            "\t\twhile(h<=t){",
            "\t\t\tRe x=Q[h++];",
            "\t\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\t\tif(a[i].flow&&!dis[to=a[i].to]){",
            "\t\t\t\t\tdis[Q[++t]=to]=dis[x]+1;",
            "\t\t\t\t\tif(to==ed)return 1;",
            "\t\t\t\t}",
            "\t\t}",
            "\t\treturn 0;",
            "\t}",
            "\tinline int dfs(Re x,Re flow){",
            "\t\tif(x==ed||!flow)return flow;",
            "\t\tRe tmp=0,to,f;",
            "\t\tfor(Re i=cur[x];i;i=a[i].next){",
            "\t\t\tcur[x]=i;",
            "\t\t\tif(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(a[i].flow,flow-tmp)))){",
            "\t\t\t\ta[i].flow-=f,a[i^1].flow+=f,tmp+=f;",
            "\t\t\t\tif(tmp==flow)break;",
            "\t\t\t}",
            "\t\t}",
            "\t\treturn tmp;",
            "\t}",
            "\tinline void dinic(Re st,Re ed){while(bfs(st,ed))maxflow+=dfs(st,inf);}",
            "\tinline int find(Re x){",
            "\t\tRe last=ed;",
            "\t\twhile(x<=O||x>O+n){",
            "\t\t\tfor(Re i=head[x];i;i=a[i].next)",
            "\t\t\t\tif(a[i^1].to==x&&a[i].to!=last&&a[i].flow){",
            "\t\t\t\t\t--a[i].flow,last=x,x=a[i].to;break;",
            "\t\t\t\t}",
            "\t\t}",
            "\t\treturn x-O;",
            "\t}",
            "}T1;",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tstruct QAQ{int in;}tr[N<<2];",
            "\tinline void build(Re p,Re L,Re R){",
            "\t\tif(L==R){tr[p].in=L;return;}",
            "\t\ttr[p].in=++O,build(pl,L,mid),build(pr,mid+1,R);",
            "\t\tT1.add(tr[p].in,tr[pl].in,inf),T1.add(tr[p].in,tr[pr].in,inf);",
            "\t}",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re w){",
            "\t\tif(l<=L&&R<=r){T1.add(x,tr[p].in,w);return;}",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,x,w);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,x,w);",
            "\t}",
            "}TR;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),T1.o=1,O=m,TR.build(1,1,m),st=O+n+1,ed=st+1;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tin(op);",
            "\t\tif(op<1){",
            "\t\t\tin(x),T1.add(st,O+i,1);",
            "\t\t\twhile(x--)in(y),T1.add(O+i,y,1);",
            "\t\t}",
            "\t\telse if(op<2)in(x),in(y),T1.add(st,O+i,1),TR.change(1,1,m,x,y,O+i,1);",
            "\t\telse{",
            "\t\t\tin(x),in(y),in(z),T1.add(st,O+i,2),X[i]=x,Y[i]=y,Z[i]=z;",
            "\t\t\tT1.add(O+i,x,1),T1.add(O+i,y,1),T1.add(O+i,z,1);",
            "\t\t}",
            "\t}",
            "\tfor(Re j=1;j<=m;++j)T1.add(j,ed,1);",
            "\tT1.dinic(st,ed),printf(\"%d\\n\",T1.maxflow);",
            "\tfor(Re i=T1.head[ed];i;i=T1.a[i].next)",
            "\t\tif(T1.a[i].flow)++cnt[Ans[T1.a[i].to]=T1.find(T1.a[i].to)];",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tif(X[i]&&cnt[i]==1){",
            "\t\t\tif(Ans[X[i]]==i)Ans[Y[i]]=i;",
            "\t\t\telse Ans[X[i]]=i;",
            "\t\t}",
            "\tfor(Re i=1;i<=m;++i)if(Ans[i])printf(\"%d %d\\n\",Ans[i],i);",
            "}",
            ""
        ],
        "description": "插入 线段树优化建边+Dinic最大流"
    },
    "线段树优化建边+Tarjan缩点": {
        "prefix": "acm-3.7炸弹",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#include<map>",
            "#define LL long long",
            "#define Re register int",
            "#define mp make_pair",
            "using namespace std;",
            "const int N=5e5+3,M=(N<<2)+N*18*2,P=1e9+7;",
            "int o,n,Ans,head[N<<2];LL X[N],R[N];",
            "struct QAQ{int x,to,next;}a[M];map<pair<int,int>,int>vis;",
            "inline void add(Re x,Re y){a[++o].x=x,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "template<typename T>inline void in(T &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tint O;",
            "\tstruct QAQ{int in;}tr[N<<2];",
            "\tinline void build(Re p,Re L,Re R){",
            "\t\tif(L==R){tr[p].in=L;return;}",
            "\t\ttr[p].in=++O;",
            "\t\tbuild(pl,L,mid),build(pr,mid+1,R);",
            "\t\tadd(tr[p].in,tr[pl].in),add(tr[p].in,tr[pr].in);",
            "\t}",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Re x){",
            "//\t\tprintf(\"(x=%d) -> (l=%d,r=%d) w=%d\\n\",x,l,r,w);return;",
            "\t\tif(l<=L&&R<=r){add(x,tr[p].in);return;}",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,x);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,x);",
            "\t}",
            "}TR;",
            "inline int find1(LL x,Re r){",
            "\tRe l=1;",
            "\twhile(l<r){",
            "\t\tRe Mid=l+r>>1;",
            "\t\tif(X[Mid]<x)l=Mid+1;",
            "\t\telse r=Mid;",
            "\t}",
            "\treturn r;",
            "}",
            "inline int find2(LL x,Re l){",
            "\tRe r=n;",
            "\twhile(l<r){",
            "\t\tRe Mid=l+r+1>>1;",
            "\t\tif(X[Mid]>x)r=Mid-1;",
            "\t\telse l=Mid;",
            "\t}",
            "\treturn l;",
            "}",
            "struct Tuopu{",
            "\tint o,n,L[N<<2],R[N<<2],ru[N<<2],pan[N<<2],head[N<<2];queue<int>Q;",
            "\tstruct QAQ{int to,next;}a[M];",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void dfs(Re x){",
            "\t\tif(pan[x])return;",
            "\t\tpan[x]=1;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tdfs(to=a[i].to),L[x]=min(L[x],L[to]),R[x]=max(R[x],R[to]);",
            "\t}",
            "\tinline void sakura(){for(Re i=1;i<=n;++i)if(!ru[i])dfs(i);}",
            "}T2;",
            "int Q_o,ip[N<<2];",
            "struct Tarjan{",
            "\tint n,t,dfn_o,Q[N<<2],low[N<<2],dfn[N<<2],pan[N<<2];",
            "\tinline void tarjan(Re x){",
            "\t\tdfn[x]=low[x]=++dfn_o,Q[++t]=x,pan[x]=1;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(!dfn[to=a[i].to])tarjan(to),low[x]=min(low[x],low[to]);",
            "\t\t\telse if(pan[to])low[x]=min(low[x],dfn[to]);",
            "\t\tif(low[x]==dfn[x]){",
            "\t\t\t++Q_o,T2.L[Q_o]=n+1,T2.R[Q_o]=-1;",
            "\t\t\twhile(1){",
            "\t\t\t\tip[Q[t]]=Q_o,pan[Q[t]]=0;",
            "\t\t\t\tif(x==Q[t--])break;",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "\tinline void sakura(){",
            "\t\tfor(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i);",
            "\t\tfor(Re i=1,x,y;i<=o;++i)",
            "\t\t\tif((x=ip[a[i].x])!=(y=ip[a[i].to])&&!vis[mp(x,y)])",
            "\t\t\t\tvis[mp(x,y)]=1,++T2.ru[y],T2.add(x,y);",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),TR.O=n,TR.build(1,1,n);",
            "\tfor(Re i=1;i<=n;++i)in(X[i]),in(R[i]);",
            "\tfor(Re i=1;i<=n;++i)TR.change(1,1,n,find1(X[i]-R[i],i),find2(X[i]+R[i],i),i);",
            "\tT1.n=TR.O,T1.sakura();",
            "\tfor(Re i=1;i<=n;++i)T2.L[ip[i]]=min(T2.L[ip[i]],i),T2.R[ip[i]]=max(T2.R[ip[i]],i);;",
            "\tT2.n=Q_o,T2.sakura();",
            "\tfor(Re i=1;i<=n;++i)(Ans+=(LL)i*(T2.R[ip[i]]-T2.L[ip[i]]+1)%P)%=P;",
            "\tprintf(\"%d\\n\",Ans);",
            "}",
            ""
        ],
        "description": "插入 线段树优化建边+Tarjan缩点"
    },
    "最大流  (m n^2)": {
        "prefix": "acm-3.5Dinic+多路增广+当前弧",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e4+5,M=1e5+5,inf=2147483647;",
            "int x,y,z,n,m,s,t,st,ed;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Dinic{",
            "\tint o,h,t,Q[N],dis[N],cur[N],head[N];LL maxflow;",
            "\tDinic(){o=1;}",
            "\tstruct QAQ{int to,next,flow;}a[M<<1];",
            "\tinline void add_(Re x,Re y,Re flow){a[++o].to=y,a[o].flow=flow,a[o].next=head[x],head[x]=o;}",
            "\tinline void add(Re x,Re y,Re flow){add_(x,y,flow),add_(y,x,0);}",
            "\tinline int bfs(Re st,Re ed){",
            "\t\tfor(Re i=0;i<=ed;++i)dis[i]=0,cur[i]=head[i];",
            "\t\th=1,t=0,Q[++t]=st,dis[st]=1;",
            "\t\twhile(h<=t){",
            "\t\t\tRe x=Q[h++];",
            "\t\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\t\tif(a[i].flow&&!dis[to=a[i].to]){",
            "\t\t\t\t\tdis[to]=dis[x]+1,Q[++t]=to;",
            "\t\t\t\t\tif(to==ed)return 1;",
            "\t\t\t\t}",
            "\t\t}",
            "\t\treturn 0;",
            "\t}",
            "\tinline int dfs(Re x,Re flow){",
            "\t\tif(x==ed||!flow)return flow;",
            "\t\tRe tmp=0,to,f;",
            "\t\tfor(Re i=cur[x];i;i=a[i].next){",
            "\t\t\tcur[x]=i;",
            "\t\t\tif(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(flow-tmp,a[i].flow)))){",
            "\t\t\t\ta[i].flow-=f,a[i^1].flow+=f,tmp+=f;",
            "\t\t\t\tif(flow==tmp)break;",
            "\t\t\t}",
            "\t\t}",
            "\t\treturn tmp;",
            "\t}",
            "\tinline void dinic(Re st,Re ed){while(bfs(st,ed))maxflow+=dfs(st,inf);}",
            "}T1;",
            "int main(){",
            "    in(n),in(m),in(s),in(t),st=n+1,ed=st+1;",
            "    while(m--)in(x),in(y),in(z),T1.add(x,y,z);",
            "    T1.add(st,s,inf),T1.add(t,ed,inf),T1.dinic(st,ed);",
            "    printf(\"%lld\",T1.maxflow);",
            "}",
            ""
        ],
        "description": "插入 最大流  (m n^2)"
    },
    "最大流  (n m^2)": {
        "prefix": "acm-3.5EK",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e4+3,M=1e5+3,inf=2e9;",
            "int x,y,z,o=1,n,m,h,t,st,ed,Q[N],cyf[N],pan[N],pre[N],head[N];long long maxflow; ",
            "struct QAQ{int to,next,flow;}a[M<<1];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z){a[++o].flow=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline int bfs(Re st,Re ed){",
            "\tfor(Re i=0;i<=n;++i)pan[i]=0;",
            "\th=1,t=0,pan[st]=1,Q[++t]=st,cyf[st]=inf;",
            "\twhile(h<=t){",
            "\t\tRe x=Q[h++];",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(a[i].flow&&!pan[to=a[i].to]){",
            "\t\t\t\tcyf[to]=min(cyf[x],a[i].flow);",
            "\t\t\t\tQ[++t]=to,pre[to]=i,pan[to]=1;",
            "\t\t\t\tif(to==ed)return 1;",
            "\t\t\t}",
            "\t}",
            "\treturn 0;",
            "}",
            "inline void EK(Re st,Re ed){",
            "\twhile(bfs(st,ed)==1){",
            "\t\tRe x=ed;maxflow+=cyf[ed];",
            "\t\twhile(x!=st){",
            "\t\t\tRe i=pre[x];",
            "\t\t\ta[i].flow-=cyf[ed];",
            "\t\t\ta[i^1].flow+=cyf[ed];",
            "\t\t\tx=a[i^1].to;",
            "\t\t}",
            "\t}",
            "}",
            "int main(){",
            "\tin(n),in(m),in(st),in(ed);",
            "\twhile(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,0);",
            "\tEK(st,ed);",
            "\tprintf(\"%lld\",maxflow);",
            "}",
            ""
        ],
        "description": "插入 最大流  (n m^2)"
    },
    "最小割可行边、必须边": {
        "prefix": "acm-3.5add_",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=4003,M=6e4+3,inf=2e9;",
            "int n,m,x,y,z,st,ed;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Dinic{",
            "\tint o,h,t,Q[N],dis[N],cur[N],head[N];",
            "\tstruct QAQ{int to,next,flow;}a[M<<1];",
            "\tinline void add_(Re x,Re y,Re flow){a[++o].to=y,a[o].flow=flow,a[o].next=head[x],head[x]=o;}",
            "\tinline void add(Re x,Re y,Re flow){add_(x,y,flow),add_(y,x,0);}",
            "\tinline int bfs(Re st,Re ed){",
            "\t\tfor(Re i=0;i<=n;++i)dis[i]=0,cur[i]=head[i];",
            "\t\th=1,t=0,dis[st]=1,Q[++t]=st;",
            "\t\twhile(h<=t){",
            "\t\t\tRe x=Q[h++];",
            "\t\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\t\tif(a[i].flow&&!dis[to=a[i].to]){",
            "\t\t\t\t\tdis[to]=dis[x]+1,Q[++t]=to;",
            "\t\t\t\t\tif(to==ed)return 1;",
            "\t\t\t\t}",
            "\t\t}",
            "\t\treturn 0;",
            "\t}",
            "\tinline int dfs(Re x,Re flow){",
            "\t\tif(x==ed||!flow)return flow;",
            "\t\tRe tmp=0,to,f;",
            "\t\tfor(Re i=cur[x];i;i=a[i].next){",
            "\t\t\tcur[x]=i;",
            "\t\t\tif(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(flow-tmp,a[i].flow)))){",
            "\t\t\t\ta[i].flow-=f,a[i^1].flow+=f,tmp+=f;",
            "\t\t\t\tif(flow==tmp)break;",
            "\t\t\t}",
            "\t\t}",
            "\t\treturn tmp;",
            "\t}",
            "\tint Q_o,dfn_O,ip[N],dfn[N],low[N],pan[N];",
            "\tinline void tarjan(Re x){",
            "\t\tdfn[x]=low[x]=++dfn_O,Q[++t]=x,pan[x]=1;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(a[i].flow){",
            "\t\t\t\tif(!dfn[to=a[i].to])tarjan(to),low[x]=min(low[x],low[to]);",
            "\t\t\t\telse if(pan[to])low[x]=min(low[x],dfn[to]);",
            "\t\t\t}",
            "\t\tif(dfn[x]==low[x]){",
            "\t\t\t++Q_o;",
            "\t\t\twhile(1){",
            "\t\t\t\tip[Q[t]]=Q_o,pan[Q[t]]=0;",
            "\t\t\t\tif(x==Q[t--])break;",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "\tinline void sakura(){",
            "\t\twhile(bfs(st,ed))dfs(st,inf);",
            "\t\tfor(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i);",
            "\t\tfor(Re i=2;i<=o;i+=2)printf(\"%d %d\\n\",",
            "\t\t\t(!a[i].flow&&ip[a[i^1].to]!=ip[a[i].to]),",
            "\t\t\t(!a[i].flow&&ip[st]==ip[a[i^1].to]&&ip[a[i].to]==ip[ed]));",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),in(st),in(ed),T1.o=1;",
            "\twhile(m--)in(x),in(y),in(z),T1.add(x,y,z);",
            "\tT1.sakura();",
            "}",
            ""
        ],
        "description": "插入 最小割可行边、必须边"
    },
    "最小费用最大流": {
        "prefix": "acm-3.5EK+SPFA",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5005,M=5e4+5,inf=2e9;",
            "int x,y,z,w,n,m,s,t,st,ed;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct MCMF{",
            "\tint o,h,t,cyf[N],pan[N],pre[N],dis[N],head[N];LL mincost,maxflow;",
            "\tMCMF(){o=1;}",
            "\tstruct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;",
            "\tinline void add_(Re x,Re y,Re flow,Re w){a[++o].w=w,a[o].to=y,a[o].flow=flow,a[o].next=head[x],head[x]=o;}",
            "\tinline void add(Re a,Re b,Re flow,Re w){add_(a,b,flow,w),add_(b,a,0,-w);}",
            "\tinline int SPFA(Re st,Re ed){",
            "\t\tfor(Re i=0;i<=ed;++i)dis[i]=inf,pan[i]=0;",
            "\t\tQ.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;",
            "\t\twhile(!Q.empty()){",
            "\t\t\tRe x=Q.front();Q.pop();pan[x]=0;",
            "\t\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\t\tif(a[i].flow&&dis[to=a[i].to]>dis[x]+a[i].w){",
            "\t\t\t\t\tdis[to]=dis[x]+a[i].w,pre[to]=i;",
            "\t\t\t\t\tcyf[to]=min(cyf[x],a[i].flow);",
            "\t\t\t\t\tif(!pan[to])pan[to]=1,Q.push(to);",
            "\t\t\t\t}",
            "\t\t}",
            "\t\treturn dis[ed]!=inf;",
            "\t}",
            "\tinline void EK(Re st,Re ed){",
            "\t\twhile(SPFA(st,ed)){",
            "\t\t\tRe x=ed;maxflow+=cyf[ed],mincost+=(LL)cyf[ed]*dis[ed];",
            "\t\t\twhile(x!=st){",
            "\t\t\t\tRe i=pre[x];",
            "\t\t\t\ta[i].flow-=cyf[ed];",
            "\t\t\t\ta[i^1].flow+=cyf[ed];",
            "\t\t\t\tx=a[i^1].to;",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),in(s),in(t),st=n+1,ed=st+1;",
            "\twhile(m--)in(x),in(y),in(z),in(w),T1.add(x,y,z,w);",
            "\tT1.add(st,s,inf,0),T1.add(t,ed,inf,0),T1.EK(st,ed);",
            "\tprintf(\"%lld %lld\\n\",T1.maxflow,T1.mincost);",
            "}",
            ""
        ],
        "description": "插入 最小费用最大流"
    },
    "孤岛营救问题  (EK)": {
        "prefix": "acm-3.5MCMF",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<vector>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=2e5,M=2e6+5,inf=2e9;",
            "int T,x,y,z,w,G,o=1,p,n,m,h,t,st,ed,maxp,cyf[N],pan[N],pre[N],dis[N],head[N],Map[11][11][11][11];LL mincost,maxflow; ",
            "struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;vector<int>key[11][11];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}",
            "inline int SPFA(Re st,Re ed){",
            "\tfor(Re i=0;i<=ed;++i)dis[i]=inf,pan[i]=0;",
            "\tQ.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;",
            "\twhile(!Q.empty()){",
            "\t\tRe x=Q.front();Q.pop();pan[x]=0;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(a[i].flow&&dis[to=a[i].to]>dis[x]+a[i].w){",
            "\t\t\t\tdis[to]=dis[x]+a[i].w,pre[to]=i;",
            "\t\t\t\tcyf[to]=min(cyf[x],a[i].flow);",
            "\t\t\t\tif(!pan[to])pan[to]=1,Q.push(to);",
            "\t\t\t}",
            "\t}",
            "\treturn dis[ed]!=inf;",
            "}",
            "inline void EK(Re st,Re ed){",
            "\twhile(SPFA(st,ed)){",
            "\t\tRe x=ed;maxflow+=cyf[ed],mincost+=(LL)cyf[ed]*dis[ed];",
            "\t\twhile(x!=st){",
            "\t\t\tRe i=pre[x];",
            "\t\t\ta[i].flow-=cyf[ed];",
            "\t\t\ta[i^1].flow+=cyf[ed];",
            "\t\t\tx=a[i^1].to;",
            "\t\t}",
            "\t}",
            "}",
            "inline int P(Re x,Re y,Re k){return (x-1)*m+y+k*n*m;}",
            "int main(){",
            "\tin(n),in(m),in(p),maxp=(1<<p)-1;st=(maxp+1)*n*m+1,ed=st+1;",
            "\tin(T);while(T--)in(x),in(y),in(z),in(w),in(G),Map[x][y][z][w]=Map[z][w][x][y]=G?G:-1;",
            "\tin(T);while(T--)in(x),in(y),in(G),key[x][y].push_back(G);",
            "\tadd_(st,P(1,1,0),1,0);",
            "\tfor(Re k=0;k<=maxp;++k)add_(P(n,m,k),ed,1,0);",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\tif(!key[i][j].empty())",
            "\t\t\t\tfor(Re O=0;O<key[i][j].size();++O){",
            "\t\t\t\t\tRe KEY=key[i][j][O];",
            "\t\t\t\t\tfor(Re k=0;k<=maxp;++k){",
            "\t\t\t\t\t\tif(!((k>>KEY-1)&1))add_(P(i,j,k),P(i,j,k|(1<<KEY-1)),inf,0);",
            "\t\t\t\t\t\telse{",
            "\t\t\t\t\t\t\tif(i<n&&Map[i][j][i+1][j]!=-1){",
            "\t\t\t\t\t\t\t\tif(!Map[i][j][i+1][j])add_(P(i,j,k),P(i+1,j,k),inf,1);",
            "\t\t\t\t\t\t\t\telse if((k>>Map[i][j][i+1][j]-1)&1)add_(P(i,j,k),P(i+1,j,k),inf,1);",
            "\t\t\t\t\t\t\t}",
            "\t\t\t\t\t\t\tif(j<m&&Map[i][j][i][j+1]!=-1){",
            "\t\t\t\t\t\t\t\tif(!Map[i][j][i][j+1])add_(P(i,j,k),P(i,j+1,k),inf,1);",
            "\t\t\t\t\t\t\t\telse if((k>>Map[i][j][i][j+1]-1)&1)add_(P(i,j,k),P(i,j+1,k),inf,1);",
            "\t\t\t\t\t\t\t}",
            "\t\t\t\t\t\t\tif(i>1&&Map[i][j][i-1][j]!=-1){",
            "\t\t\t\t\t\t\t\tif(!Map[i][j][i-1][j])add_(P(i,j,k),P(i-1,j,k),inf,1);",
            "\t\t\t\t\t\t\t\telse if((k>>Map[i][j][i-1][j]-1)&1)add_(P(i,j,k),P(i-1,j,k),inf,1);",
            "\t\t\t\t\t\t\t}",
            "\t\t\t\t\t\t\tif(j>1&&Map[i][j][i][j-1]!=-1){",
            "\t\t\t\t\t\t\t\tif(!Map[i][j][i][j-1])add_(P(i,j,k),P(i,j-1,k),inf,1);",
            "\t\t\t\t\t\t\t\telse if((k>>Map[i][j][i][j-1]-1)&1)add_(P(i,j,k),P(i,j-1,k),inf,1);",
            "\t\t\t\t\t\t\t}",
            "\t\t\t\t\t\t}",
            "\t\t\t\t\t}",
            "\t\t\t\t}",
            "\t\t\telse",
            "\t\t\t\tfor(Re k=0;k<=maxp;++k){",
            "\t\t\t\t\tif(i<n&&Map[i][j][i+1][j]!=-1){",
            "\t\t\t\t\t\tif(!Map[i][j][i+1][j])add_(P(i,j,k),P(i+1,j,k),inf,1);",
            "\t\t\t\t\t\telse if((k>>Map[i][j][i+1][j]-1)&1)add_(P(i,j,k),P(i+1,j,k),inf,1);",
            "\t\t\t\t\t}",
            "\t\t\t\t\tif(j<m&&Map[i][j][i][j+1]!=-1){",
            "\t\t\t\t\t\tif(!Map[i][j][i][j+1])add_(P(i,j,k),P(i,j+1,k),inf,1);",
            "\t\t\t\t\t\telse if((k>>Map[i][j][i][j+1]-1)&1)add_(P(i,j,k),P(i,j+1,k),inf,1);",
            "\t\t\t\t\t}",
            "\t\t\t\t\tif(i>1&&Map[i][j][i-1][j]!=-1){",
            "\t\t\t\t\t\tif(!Map[i][j][i-1][j])add_(P(i,j,k),P(i-1,j,k),inf,1);",
            "\t\t\t\t\t\telse if((k>>Map[i][j][i-1][j]-1)&1)add_(P(i,j,k),P(i-1,j,k),inf,1);",
            "\t\t\t\t\t}",
            "\t\t\t\t\tif(j>1&&Map[i][j][i][j-1]!=-1){",
            "\t\t\t\t\t\tif(!Map[i][j][i][j-1])add_(P(i,j,k),P(i,j-1,k),inf,1);",
            "\t\t\t\t\t\telse if((k>>Map[i][j][i][j-1]-1)&1)add_(P(i,j,k),P(i,j-1,k),inf,1);",
            "\t\t\t\t\t}",
            "\t\t\t\t}",
            "\tEK(st,ed);",
            "\tif(maxflow)printf(\"%lld\",mincost);",
            "\telse printf(\"-1\");",
            "}",
            ""
        ],
        "description": "插入 孤岛营救问题  (EK)"
    },
    "数字梯形问题  (EK)": {
        "prefix": "acm-3.5MCMF",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1200,M=1865,inf=2e9;",
            "int o=1,n,m,h,t,st,ed,O,Poi[23][43],A[23][43],cyf[N],pan[N],pre[N],dis[N],head[N];LL maxcost,maxflow; ",
            "struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}",
            "inline int SPFA(Re st,Re ed){",
            "    for(Re i=0;i<=ed;++i)dis[i]=-inf,pan[i]=0;",
            "    Q.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;",
            "    while(!Q.empty()){",
            "    \tRe x=Q.front();Q.pop();pan[x]=0;",
            "    \tfor(Re i=head[x],to;i;i=a[i].next)",
            "    \t\tif(a[i].flow&&dis[to=a[i].to]<dis[x]+a[i].w){",
            "    \t\t\tdis[to]=dis[x]+a[i].w,pre[to]=i;",
            "    \t\t\tcyf[to]=min(cyf[x],a[i].flow);",
            "    \t\t\tif(!pan[to])pan[to]=1,Q.push(to);",
            "    \t\t}",
            "    }",
            "    return dis[ed]!=-inf;",
            "}",
            "inline void EK(Re st,Re ed){",
            "    while(SPFA(st,ed)){",
            "    \tRe x=ed;maxflow+=cyf[ed],maxcost+=(LL)cyf[ed]*dis[ed];",
            "    \twhile(x!=st){",
            "    \t\tRe i=pre[x];",
            "    \t\ta[i].flow-=cyf[ed];",
            "    \t\ta[i^1].flow+=cyf[ed];",
            "    \t\tx=a[i^1].to;",
            "    \t}",
            "    }",
            "}",
            "inline void TAT1(){",
            "    for(Re i=1;i<=m;++i)add_(st,Poi[1][i],1,0);",
            "    for(Re i=1;i<=m+n-1;++i)add_(Poi[n][i]+O,ed,1,0);",
            "    for(Re i=1;i<=n;++i)",
            "    \tfor(Re j=1;j<=m+i-1;++j){",
            "    \t\tadd_(Poi[i][j],Poi[i][j]+O,1,A[i][j]);",
            "    \t\tif(i<n)add_(Poi[i][j]+O,Poi[i+1][j],1,0),add_(Poi[i][j]+O,Poi[i+1][j+1],1,0);",
            "    \t}",
            "    EK(st,ed);",
            "    printf(\"%lld\\n\",maxcost);",
            "}",
            "inline void TAT2(){",
            "    for(Re i=1;i<=m;++i)add_(st,Poi[1][i],1,0);",
            "    for(Re i=1;i<=m+n-1;++i)add_(Poi[n][i]+O,ed,inf,0);",
            "    for(Re i=1;i<=n;++i)",
            "    \tfor(Re j=1;j<=m+i-1;++j){",
            "    \t\tadd_(Poi[i][j],Poi[i][j]+O,inf,A[i][j]);",
            "    \t\tif(i<n)add_(Poi[i][j]+O,Poi[i+1][j],1,0),add_(Poi[i][j]+O,Poi[i+1][j+1],1,0);",
            "    \t}",
            "    EK(st,ed);",
            "    printf(\"%lld\\n\",maxcost);",
            "}",
            "inline void TAT3(){",
            "    for(Re i=1;i<=m;++i)add_(st,Poi[1][i],1,0);",
            "    for(Re i=1;i<=m+n-1;++i)add_(Poi[n][i]+O,ed,inf,0);",
            "    for(Re i=1;i<=n;++i)",
            "    \tfor(Re j=1;j<=m+i-1;++j){",
            "            add_(Poi[i][j],Poi[i][j]+O,inf,A[i][j]);",
            "            if(i<n)add_(Poi[i][j]+O,Poi[i+1][j],inf,0),add_(Poi[i][j]+O,Poi[i+1][j+1],inf,0);",
            "    \t}",
            "    EK(st,ed);",
            "    printf(\"%lld\\n\",maxcost);",
            "}",
            "inline void CL(){",
            "    memset(head,0,sizeof(head));",
            "    memset(cyf,0,sizeof(cyf));",
            "    memset(pre,0,sizeof(pre));",
            "    memset(a,0,sizeof(a));",
            "    maxflow=maxcost=0,o=1;",
            "}",
            "int main(){",
            "    in(m),in(n);",
            "    for(Re i=1;i<=n;++i)",
            "    \tfor(Re j=1;j<=m+i-1;++j)",
            "            in(A[i][j]),Poi[i][j]=++O;",
            "    st=O<<1|1,ed=st+1;",
            "    TAT1(),CL(),TAT2(),CL(),TAT3();",
            "}",
            ""
        ],
        "description": "插入 数字梯形问题  (EK)"
    },
    "方格取数问题": {
        "prefix": "acm-3.5Dinic",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e4+5,M=3e4+5,inf=2e9;",
            "int x,n,m,h,t,o=1,T,st,ed,ans,maxflow,Q[N],cur[N],dis[N],head[N],wi[4]={0,0,1,-1},wj[4]={1,-1,0,0};",
            "struct QAQ{int to,next,flow;}a[M<<1];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z){a[++o].flow=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void add_(Re x,Re y,Re z){add(x,y,z),add(y,x,0);}",
            "inline int bfs(Re st,Re ed){//bfs求源点到所有点的最短路 ",
            "    for(Re i=0;i<=ed;++i)cur[i]=head[i],dis[i]=0;//当前弧优化cur=head",
            "    h=1,t=0,dis[st]=1,Q[++t]=st;",
            "    while(h<=t){",
            "        Re x=Q[h++],to;",
            "        for(Re i=head[x];i;i=a[i].next)",
            "            if(a[i].flow&&!dis[to=a[i].to]){",
            "            \tdis[to]=dis[x]+1,Q[++t]=to;",
            "            \tif(to==ed)return 1;",
            "            }",
            "    }",
            "    return 0;",
            "}",
            "inline int dfs(Re x,Re flow){//flow为源点到x的路径上的最小边权 ",
            "    if(!flow||x==ed)return flow;//发现没有流了或者到达终点即可返回 ",
            "    Re tmp=0,to,f;",
            "    for(Re i=cur[x];i;i=a[i].next){",
            "    \tcur[x]=i;//当前弧优化cur=i",
            "    \tif(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(flow-tmp,a[i].flow)))){",
            "    \t//若边权为0，不满足增广路性质，此时dfs返回值f为0，不必执行下面了 ",
            "            a[i].flow-=f,a[i^1].flow+=f;",
            "            tmp+=f;//记录终点已经有了多少流 ",
            "            if(!(flow-tmp))break;//前面那些儿子都是最短路，这些最优路径已经榨干了从x出来的所有流，后面的都不用管了 ",
            "    \t}",
            "    }",
            "    return tmp;",
            "}",
            "inline void Dinic(Re st,Re ed){",
            "    Re flow=0;maxflow=0;",
            "    while(bfs(st,ed))maxflow+=dfs(st,inf);",
            "}",
            "inline int Poi(Re i,Re j){return (i-1)*m+j;}",
            "int main(){",
            "\tin(n),in(m),st=n*m+1,ed=st+1;",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=m;++j){",
            "\t\t\tin(x),ans+=x;",
            "\t\t\tif((i+j)%2)add_(st,Poi(i,j),x);",
            "\t\t\telse add_(Poi(i,j),ed,x);",
            "\t\t}",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\tif((i+j)%2)for(Re k=0;k<4;++k){",
            "\t\t\t\tRe ni=i+wi[k],nj=j+wj[k];",
            "\t\t\t\tif(ni>=1&&ni<=n&&nj>=1&&nj<=m)add_(Poi(i,j),Poi(ni,nj),inf);",
            "\t\t\t}",
            "\tDinic(st,ed);",
            "\tprintf(\"%d\\n\",ans-maxflow);",
            "}"
        ],
        "description": "插入 方格取数问题"
    },
    "汽车加油行驶问题  (EK)": {
        "prefix": "acm-3.5MCMF",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=11e4+5,M=6e5+5,inf=2e9;",
            "int x,y,z,w,o=1,n,m,h,t,A,B,C,K,st,ed,cyf[N],pan[N],pre[N],dis[N],head[N];LL mincost,maxflow; ",
            "struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}",
            "inline int SPFA(Re st,Re ed){",
            "\tfor(Re i=0;i<=ed;++i)dis[i]=inf,pan[i]=0;",
            "\tQ.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;",
            "\twhile(!Q.empty()){",
            "\t\tRe x=Q.front();Q.pop();pan[x]=0;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(a[i].flow&&dis[to=a[i].to]>dis[x]+a[i].w){",
            "\t\t\t\tdis[to]=dis[x]+a[i].w,pre[to]=i;",
            "\t\t\t\tcyf[to]=min(cyf[x],a[i].flow);",
            "\t\t\t\tif(!pan[to])pan[to]=1,Q.push(to);",
            "\t\t\t}",
            "\t}",
            "\treturn dis[ed]!=inf;",
            "}",
            "inline void EK(Re st,Re ed){",
            "\twhile(SPFA(st,ed)){",
            "\t\tRe x=ed;maxflow+=cyf[ed],mincost+=(LL)cyf[ed]*dis[ed];",
            "\t\twhile(x!=st){",
            "\t\t\tRe i=pre[x];",
            "\t\t\ta[i].flow-=cyf[ed];",
            "\t\t\ta[i^1].flow+=cyf[ed];",
            "\t\t\tx=a[i^1].to;",
            "\t\t}",
            "\t}",
            "}",
            "inline int P(Re x,Re y,Re k){return (x-1)*n+y+k*n*n;}",
            "int main(){",
            "\tin(n),in(K),in(A),in(B),in(C),st=(K+1)*n*n+1,ed=st+1;",
            "\tadd_(st,P(1,1,0),1,0);",
            "\tfor(Re k=1;k<=K;++k)add_(P(n,n,k),ed,1,0);",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=n;++j){",
            "\t\t\tin(x);",
            "\t\t\tif(x){",
            "\t\t\t\tfor(Re k=1;k<=K;++k)add_(P(i,j,k),P(i,j,0),inf,A);",
            "\t\t\t\tif(i<n)add_(P(i,j,0),P(i+1,j,1),inf,0);",
            "\t\t\t\tif(j<n)add_(P(i,j,0),P(i,j+1,1),inf,0);",
            "\t\t\t\tif(i>1)add_(P(i,j,0),P(i-1,j,1),inf,B);",
            "\t\t\t\tif(j>1)add_(P(i,j,0),P(i,j-1,1),inf,B);",
            "\t\t\t}",
            "\t\t\telse{",
            "\t\t\t\tfor(Re k=0;k<K;++k){",
            "\t\t\t\t\tif(i<n)add_(P(i,j,k),P(i+1,j,k+1),inf,0);",
            "\t\t\t\t\tif(j<n)add_(P(i,j,k),P(i,j+1,k+1),inf,0);",
            "\t\t\t\t\tif(i>1)add_(P(i,j,k),P(i-1,j,k+1),inf,B);",
            "\t\t\t\t\tif(j>1)add_(P(i,j,k),P(i,j-1,k+1),inf,B);",
            "\t\t\t\t}",
            "\t\t\t\tadd_(P(i,j,K),P(i,j,0),1,A+C);",
            "\t\t\t}",
            "\t\t}",
            "\tEK(st,ed);",
            "\tprintf(\"%lld\",mincost);",
            "}",
            ""
        ],
        "description": "插入 汽车加油行驶问题  (EK)"
    },
    "深海机器人问题  (EK)": {
        "prefix": "acm-3.5MCMF",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=260,M=1540,inf=2e9;",
            "int x,y,z,o=1,n,m,h,t,Q1,Q2,st,ed,cyf[N],pan[N],pre[N],dis[N],head[N];LL maxcost,maxflow; ",
            "struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}",
            "inline int SPFA(Re st,Re ed){",
            "\tfor(Re i=0;i<=ed;++i)dis[i]=-inf,pan[i]=0;",
            "\tQ.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;",
            "\twhile(!Q.empty()){",
            "\t\tRe x=Q.front();Q.pop();pan[x]=0;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(a[i].flow&&dis[to=a[i].to]<dis[x]+a[i].w){",
            "\t\t\t\tdis[to]=dis[x]+a[i].w,pre[to]=i;",
            "\t\t\t\tcyf[to]=min(cyf[x],a[i].flow);",
            "\t\t\t\tif(!pan[to])pan[to]=1,Q.push(to);",
            "\t\t\t}",
            "\t}",
            "\treturn dis[ed]!=-inf;",
            "}",
            "inline void EK(Re st,Re ed){",
            "\twhile(SPFA(st,ed)){",
            "\t\tRe x=ed;maxflow+=cyf[ed],maxcost+=(LL)cyf[ed]*dis[ed];",
            "\t\twhile(x!=st){",
            "\t\t\tRe i=pre[x];",
            "\t\t\ta[i].flow-=cyf[ed];",
            "\t\t\ta[i^1].flow+=cyf[ed];",
            "\t\t\tx=a[i^1].to;",
            "\t\t}",
            "\t}",
            "}",
            "inline int Poi(Re x,Re y){return (x-1)*m+y;}",
            "int main(){",
            "\tin(Q1),in(Q2),in(n),in(m),++n,++m,st=n*m+1,ed=st+1;",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<m;++j)",
            "\t\t\tin(x),add_(Poi(i,j),Poi(i,j+1),1,x),add_(Poi(i,j),Poi(i,j+1),inf,0);",
            "\tfor(Re j=1;j<=m;++j)",
            "\t\tfor(Re i=1;i<n;++i)",
            "\t\t\tin(x),add_(Poi(i,j),Poi(i+1,j),1,x),add_(Poi(i,j),Poi(i+1,j),inf,0);",
            "\twhile(Q1--)in(z),in(x),in(y),add_(st,Poi(x+1,y+1),z,0);",
            "\twhile(Q2--)in(z),in(x),in(y),add_(Poi(x+1,y+1),ed,z,0);",
            "\tEK(st,ed);",
            "\tprintf(\"%lld\",maxcost);",
            "}",
            ""
        ],
        "description": "插入 深海机器人问题  (EK)"
    },
    "航空路线问题  (EK)": {
        "prefix": "acm-3.5MCMF",
        "body": [
            "#include<algorithm>",
            "#include<iostream>",
            "#include<string>",
            "#include<cstdio>",
            "#include<queue>",
            "#include<map>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=103,M=40000,inf=2e9;",
            "int x,y,o=1,n,m,h,t,st,ed,flag,cyf[N],pan[N],pre[N],dis[N],head[N];LL maxcost,maxflow;",
            "struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;string CH,ch[N];map<string,int>ip;",
            "inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}",
            "inline int SPFA(Re st,Re ed){",
            "\tfor(Re i=0;i<=ed;++i)dis[i]=-inf,pan[i]=0;",
            "\tQ.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;",
            "\twhile(!Q.empty()){",
            "\t\tRe x=Q.front();Q.pop();pan[x]=0;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(a[i].flow&&dis[to=a[i].to]<dis[x]+a[i].w){//�· ",
            "\t\t\t\tdis[to]=dis[x]+a[i].w,pre[to]=i;",
            "\t\t\t\tcyf[to]=min(cyf[x],a[i].flow);",
            "\t\t\t\tif(!pan[to])pan[to]=1,Q.push(to);",
            "\t\t\t}",
            "\t}",
            "\treturn dis[ed]!=-inf;",
            "}",
            "inline void EK(Re st,Re ed){",
            "\twhile(SPFA(st,ed)){",
            "\t\tRe x=ed;maxflow+=cyf[ed],maxcost+=(LL)cyf[ed]*dis[ed];",
            "\t\twhile(x!=st){",
            "\t\t\tRe i=pre[x];",
            "\t\t\ta[i].flow-=cyf[ed];",
            "\t\t\ta[i^1].flow+=cyf[ed];",
            "\t\t\tx=a[i^1].to;",
            "\t\t}",
            "\t}",
            "}",
            "inline void dfs1(Re x){",
            "\tpan[x]=1;",
            "\tcout<<ch[x-n]<<endl;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)<=n&&!a[i].flow){dfs1(to+n);break;}",
            "}",
            "inline void dfs2(Re x){",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)<=n&&!a[i].flow&&!pan[to+n])dfs2(to+n);",
            "\tcout<<ch[x-n]<<endl;",
            "}",
            "int main(){",
            "\tcin>>n>>m;st=1,ed=n<<1;",
            "\tfor(Re i=1;i<=n;++i)cin>>ch[i],ip[ch[i]]=i;",
            "\tfor(Re i=2;i<n;++i)add_(i,n+i,1,1);",
            "\tadd_(1,1+n,2,1),add_(n,n+n,2,1);",
            "\twhile(m--){",
            "\t\tcin>>CH;x=ip[CH];",
            "\t\tcin>>CH;y=ip[CH];",
            "\t\tif(x>y)swap(x,y);",
            "\t\tflag|=x==1&&y==n; ",
            "\t\tadd_(x+n,y,1,0);",
            "\t}",
            "\tEK(st,ed);",
            "\tif(maxflow==2)printf(\"%d\\n\",maxcost-2);",
            "\telse if(maxflow==1&&flag){",
            "\t\tprintf(\"2\\n\");",
            "\t\tcout<<ch[1]<<endl<<ch[n]<<endl<<ch[1]<<endl;",
            "\t\treturn 0;",
            "\t}",
            "\telse return !printf(\"No Solution!\\n\");",
            "\tfor(Re i=1;i<=n+2;++i)pan[i+n]=0;",
            "\tdfs1(1+n),dfs2(1+n);",
            "}",
            ""
        ],
        "description": "插入 航空路线问题  (EK)"
    },
    "负载平衡问题  (EK)": {
        "prefix": "acm-3.5MCMF",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=103,inf=2e9;",
            "int o=1,n,h,t,S,st,ed,A[N],cyf[N],pan[N],pre[N],dis[N],head[N];LL mincost; ",
            "struct QAQ{int w,to,next,flow;}a[N<<3];queue<int>Q;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}",
            "inline int SPFA(Re st,Re ed){",
            "\tfor(Re i=0;i<=n;++i)dis[i]=inf,pan[i]=0;",
            "\tQ.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;",
            "\twhile(!Q.empty()){",
            "\t\tRe x=Q.front();Q.pop();pan[x]=0;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(a[i].flow&&dis[to=a[i].to]>dis[x]+a[i].w){",
            "\t\t\t\tdis[to]=dis[x]+a[i].w,pre[to]=i;",
            "\t\t\t\tcyf[to]=min(cyf[x],a[i].flow);",
            "\t\t\t\tif(!pan[to])pan[to]=1,Q.push(to);",
            "\t\t\t}",
            "\t}",
            "\treturn dis[ed]!=inf;",
            "}",
            "inline void EK(Re st,Re ed){",
            "\twhile(SPFA(st,ed)){",
            "\t\tRe x=ed;mincost+=(LL)cyf[ed]*dis[ed];",
            "\t\twhile(x!=st){",
            "\t\t\tRe i=pre[x];",
            "\t\t\ta[i].flow-=cyf[ed];",
            "\t\t\ta[i^1].flow+=cyf[ed];",
            "\t\t\tx=a[i^1].to;",
            "\t\t}",
            "\t}",
            "}",
            "int main(){",
            "\tin(n);st=n+1,ed=n+2;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]),S+=A[i];S/=n;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tif(i>1)add_(i,i-1,inf,1),add_(i-1,i,inf,1);",
            "\t\tif(A[i]>S)add_(st,i,A[i]-S,0);",
            "\t\telse if(A[i]<S)add_(i,ed,S-A[i],0);",
            "\t}",
            "\tadd_(1,n,inf,1),add_(n,1,inf,1);",
            "\tn+=2;EK(st,ed);",
            "\tprintf(\"%lld\",mincost);",
            "}",
            ""
        ],
        "description": "插入 负载平衡问题  (EK)"
    },
    "运输问题  (EK)": {
        "prefix": "acm-3.5MCMF",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=205,M=10205,inf=2e9;",
            "int o=1,n,m,h,t,st,ed,cyf[N],pan[N],pre[N],dis[N],head[N],Flow[N][2],Cost[N][N];LL mincost,maxflow; ",
            "struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}",
            "inline int SPFA(Re st,Re ed){",
            "\tfor(Re i=0;i<=ed;++i)dis[i]=inf,pan[i]=0;",
            "\tQ.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;",
            "\twhile(!Q.empty()){",
            "\t\tRe x=Q.front();Q.pop();pan[x]=0;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(a[i].flow&&dis[to=a[i].to]>dis[x]+a[i].w){",
            "\t\t\t\tdis[to]=dis[x]+a[i].w,pre[to]=i;",
            "\t\t\t\tcyf[to]=min(cyf[x],a[i].flow);",
            "\t\t\t\tif(!pan[to])pan[to]=1,Q.push(to);",
            "\t\t\t}",
            "\t}",
            "\treturn dis[ed]!=inf;",
            "}",
            "inline void EK(Re st,Re ed){",
            "\twhile(SPFA(st,ed)){",
            "\t\tRe x=ed;maxflow+=cyf[ed],mincost+=(LL)cyf[ed]*dis[ed];",
            "\t\twhile(x!=st){",
            "\t\t\tRe i=pre[x];",
            "\t\t\ta[i].flow-=cyf[ed];",
            "\t\t\ta[i^1].flow+=cyf[ed];",
            "\t\t\tx=a[i^1].to;",
            "\t\t}",
            "\t}",
            "}",
            "int main(){",
            "\tin(n),in(m),st=n+m+1,ed=st+1;",
            "\tfor(Re i=1;i<=n;++i)in(Flow[i][0]),add_(st,i,Flow[i][0],0);",
            "\tfor(Re i=1;i<=m;++i)in(Flow[i][1]),add_(n+i,ed,Flow[i][1],0);",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\tin(Cost[i][j]),add_(i,n+j,inf,Cost[i][j]);",
            "\tEK(st,ed);",
            "\tprintf(\"%lld\\n\",mincost);",
            "\tmemset(head,0,sizeof(head));",
            "\tmemset(cyf,0,sizeof(cyf));",
            "\tmemset(pre,0,sizeof(pre));",
            "\tmemset(a,0,sizeof(a));",
            "\to=1;maxflow=mincost=0;",
            "\tfor(Re i=1;i<=n;++i)add_(st,i,Flow[i][0],0);",
            "\tfor(Re i=1;i<=m;++i)add_(n+i,ed,Flow[i][1],0);",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\tadd_(i,n+j,inf,-Cost[i][j]);",
            "\tEK(st,ed);",
            "\tprintf(\"%lld\\n\",-mincost);",
            "}",
            ""
        ],
        "description": "插入 运输问题  (EK)"
    },
    "飞行员配对方案问题": {
        "prefix": "acm-3.5EK",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=103,inf=2e9;",
            "int x,y,n,m,o=1,h,t,st,ed,ans,maxflow,cyf[N],Q[N],pre[N],pan[N],head[N];",
            "struct QAQ{int to,next,flow;}a[N*N*2+N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z){a[++o].flow=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline int bfs(Re st,Re ed){",
            "\tfor(Re i=0;i<=n+2;++i)pan[i]=0;",
            "\th=1,t=0,pan[st]=1,cyf[st]=inf,Q[++t]=st;",
            "\twhile(h<=t){",
            "\t\tRe to,x=Q[h++];",
            "\t\tfor(Re i=head[x];i;i=a[i].next)",
            "\t\t\tif(a[i].flow&&!pan[to=a[i].to]){",
            "\t\t\t\tcyf[to]=min(cyf[x],a[i].flow);",
            "\t\t\t\tpan[to]=1,pre[to]=i,Q[++t]=to;",
            "\t\t\t\tif(to==ed)return 1;",
            "\t\t\t}",
            "\t}",
            "\treturn 0;",
            "}",
            "inline void EK(Re st,Re ed){",
            "\twhile(bfs(st,ed)){",
            "\t\tmaxflow+=cyf[ed];",
            "\t\tRe x=ed;",
            "\t\twhile(x!=st){",
            "\t\t\tRe i=pre[x];",
            "\t\t\ta[i].flow-=cyf[ed];",
            "\t\t\ta[i^1].flow+=cyf[ed];",
            "\t\t\tx=a[i^1].to;",
            "\t\t}",
            "\t}",
            "}",
            "int main(){",
            "\tin(m),in(n),st=n+1,ed=n+2;",
            "\twhile(1){",
            "\t\tin(x),in(y);",
            "\t\tif(x==-1)break;",
            "\t\tadd(x,y,1),add(y,x,0);",
            "\t}",
            "\tfor(Re i=1;i<=m;++i)add(st,i,1),add(i,st,0);",
            "\tfor(Re i=m+1;i<=n;++i)add(i,ed,1),add(ed,i,0);",
            "\tEK(st,ed);",
            "\tprintf(\"%d\\n\",maxflow);",
            "\tfor(Re x=1;x<=m;++x)",
            "\t\tfor(Re i=head[x];i;i=a[i].next)",
            "\t\t\tif(!(i&1)&&a[i].to!=st&&!a[i].flow)printf(\"%d %d\\n\",x,a[i].to);",
            "}",
            ""
        ],
        "description": "插入 飞行员配对方案问题"
    },
    "魔术球问题": {
        "prefix": "acm-3.5EK",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<vector>",
            "#include<cmath>",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+5,inf=2e9;",
            "int h,t,n,p,o=1,st,ed,cnt,maxflow,Q[N],zhu[N],ans[N],pan[N],pre[N],cyf[N],head[N];",
            "struct QAQ{int to,flow,next;}a[N<<1];vector<int>Ans[N];",
            "inline void add(Re x,Re y,Re flow){a[++o].flow=flow,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void add_(Re x,Re y,Re flow){add(x,y,flow),add(y,x,0);}",
            "inline int bfs(Re st,Re ed){",
            "\tfor(Re i=1;i<=ed;++i)pan[i]=0;",
            "\th=1,t=0,pan[st]=1,Q[++t]=st,cyf[st]=inf;",
            "\twhile(h<=t){",
            "\t\tRe x=Q[h++];",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(a[i].flow&&!pan[to=a[i].to]){",
            "\t\t\t\tcyf[to]=min(cyf[x],a[i].flow);",
            "\t\t\t\tpan[Q[++t]=to]=1,pre[to]=i;",
            "\t\t\t\tif(to==ed)return 1;",
            "\t\t\t}",
            "\t}",
            "\treturn 0;",
            "}",
            "inline void EK(Re st,Re ed){",
            "\tRe x,flow=0;maxflow=0;",
            "\twhile(bfs(st,ed)){",
            "\t\tx=ed,maxflow+=cyf[ed];",
            "\t\twhile(x!=st){",
            "\t\t\tRe i=pre[x];",
            "\t\t\ta[i].flow-=cyf[ed];",
            "\t\t\ta[i^1].flow+=cyf[ed];",
            "\t\t\tx=a[i^1].to;",
            "\t\t}",
            "\t}",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tscanf(\"%d\",&n),st=1e5+1,ed=st+1;",
            "\twhile(ans[0]<=n){",
            "\t\t++p;",
            "\t\tadd_(st,p<<1,1),add_(p<<1|1,ed,1);",
            "\t\tfor(Re j=sqrt(p)+1;j*j-p<=p-1;++j)add_((j*j-p)<<1,(p<<1)|1,1);",
            "\t\tEK(st,ed);",
            "\t\tif(!maxflow)ans[++ans[0]]=p,Ans[zhu[p]=ans[0]].push_back(p);",
            "\t\telse{",
            "\t\t\tRe x=p<<1|1;",
            "\t\t\twhile(!zhu[x-1>>1])x=a[pre[x]^1].to+1;",
            "\t\t\tAns[zhu[x-1>>1]].push_back(p);",
            "\t\t}",
            "\t}",
            "\tprintf(\"%d\\n\",p-1);",
            "\tfor(Re i=1;i<=n;puts(\"\"),++i)",
            "\t\tfor(Re j=0;j<Ans[i].size();++j)",
            "\t\t\tprintf(\"%d \",Ans[i][j]);",
            "}",
            ""
        ],
        "description": "插入 魔术球问题"
    },
    "教辅的组成": {
        "prefix": "acm-3.5Dinic",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "using namespace std;",
            "const int N=4e4+5,M=7e4+3,inf=2e9;",
            "int x,y,z,o=1,n1,n2,n3,nn,m,h,t,st,ed,Q[N],dis[N],pan[N],pre[N],head[N];long long maxflow; ",
            "struct QAQ{int to,next,flow;}a[M<<1];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z){a[++o].flow=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void add_(Re x,Re y,Re flow){add(x,y,flow),add(y,x,0);}",
            "inline int bfs(Re st,Re ed){",
            "\tfor(Re i=0;i<=ed;++i)dis[i]=0;",
            "\th=1,t=0,dis[st]=1,Q[++t]=st;",
            "\twhile(h<=t){",
            "\t\tRe x=Q[h++],to;",
            "\t\tfor(Re i=head[x];i;i=a[i].next)",
            "\t\t\tif(a[i].flow&&!dis[to=a[i].to]){",
            "\t\t\t\tdis[to]=dis[x]+1,Q[++t]=to;",
            "\t\t\t\tif(to==ed)return 1;",
            "\t\t\t}",
            "\t}",
            "\treturn 0;",
            "}",
            "inline int dfs(Re x,Re flow){",
            "\tif(!flow||x==ed)return flow;",
            "\tRe tmp=0,to,f;",
            "\tfor(Re i=head[x];i;i=a[i].next)",
            "\t\tif(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(flow-tmp,a[i].flow)))){",
            "\t\t\ta[i].flow-=f,a[i^1].flow+=f,tmp+=f;",
            "\t\t\tif(!(flow-tmp))break;",
            "\t\t}",
            "\treturn tmp;",
            "}",
            "inline void Dinic(Re st,Re ed){",
            "\tRe flow=0;",
            "\twhile(bfs(st,ed))while(flow=dfs(st,inf))maxflow+=flow;",
            "}",
            "int main(){",
            "\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n1),in(n2),in(n3);nn=n1+n2+n3,st=nn+n1+1,ed=st+1;",
            "\tfor(Re i=1;i<=n1;++i)add_(i,i+nn,1);",
            "\tfor(Re i=1;i<=n2;++i)add_(st,n1+i,1);",
            "\tfor(Re i=1;i<=n3;++i)add_(n1+n2+i,ed,1);",
            "\tin(m);while(m--)in(x),in(y),add_(n1+y,x,1);",
            "\tin(m);while(m--)in(x),in(y),add_(x+nn,n1+n2+y,1);",
            "\tDinic(st,ed);",
            "\tprintf(\"%lld\",maxflow);",
            "}",
            ""
        ],
        "description": "插入 教辅的组成"
    },
    "01分数规划": {
        "prefix": "acm-3.6观光奶牛Sightseeing Cows",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e4+5,M=5e5+5,inf=2e9;",
            "int x,y,z,n,m,o,T,to,A[N],cha[N],pan[N],head[N];double dis[N];",
            "struct QAQ{int w,to,next;}a[M<<1];queue<int>Q;",
            "inline void in(Re &x){",
            "    Re fu=0;x=0;char ch=getchar();",
            "    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void add(Re x,Re y,Re z){a[++o].to=y,a[o].w=z,a[o].next=head[x],head[x]=o;}",
            "inline int SPFA(Re st,double mid){",
            "    for(Re i=0;i<=n;++i)dis[i]=-inf,pan[i]=cha[i]=0;",
            "    dis[st]=0,cha[st]=pan[st]=1,Q.push(st);",
            "    while(!Q.empty()){",
            "        x=Q.front(),Q.pop();",
            "        pan[x]=0;",
            "        for(Re i=head[x];i;i=a[i].next)",
            "            if(dis[to=a[i].to]<dis[x]+A[x]-mid*a[i].w){",
            "                dis[to]=dis[x]+A[x]-mid*a[i].w;",
            "                if(++cha[to]>n)return 1;",
            "                if(!pan[to])Q.push(to);",
            "            }",
            "    }",
            "    return 0;",
            "}",
            "int main(){",
            "    in(n),in(m);",
            "    for(Re i=1;i<=n;++i)in(A[i]);",
            "    while(m--)in(x),in(y),in(z),add(x,y,z);",
            "    double l=0,r=1000000,mid;",
            "    while(r-l>1e-4){",
            "        mid=(l+r)/2;",
            "        if(SPFA(1,mid))l=mid;",
            "        else r=mid;",
            "    }",
            "    printf(\"%.2lf\",l);",
            "}",
            ""
        ],
        "description": "插入 01分数规划"
    },
    "判负环": {
        "prefix": "acm-3.6SPFA",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=2003,M=3e5+3,inf=2e9;",
            "int n,m,x,y,z,o,T,pan[N],chu[N],dis[N],head[N];queue<int>Q;",
            "struct QAQ{int w,to,next;}a[M<<1];",
            "inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int SPFA(Re st){",
            "    for(Re i=1;i<=n;++i)dis[i]=inf,chu[i]=pan[i]=0;",
            "    while(!Q.empty())Q.pop();",
            "    Q.push(st),dis[st]=0,chu[st]=0,pan[st]=1;",
            "    while(!Q.empty()){",
            "        Re x=Q.front();Q.pop();pan[x]=0;",
            "        for(Re i=head[x],to;i;i=a[i].next)",
            "            if(dis[to=a[i].to]>dis[x]+a[i].w){",
            "                dis[to]=dis[x]+a[i].w;",
            "                if((chu[to]=chu[x]+1)>=n)return 1;",
            "//                if(++chu[to]>=n)return 1;",
            "                if(!pan[to])pan[to]=1,Q.push(to);",
            "            }",
            "    }",
            "    return 0;",
            "}",
            "int main(){",
            "    in(T);",
            "    while(T--){",
            "        in(n),in(m),memset(head,0,sizeof(head)),o=0;",
            "        while(m--){in(x),in(y),in(z),add(x,y,z);if(z>=0)add(y,x,z);}",
            "        puts(SPFA(1)?\"YES\":\"NO\");",
            "    }",
            "}",
            ""
        ],
        "description": "插入 判负环"
    },
    "差分约束系统": {
        "prefix": "acm-3.6糖果",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+5,M=3e5+5,inf=2e9;",
            "int x,y,n,m,o,op,chu[N],dis[N],pan[N],head[N];long long ans;",
            "struct QAQ{int w,to,next;}a[M];queue<int>Q;",
            "inline void add(Re x,Re y,Re z){a[++o].to=y,a[o].w=z,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "inline int SPFA(Re st,Re ed){",
            "\tfor(Re i=0;i<=n;++i)dis[i]=-inf,chu[i]=0;",
            "\tdis[st]=0,chu[st]=pan[st]=1,Q.push(st);",
            "\twhile(!Q.empty()){",
            "\t\tx=Q.front(),Q.pop();",
            "\t\tpan[x]=0;",
            "\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\tif(dis[to=a[i].to]<dis[x]+a[i].w){",
            "\t\t\t\tdis[to]=dis[x]+a[i].w;",
            "\t\t\t\tif((chu[to]=chu[x]+1)>n+1)return 1;",
            "\t\t\t\tif(!pan[to])pan[to]=1,Q.push(to);",
            "\t\t\t}",
            "\t}",
            "\treturn 0;",
            "}",
            "int main(){",
            "\tin(n),in(m);",
            "\tfor(Re i=n;i>=1;--i)add(0,i,1); //a[i]>=a[0]=1,a[i]-a[0]>=1",
            "\twhile(m--){",
            "\t\tin(op),in(x),in(y);",
            "\t\tif(op<2)add(y,x,0),add(x,y,0);",
            "\t\telse if(op<3)add(x,y,1);//a[x]<a[y]: a[y]-a[x]>=1",
            "\t\telse if(op<4)add(y,x,0);//a[x]>=a[y]: a[x]-a[y]>=0",
            "\t\telse if(op<5)add(y,x,1);//a[x]>a[y]: a[x]-a[y]>=1",
            "\t\telse add(x,y,0);//a[x]<=a[y]: a[y]-a[x]>=0",
            "\t\tif(!(op%2)&&x==y){puts(\"-1\");return 0;}",
            "\t}",
            "\tif(SPFA(0,n))puts(\"-1\");",
            "\telse{",
            "\t\tfor(Re i=1;i<=n;++i)ans+=dis[i];",
            "\t\tprintf(\"%lld\",ans);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 差分约束系统"
    },
    "n进制 转 m进制": {
        "prefix": "acm-1.5n_to_ten",
        "body": [
            "#include<cstdio>",
            "const int N=1e5+3;",
            "int n,m,x,tmp,ansl;char a[N],ans[N];",
            "inline int n_to_ten(){",
            "\tint x=0;",
            "\tfor(int i=0;a[i];++i){",
            "        x*=n;",
            "        if (a[i]>='A'&&a[i]<='F')x+=(a[i]-'A'+10);",
            "        else x+=(a[i]-'0');",
            "   }",
            "   return x;",
            "}",
            "inline void ten_to_m(){",
            "\tdo{",
            "\t\ttmp=x%m;",
            "\t\tif(tmp<10)ans[++ansl]='0'+tmp;",
            "\t\telse ans[++ansl]='A'+tmp-10;",
            "\t\tx/=m;",
            "\t\t",
            "\t}while(x);",
            "}",
            "int main(){",
            "   scanf(\"%d%s%d\",&n,a,&m);",
            "   x=n_to_ten();",
            "   ten_to_m();",
            "   for(int i=ansl;i;--i)printf(\"%c\",ans[i]);puts(\"\");",
            "}",
            ""
        ],
        "description": "插入 n进制 转 m进制"
    },
    "ST表求区间最值": {
        "prefix": "acm-2.6RMQ",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "using namespace std;",
            "const int N=1e5+3,inf=2147483647;",
            "int i,j,n,k,m,a[N],lg[N],f1[N][18],f2[N][18];",
            "int main(){",
            "    scanf(\"%d%d\",&n,&k);",
            "    for(i=0;i<=17;i++)",
            "        for(j=0;j<=n+1;j++)",
            "            f1[i][j]=-inf,f2[i][j]=inf;",
            "    lg[1]=0;for(i=2;i<=n;i++)lg[i]=lg[i>>1]+1;m=lg[n];",
            "    for(i=1;i<=n;f2[i][0]=f1[i][0],i++)scanf(\"%d\",&f1[i][0]);",
            "    for(i=1;i<=m;i++)",
            "        for(j=1;j+(1<<i)-1<=n;j++)",
            "            f1[j][i]=max(f1[j][i-1],f1[j+(1<<i-1)][i-1]),f2[j][i]=min(f2[j][i-1],f2[j+(1<<i-1)][i-1]);",
            "    m=lg[k];",
            "    for(i=1;i+k-1<=n;i++)printf(\"%d %d\\n\",max(f1[i][m],f1[i+k-(1<<m)][m]),min(f2[i][m],f2[i+k-(1<<m)][m]));",
            "}",
            ""
        ],
        "description": "插入 ST表求区间最值"
    },
    "归并排序": {
        "prefix": "acm-1.5optimize",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<cstdio>",
            "#define Re register int",
            "const int N=5e5+3;",
            "int fu,n,s[N],b[N];long long gs;char ch;",
            "inline void in(int &x){",
            "\tfu=x=0;ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "void merge(Re L,Re mid,Re R){",
            "    Re i=L,j=mid+1,w=L;",
            "    while(i<=mid&&j<=R){",
            "        if(s[i]<=s[j])b[w++]=s[i++];",
            "        else b[w++]=s[j++],gs+=mid-i+1;",
            "    }",
            "    for(;i<=mid;i++)b[w++]=s[i];",
            "    for(;j<=R;j++)b[w++]=s[j];",
            "    for(i=L;i<=R;i++)s[i]=b[i];",
            "}",
            "inline void Sort(Re L,Re R){",
            "    if(L<R){",
            "        Re mid=L+R>>1;",
            "        Sort(L,mid),Sort(mid+1,R);",
            "        merge(L,mid,R);",
            "    }",
            "}",
            "int main(){",
            "    in(n);",
            "    for(Re i=1;i<=n;i++)in(s[i]);",
            "    Sort(1,n);",
            "    for(Re i=1;i<=n;i++)printf(\"%d \",s[i]); ",
            "}",
            ""
        ],
        "description": "插入 归并排序"
    },
    "快排": {
        "prefix": "acm-1.5mysort",
        "body": [
            "#include<bits/stdc++.h>",
            "using namespace std;",
            "int data[100100],n;",
            "void mysort(int left, int right){",
            "\tint mid=data[(left+right)/2];",
            "\tint i=left,j=right;",
            "\twhile(i<=j){",
            "\t\twhile(data[i]<mid)i++;",
            "\t\twhile(data[j]>mid)j--;",
            "\t\tif(i<=j)swap(data[i++],data[j--]);",
            "\t}",
            "\tif(j>left)mysort(left,j);",
            "\tif(i<right)mysort(i,right);",
            "}",
            "int main(){\t",
            "\tscanf(\"%d\",&n);",
            "\tfor(int i=1;i<=n;i++)scanf(\"%d\",&data[i]);",
            "\tmysort(1,n);",
            "\tfor(int i=1;i<=n;i++)printf(\"%d \",data[i]);",
            "}",
            ""
        ],
        "description": "插入 快排"
    },
    "快读 +快输 (int)": {
        "prefix": "acm-1.5int+double",
        "body": [
            "#include<cstdio>",
            "#define LD double",
            "#define Re register int",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void print(Re x){",
            "\tif(x<0)putchar('-'),x=-x;",
            "\tif(x>9)print(x/10);putchar(x%10+'0');",
            "}",
            "inline LD LDin(){",
            "\tLD X=0,Y=1.0;int f=0;char c=getchar();",
            "\twhile(c<'0'||c>'9')f|=c=='-',c=getchar(); ",
            "\twhile(c>='0'&&c<='9')X=X*10+(c^48),c=getchar(); ",
            "\tif(c=='.'){c=getchar();while(c>='0'&&c<='9')X+=(Y/=10)*(c^48),c=getchar();}",
            "\treturn f?-X:X;",
            "}",
            "int main(){}",
            ""
        ],
        "description": "插入 快读 +快输 (int)"
    },
    "快速幂+龟速乘": {
        "prefix": "acm-1.5cf_flow",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "int a,b,P;",
            "inline int cf_flow(Re a,Re k){// 递归 快速乘",
            "\tif(!k)return 0;",
            "\tRe x=1,y=cf_flow(a,k>>1);",
            "\tx=(LL)y+y%P;",
            "\tif(k&1)x=(LL)x+a%P;",
            "\treturn x%P;",
            "}",
            "inline int cf(Re a,Re b){// 二进制法 快速乘 ",
            "\tRe x=0;",
            "\twhile(b){",
            "\t\tif(b&1)x=(x+a)%P;",
            "\t\ta=a*2%P,b>>=1;",
            "\t}",
            "\treturn x%P;",
            "}",
            "inline int mi_slow(Re a,Re k){// 递归 快速幂 ",
            "\tif(!k)return 1%P;",
            "\tRe x=1,y=mi_slow(a,k>>1);",
            "\tx=(LL)y*y%P;",
            "\tif(k&1)x=(LL)x*a%P;",
            "\treturn x%P;",
            "}",
            "inline int mi(Re x,Re k){// 二进制法 快速幂 ",
            "\tRe s=1;",
            "    while(k){",
            "    \tif(k&1)s=(LL)s*x%P;",
            "    \tx=(LL)x*x%P,k>>=1;",
            "    }",
            "    return s%P;",
            "}",
            "int main(){}",
            ""
        ],
        "description": "插入 快速幂+龟速乘"
    },
    "模拟退火  (A Star not a Tree？)": {
        "prefix": "acm-1.5坐标系随机移动",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e6+3;",
            "int n,HYJ,X[N],Y[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline LD calc(LD x,LD y){",
            "\tLD tmp=0;",
            "\tfor(Re i=1;i<=n;++i)tmp+=sqrt((x-X[i])*(x-X[i])+(y-Y[i])*(y-Y[i]));",
            "\treturn tmp;",
            "}",
            "inline void Srand(Re seed){",
            "\tsrand(seed);Re a=rand()%10+1;",
            "\twhile(a--)srand(rand());",
            "}",
            "LD ans,ansx,ansy;",
            "const LD deltaT=0.99,maxT=4995,minT=1e-12;",
            "inline void fire(){",
            "\tLD x=ansx,y=ansy,nowT=maxT;",
            "\twhile(nowT>minT){",
            "\t\tLD nx=x+((rand()<<1)-RAND_MAX)*nowT;",
            "\t\tLD ny=y+((rand()<<1)-RAND_MAX)*nowT;",
            "\t\tLD nans=calc(nx,ny),deltaE=nans-ans;",
            "\t\tif(deltaE<0)ans=nans,ansx=x=nx,ansy=y=ny;",
            "\t\telse if(exp(-deltaE/nowT)>(LD)rand()/RAND_MAX)x=nx,y=ny;",
            "\t\tnowT*=deltaT;",
            "\t}",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(HYJ),Srand(20030825);",
            "\twhile(HYJ--){",
            "\t\tin(n);",
            "\t\tfor(Re i=1;i<=n;++i)in(X[i]),in(Y[i]);",
            "\t\tans=calc(X[1],Y[1]),ansx=X[1],ansy=Y[1];",
            "\t\tfire(),fire(),fire(),fire(),fire();",
            "\t\tprintf(\"%.lf\\n\",ans);",
            "\t\tif(HYJ)puts(\"\");",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 模拟退火  (A Star not a Tree？)"
    },
    "模拟退火  (均分数据)": {
        "prefix": "acm-1.5序列随机swap",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=23;",
            "int n,m,S,A[N];LD x0;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void Srand(Re seed){",
            "\tsrand(seed);Re a=rand()%10+1;",
            "\twhile(a--)srand(rand());",
            "}",
            "inline void Random(Re *A,Re n){",
            "\tfor(Re i=1;i<=n;++i)swap(A[i],A[rand()%n+1]);",
            "}",
            "int x[N];",
            "inline LD calc(Re *A){",
            "\tfor(Re i=1;i<=m;++i)x[i]=0;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tRe w=1;",
            "\t\tfor(Re j=2;j<=m;++j)if(x[j]<x[w])w=j;",
            "\t\tx[w]+=A[i];",
            "\t}",
            "\tLD tmp=0;",
            "\tfor(Re i=1;i<=m;++i)tmp+=(x[i]-x0)*(x[i]-x0);",
            "\treturn tmp/m;",
            "}",
            "int nowA[N],ansA[N];LD ans;",
            "const LD deltaT=0.995,maxT=4995,minT=1e-15;",
            "inline void fire(){",
            "\tfor(Re i=1;i<=n;++i)nowA[i]=ansA[i];LD nowT=maxT;",
            "\twhile(nowT>minT){",
            "\t\tRe x=rand()%n+1,y=rand()%n+1;",
            "\t\tswap(nowA[x],nowA[y]);",
            "\t\tLD nans=calc(nowA),deltaE=nans-ans;",
            "\t\tif(deltaE<0){for(Re i=1;i<=n;++i)ansA[i]=nowA[i];ans=nans;}",
            "\t\telse if(exp(-deltaE/nowT)>(LD)rand()/RAND_MAX);",
            "\t\telse swap(nowA[x],nowA[y]);",
            "\t\tnowT*=deltaT;",
            "\t}",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m);",
            "\tfor(Re i=1;i<=n;++i)in(A[i]),S+=A[i];x0=(LD)S/m;",
            "\tfor(Re i=1;i<=n;++i)ansA[i]=A[i];",
            "\tSrand(965579261),Random(ansA,n),Srand(20030825);",
            "\tans=calc(ansA),fire(),fire(),fire(),fire(),fire();",
            "\tprintf(\"%.2lf\\n\",sqrt(ans));",
            "}",
            ""
        ],
        "description": "插入 模拟退火  (均分数据)"
    },
    "高精度乘法": {
        "prefix": "acm-1.5普通写法",
        "body": [
            "#include<iostream>",
            "#include<cstring>",
            "#include<cstdio>",
            "using namespace std;",
            "int main(){",
            "    char a1[10005],b1[10005];",
            "    int a[100005],b[100005],c[100005],lena,lenb,lenc,i,j,x;",
            "    memset(a,0,sizeof(a));",
            "    memset(b,0,sizeof(b));",
            "    memset(c,0,sizeof(c));",
            "    gets(a1);gets(b1);",
            "    lena=strlen(a1);lenb=strlen(b1);",
            "    for(i=0;i<=lena-1;i++) a[lena-i]=a1[i]-48;",
            "    for(i=0;i<=lenb-1;i++) b[lenb-i]=b1[i]-48;",
            "\tfor(i=1;i<=lena;i++){",
            "\t    x=0;                                               ",
            "\t    for(j=1;j<=lenb;j++){",
            "\t        c[i+j-1]=a[i]*b[j]+x+c[i+j-1];",
            "\t        x=c[i+j-1]/10;",
            "\t        c[i+j-1] %= 10;",
            "\t    }",
            "\t    c[i+lenb]=x;                             ",
            "\t}",
            "\tlenc=lena+lenb;",
            "\twhile(c[lenc]==0&&lenc>1)lenc--;",
            "\tfor(i=lenc;i>=1;i--)cout<<c[i];",
            "\tcout<<endl;",
            "}",
            ""
        ],
        "description": "插入 高精度乘法"
    },
    "高精度加法": {
        "prefix": "acm-1.5普通写法",
        "body": [
            "#include<bits/stdc++.h>",
            "using namespace std;",
            "int a[1000],b[1000],c[1000];",
            "char st[1000];",
            "int main(){",
            "    scanf(\"%s\",st);",
            "    int lena,lenb,lenc;",
            "    lena =strlen(st);",
            "    for(int i=1;i<=lena;i++)a[i]=st[lena-i]-'0';",
            "    scanf(\"%s\",st);",
            "    lenb=strlen(st);",
            "    for(int i=1;i<=lenb;i++)b[i]=st[lenb-i]-'0';",
            "    if(lena>lenb)lenc=lena;",
            "    else lenc=lenb;",
            "    for(int i=1;i<=lenc;i++){",
            "        c[i]=a[i]+b[i]+c[i];",
            "        c[i+1]=c[i+1]+c[i]/10;",
            "        c[i]=c[i]%10;",
            "    }",
            "    if(c[lenc+1])lenc++;",
            "    for(int i=lenc;i>0;i--)printf(\"%d\",c[i]);",
            "    return 0;\t",
            "}",
            ""
        ],
        "description": "插入 高精度加法"
    },
    "高精模板 (史上最全没有之一)": {
        "prefix": "acm-1.5结构体",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int base=1e8;",
            "const int N=1e4+10;",
            "int aux[N<<3];",
            "struct Int{",
            "    int s[N],l;",
            "    inline void CL(){l=0;memset(s,0,sizeof(s));}",
            "    inline void pr(){",
            "        printf(\"%d\",s[l]);",
            "        for(Re i=l-1;i;i--)printf(\"%08d\",s[i]);",
            "    }",
            "    inline void re_l(){",
            "        Re i,x=0,k=1,L=0,fl,o;char c=getchar();",
            "        for(;c<'0'||c>'9';c=getchar());",
            "        for(;c>='0'&&c<='9';c=getchar()){if(!(L-1)&&!aux[L])L--;aux[++L]=c-'0';}",
            "        CL();l=L/8+((o=L%8)>0);",
            "        for(i=1;i<=o;i++)x=x*10+aux[i];",
            "        if(o)s[l]=x;fl=!o?l+1:l;",
            "        for(i=o+1,x=0;i<=L;i++,k++){",
            "            x=x*10+aux[i];",
            "            if(!(k^8))s[--fl]=x,x=k=0;",
            "        }",
            "        if(!l)l=1;",
            "    }",
            "    inline LL toint(){",
            "        LL x=0;",
            "        for(Re i=l;i;i--)x=x*base+s[i];",
            "        return x;",
            "    }",
            "    inline Int operator=(Re b){",
            "        CL();",
            "        do s[++l]=b%base,b/=base;while(b>0);",
            "        return *this;",
            "    }",
            "    inline Int operator=(LL b){",
            "        CL();",
            "        do s[++l]=b%base,b/=base;while(b>0);",
            "        return *this;",
            "    }",
            "    inline Int operator+(const Re &b){",
            "        Int c=*this;LL x=b;",
            "        for(Re i=1;i<=l&&x;i++)x=x+c.s[i],c.s[i]=x%base,x/=base;",
            "        if(x)c.s[++c.l]=x;",
            "        return c;",
            "    }",
            "    inline Int operator+(const LL &b){",
            "        Int c=*this;LL x=b;",
            "        for(Re i=1;i<=l&&x;i++)x=x+c.s[i],c.s[i]=x%base,x/=base;",
            "        if(x)c.s[++c.l]=x;",
            "        return c;",
            "    }",
            "    inline Int operator+(Int &b){",
            "        if(b.l<3)return *this+b.toint();",
            "        Int c;LL x=0;Re k=l<b.l?b.l:l;c.CL(),c.l=k;",
            "        for(Re i=1;i<=k;i++)x=x+s[i]+b.s[i],c.s[i]=x%base,x/=base;",
            "        if(x)c.s[++c.l]=x;",
            "        return c;",
            "    }",
            "    inline Int operator-(const Int &b){",
            "        Int c,d=*this;LL x=0;c.CL();",
            "        for(Re i=1;i<=l;i++){",
            "            if((x=d.s[i])<b.s[i])d.s[i+1]--,x+=base;",
            "            c.s[i]=x-b.s[i];",
            "        }",
            "        c.l=l;",
            "        for(;!c.s[c.l]&&c.l>1;c.l--);",
            "        return c;",
            "    }",
            "    inline Int operator-(const Re &b){Int c;return *this-(c=b);}",
            "    inline Int operator-(const LL&b){Int c;return *this-(c=b);}",
            "    inline Int operator*(const Re &b){",
            "        Int c;LL x=0;c.CL();",
            "        for(Re i=1;i<=l;i++)x=x+1LL*s[i]*b,c.s[i]=x%base,x/=base;",
            "        for(c.l=l;x;x/=base)c.s[++c.l]=x%base;",
            "        return c;",
            "    }",
            "    inline Int operator*(Int&b){",
            "        if(b.l<2)return *this*b.toint();",
            "        Int c;LL x;Re i,j,k;c.CL();",
            "        for(i=1;i<=l;i++){",
            "            x=0;",
            "            for(j=1;j<=b.l;j++)x=x+1LL*s[i]*b.s[j]+c.s[k=i+j-1],c.s[k]=x%base,x/=base;",
            "            if(x)c.s[i+b.l]=x;",
            "        }",
            "        for(c.l=l+b.l;!c.s[c.l]&&c.l>1;c.l--);",
            "        return c;",
            "    }",
            "    inline Int operator*(const LL &b){",
            "        Int c;",
            "        if(b>2e9){c=b;return *this*c;}",
            "        LL x=0;c.CL();",
            "        for(Re i=1;i<=l;i++)x=x+b*s[i],c.s[i]=x%base,x/=base;",
            "        for(c.l=l;x;x/=base)c.s[++c.l]=x%base;",
            "        return c;",
            "    }",
            "    inline Int operator/(const Re &b){",
            "        Int c;LL x=0;c.CL();",
            "        for(Re i=l;i;i--)c.s[i]=(x*base+s[i])/b,x=(x*base+s[i])%b;",
            "        for(c.l=l;!c.s[c.l]&&c.l>1;c.l--);",
            "        return c;",
            "    }",
            "    inline Int operator/(const LL&b){",
            "        Int c;LL x=0;c.CL();",
            "        for(Re i=l;i;i--)c.s[i]=(x*base+s[i])/b,x=(x*base+s[i])%b;",
            "        for(c.l=l;!c.s[c.l]&&c.l>1;c.l--);",
            "        return c;",
            "    }",
            "    inline Int operator/(Int&b){",
            "        if(b.l<2)return *this/b.toint();",
            "        Int c,d;Re i,j,le,r,mid,k;c.CL();d.CL();",
            "        for(i=l;i;i--){",
            "            for(j=++d.l;j>1;j--)d.s[j]=d.s[j-1];",
            "            d.s[1]=s[i];",
            "            if(d<b)continue;",
            "            le=k=0;r=base-1;",
            "            while(le<=r){",
            "                mid=(le+r)>>1;",
            "                if(b*mid<=d)le=mid+1,k=mid;",
            "                else r=mid-1;",
            "            }",
            "            c.s[i]=k,d=d-b*k;",
            "        }",
            "        for(c.l=l;!c.s[c.l]&&c.l>1;c.l--);",
            "        return c;",
            "    }",
            "    inline Int operator%(const Re &b){",
            "        Int c;LL x=0;c.CL();",
            "        for(Re i=l;i;i--)x=(x*base+s[i])%b;",
            "        return c=x;",
            "    }",
            "    inline Int operator%(const LL&b){",
            "        Int c;LL x=0;c.CL();",
            "        for(Re i=l;i;i--)x=(x*base+s[i])%b;",
            "        return c=x;",
            "    }",
            "    inline Int operator%(Int&b){",
            "        if(b.l<2)return *this%b.toint();",
            "        Int c;Re i,j,le,r,mid,k;c.CL();",
            "        for(i=l;i;i--){",
            "            for(j=++c.l;j>1;j--)c.s[j]=c.s[j-1];",
            "            c.s[1]=s[i];",
            "            if(c<b)continue;",
            "            le=k=0,r=base-1;",
            "            while(le<=r){",
            "                mid=(le+r)>>1;",
            "                if(b*mid<=c)le=mid+1,k=mid;",
            "                else r=mid-1;",
            "            }",
            "            c=c-b*k;",
            "        }",
            "        for(;!c.s[c.l]&&c.l>1;c.l--);",
            "        return c;",
            "    }",
            "    inline Int operator+=(Int&b){return *this=*this+b;}",
            "    inline Int operator+=(LL&b){return *this=*this+b;}",
            "    inline Int operator+=(Re &b){return *this=*this+b;}",
            "    inline Int operator-=(Int&b){return *this=*this-b;}",
            "    inline Int operator-=(LL&b){return *this=*this-b;}",
            "    inline Int operator-=(Re &b){return *this=*this-b;}",
            "    inline Int operator*=(Int&b){return *this=*this*b;}",
            "    inline Int operator*=(LL&b){return *this=*this*b;}",
            "    inline Int operator*=(Re &b){return *this=*this*b;}",
            "    inline Int operator/=(Int&b){return *this=*this/b;}",
            "    inline Int operator/=(LL&b){return *this=*this/b;}",
            "    inline Int operator/=(Re &b){return *this=*this/b;}",
            "    inline Int operator%=(Int&b){return *this=*this%b;}",
            "    inline Int operator%=(LL&b){return *this=*this%b;}",
            "    inline Int operator%=(Re &b){return *this=*this%b;}",
            "    inline bool operator<(const Int&b)const{",
            "        if(l^b.l)return l<b.l;",
            "        for(Re i=l;i;i--)if(s[i]^b.s[i])return s[i]<b.s[i];",
            "        return 0;",
            "    }",
            "    inline bool operator<=(const Int&b)const{",
            "        if(l^b.l)return l<b.l;",
            "        for(Re i=l;i;i--)if(s[i]^b.s[i])return s[i]<b.s[i];",
            "        return 1;",
            "    }",
            "    inline bool operator>(const Int&b)const{",
            "        if(l^b.l)return l>b.l;",
            "        for(Re i=l;i;i--)",
            "            if(s[i]^b.s[i])return s[i]>b.s[i];",
            "        return 0;",
            "    }",
            "    inline bool operator>=(const Int&b)const{",
            "        if(l^b.l)return l>b.l;",
            "        for(Re i=l;i;i--)if(s[i]^b.s[i])return s[i]>b.s[i];",
            "        return 1;",
            "    }",
            "    inline bool operator==(const Int&b)const{",
            "        if(l^b.l)return 0;",
            "        for(Re i=l;i;i--)if(s[i]^b.s[i])return 0;",
            "        return 1;",
            "    }",
            "    inline bool operator!=(const Int&b)const{",
            "        if(l^b.l)return 1;",
            "        for(Re i=l;i;i--)if(s[i]^b.s[i])return 1;",
            "        return 0;",
            "    }",
            "    inline bool operator<(LL b)const{Int c;return *this<(c=b);}",
            "    inline bool operator<=(LL b)const{Int c;return *this<=(c=b);}",
            "    inline bool operator>(LL b)const{Int c;return *this>(c=b);}",
            "    inline bool operator>=(LL b)const{Int c;return *this>=(c=b);}",
            "    inline bool operator==(LL b)const{Int c;return *this==(c=b);}",
            "    inline bool operator!=(LL b)const{Int c;return *this!=(c=b);}",
            "    inline bool operator<(Re b)const{Int c;return *this<(c=b);}",
            "    inline bool operator<=(Re b)const{Int c;return *this<=(c=b);}",
            "    inline bool operator>(Re b)const{Int c;return *this>(c=b);}",
            "    inline bool operator>=(Re b)const{Int c;return *this>=(c=b);}",
            "    inline bool operator==(Re b)const{Int c;return *this==(c=b);}",
            "    inline bool operator!=(Re b)const{Int c;return *this!=(c=b);}",
            "};",
            "Int a,b;",
            "int main(){",
            "    a.re_l();",
            "    b.re_l();",
            "    a.pr();printf(\"+\");b.pr();printf(\"=\");(a+b).pr();printf(\"\\n\");",
            "    a.pr();printf(\"-\");b.pr();printf(\"=\");",
            "    if(a<b){putchar('-');(b-a).pr();}",
            "    else(a-b).pr();printf(\"\\n\");",
            "    a.pr();printf(\"*\");b.pr();printf(\"=\");(a*b).pr();printf(\"\\n\");",
            "    a.pr();printf(\"/\");b.pr();printf(\"=\");(a/b).pr();printf(\"\\n\");",
            "    a.pr();printf(\"%%\");b.pr();printf(\"=\");(a%b).pr();printf(\"\\n\");",
            "    if(a<b)printf(\"a<b\\n\");",
            "    if(a<=b)printf(\"a<=b\\n\");",
            "    if(a>b)printf(\"a>b\\n\");",
            "    if(a>=b)printf(\"a>=b\\n\");",
            "    if(a==b)printf(\"a==b\\n\");",
            "    if(a!=b)printf(\"a!=b\\n\");",
            "}",
            ""
        ],
        "description": "插入 高精模板 (史上最全没有之一)"
    },
    "Huffman": {
        "prefix": "acm-2.2荷马史诗",
        "body": [
            "#pragma GCC optimize(2)",
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#include<algorithm>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "using namespace std;",
            "LL ans,fu,S,d,k,n,t,i,x;",
            "struct QAQ{LL x,d;inline bool operator<(QAQ b)const{return x==b.x?d<b.d:x<b.x;}}Q[100011];",
            "inline void up(Re p){",
            "\twhile(p>1)",
            "\t\tif(Q[p]<Q[p>>1])swap(Q[p],Q[p>>1]),p>>=1;",
            "\t\telse break;",
            "}",
            "inline void down(Re p){",
            "\tint s=p<<1;",
            "\twhile(s<=t){",
            "\t\tif(s<t&&Q[s|1]<Q[s])s++;",
            "\t\tif(Q[s]<Q[p])swap(Q[s],Q[p]),p=s,s<<=1;",
            "\t\telse break;",
            "\t}",
            "}",
            "inline void push(Re x,Re d){Q[++t].x=x,Q[t].d=d;up(t);}",
            "inline void delet(Re p){swap(Q[p],Q[t--]);down(p);}",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    if(fu)x=-x;",
            "}",
            "int main(){",
            "\tin(n),in(k);",
            "\twhile(n--)in(x),push(x,0);",
            "\twhile((t-1)%(k-1))push(0,0);",
            "\twhile(t>1){",
            "\t\tx=k,S=0,d=0;",
            "\t\twhile(x--)d=max(d,Q[1].d),S+=Q[1].x,delet(1);",
            "\t\tans+=S,push(S,d+1);",
            "\t}",
            "\tprintf(\"%lld\\n%lld\",ans,Q[1].d);",
            "}",
            ""
        ],
        "description": "插入 Huffman"
    },
    "二叉堆 (Supermarket)": {
        "prefix": "acm-2.2小根堆",
        "body": [
            "#pragma GCC optimize(2)",
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "using namespace std;",
            "struct QAQ{int w,d;}a[10003];",
            "int ans,n,i;",
            "inline bool cmp(QAQ a,QAQ b){return a.d!=b.d?a.d<b.d:a.w>b.w;}",
            "struct QWQ{",
            "\tint heap[10003],t;",
            "\tinline void CL(){memset(heap,0,sizeof(heap));t=0;}",
            "\tinline void up(int p){",
            "\t\twhile(p>1)",
            "\t\t\tif(heap[p>>1]>heap[p])swap(heap[p],heap[p>>1]),p>>=1;",
            "\t\t\telse break;",
            "\t}",
            "\tinline void down(int p){",
            "\t\tint s=(p<<1);",
            "\t\twhile(s<=t){",
            "\t\t\tif(s<t&&heap[s]>heap[s|1])s++;",
            "\t\t\tif(heap[s]<heap[p]){",
            "\t\t\t\tswap(heap[s],heap[p]);",
            "\t\t\t\tp=s,s<<=1;",
            "\t\t\t}",
            "\t\t\telse break;",
            "\t\t}",
            "\t}",
            "\tinline void pop(){delet(1);}",
            "\tinline int top(){return heap[1];}",
            "\tinline int size(){return t;}",
            "\tinline void push(int x){heap[++t]=x;up(t);}",
            "\tinline void delet(int p){swap(heap[p],heap[t--]);down(p);}",
            "}Q;",
            "int main(){",
            "    while(scanf(\"%d\",&n)!=EOF){",
            "        for(i=1;i<=n;i++)scanf(\"%d%d\",&a[i].w,&a[i].d);",
            "        sort(a+1,a+n+1,cmp);ans=0;Q.CL();",
            "        for(i=1;i<=n;i++)",
            "            if(Q.size()<a[i].d)Q.push(a[i].w);",
            "            else if(Q.top()<a[i].w)Q.pop(),Q.push(a[i].w);",
            "        while(Q.size())ans+=Q.top(),Q.pop();",
            "        printf(\"%d\\n\",ans);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 二叉堆 (Supermarket)"
    },
    "单调栈": {
        "prefix": "acm-2.1Largest Rectangle in a Histogram",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "int i,n,t,wi,a[100005],Q[100005],W[100005];",
            "long long ans;",
            "int main(){",
            "    while(scanf(\"%d\",&n)!=EOF){",
            "        if(!n)break;",
            "        for(i=1;i<=n;i++)scanf(\"%d\",&a[i]);",
            "        ans=a[n+1]=t=0;",
            "        for(i=1;i<=n+1;i++)",
            "            if(a[i]>Q[t])Q[++t]=a[i],W[t]=1;",
            "            else{",
            "                wi=0;",
            "                while(t&&a[i]<=Q[t])ans=std::max(ans,(long long)(wi+=W[t])*Q[t--]);",
            "                Q[++t]=a[i],W[t]=wi+1;",
            "            }",
            "        printf(\"%lld\\n\",ans);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 单调栈"
    },
    "对顶栈": {
        "prefix": "acm-2.1Editor",
        "body": [
            "#include<algorithm>",
            "#include<iostream>",
            "#include<cstdio>",
            "using namespace std;",
            "const int N=1e6+5;",
            "int m,x,tl,tr,L[N],R[N],f[N],s[N];char a;",
            "int main(){",
            "    while(scanf(\"%d\",&m)!=EOF){",
            "        s[0]=0;f[0]=-0xfffffff;tl=tr=0;",
            "        while(m--){",
            "            cin>>a;",
            "            if(a=='I'){",
            "                scanf(\"%d\",&x);",
            "                L[++tl]=x;",
            "                f[tl]=max(f[tl-1],s[tl]=s[tl-1]+x);",
            "            }",
            "            else if(a=='R'){",
            "                if(tr){",
            "                    x=L[++tl]=R[tr--];",
            "                    f[tl]=max(f[tl-1],s[tl]=s[tl-1]+x);",
            "                }",
            "            }",
            "            else if(a=='Q')scanf(\"%d\",&x),printf(\"%d\\n\",f[x]);",
            "            else if(a=='L'){if(tl)R[++tr]=L[tl--];}",
            "            else if(tl)tl--;",
            "        }",
            "    }",
            "}",
            ""
        ],
        "description": "插入 对顶栈"
    },
    "表达式求值": {
        "prefix": "acm-2.1加 减 乘 除 幂 括号",
        "body": [
            "#include<iostream>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cctype>",
            "#define LL long long",
            "using namespace std;",
            "int n,f,t1,t2,i,power[300],ch[40];",
            "LL x,sum[40];string a;",
            "LL mi(LL x,LL k){",
            "    LL s=1;",
            "    while(k){",
            "        if(k&1)s=(s*x);",
            "        x=(x*x);k>>=1;",
            "    }",
            "    return s;",
            "}",
            "inline void pop(char fh){",
            "    t1--;t2--;",
            "    if(fh=='+')sum[t1]+=sum[t1+1];",
            "    if(fh=='-')sum[t1]-=sum[t1+1];",
            "    if(fh=='*')sum[t1]*=sum[t1+1];",
            "    if(fh=='/')sum[t1]/=sum[t1+1];",
            "    if(fh=='^')sum[t1]=mi(sum[t1],sum[t1+1]);",
            "}",
            "int main(){",
            "    cin>>a;a='('+a+')';n=a.size();",
            "    power['(']=0;power['+']=power['-']=1;power['*']=power['/']=2;power['^']=3;",
            "    while(i<n){",
            "        x=0,f=0;",
            "        while(isdigit(a[i]))x=x*10+a[i++]-'0',f=1;",
            "        if(f)sum[++t1]=x;",
            "        if(a[i]=='(')ch[++t2]=a[i++];",
            "        if(a[i]==')'){",
            "            while(ch[t2]!='(')pop(ch[t2]);",
            "            i++;t2--;",
            "        }",
            "        if(power[a[i]]){",
            "            if(a[i]=='-'&&a[i-1]=='('){",
            "                x=0,i++;",
            "                while(isdigit(a[i]))x=x*10+a[i++]-'0';",
            "                sum[++t1]=-x;",
            "            }",
            "            else {",
            "                while(power[a[i]]<=power[ch[t2]])pop(ch[t2]);",
            "                ch[++t2]=a[i++];",
            "            }",
            "        }",
            "    }",
            "    while(t2)pop(ch[t2]);",
            "    printf(\"%lld\",sum[1]);",
            "}",
            ""
        ],
        "description": "插入 表达式求值"
    },
    "单调队列：蚯蚓": {
        "prefix": "acm-2.1f",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "using namespace std;",
            "const int N=7100005;",
            "int A[N],B[N],C[N],ans[N],h1,t1,h2,t2,h3,t3,s[100005],tmp,re,x,i,n,m,q,u,v,t;",
            "double p;",
            "inline int f(){",
            "    int a=-0xfffffff;",
            "    if(h1<=t1)a=max(a,A[h1]);",
            "    if(h2<=t2)a=max(a,B[h2]);",
            "    if(h3<=t3)a=max(a,C[h3]);",
            "    if(h1<=t1&&a==A[h1])h1++;",
            "    else if(h2<=t2&&a==B[h2])h2++;",
            "    else h3++;",
            "    return a;",
            "}",
            "inline bool cmp(int a,int b){return a>b;}",
            "int main(){",
            "    scanf(\"%d%d%d%d%d%d\",&n,&m,&q,&u,&v,&t);",
            "    p=1.0*u/v;h1=h2=h3=1;",
            "    for(i=1;i<=n;i++)scanf(\"%d\",&s[i]);",
            "    sort(s+1,s+n+1,cmp);",
            "    for(i=1;i<=n;i++)A[++t1]=s[i];",
            "    for(i=1;i<=m;i++){",
            "        x=f();",
            "        x+=tmp;",
            "        if(i%t==0)printf(\"%d \",x);",
            "        re=p*x;",
            "        B[++t2]=re-tmp-q;",
            "        C[++t3]=x-re-tmp-q;",
            "        tmp+=q;",
            "    }",
            "    printf(\"\\n\");",
            "    for(i=h1;i<=t1;i++)ans[++ans[0]]=A[i];",
            "    for(i=h2;i<=t2;i++)ans[++ans[0]]=B[i];",
            "    for(i=h3;i<=t3;i++)ans[++ans[0]]=C[i];",
            "    sort(ans+1,ans+ans[0]+1,cmp);",
            "    for(i=1;i<=ans[0];i++)",
            "        if(i%t==0)printf(\"%d \",ans[i]+tmp);",
            "    return 0;",
            "}",
            ""
        ],
        "description": "插入 单调队列：蚯蚓"
    },
    "滑动窗口": {
        "prefix": "acm-2.1数组维护单调队列",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "const int N=1e6+5;",
            "int n,k,i,h,t,a[N],Q[N],D[N];",
            "int main(){",
            "    scanf(\"%d%d\",&n,&k);",
            "    for(i=1;i<=n;i++){",
            "        scanf(\"%d\",&a[i]);",
            "        while(h<=t&&Q[t]>=a[i])t--;Q[++t]=a[i],D[t]=i;",
            "        while(h<t&&D[h]+k-1<i)h++;",
            "        if(i>=k)printf(\"%d \",Q[h]);",
            "    }",
            "    printf(\"\\n\");h=t=0;",
            "    for(i=1;i<=n;i++){",
            "        while(h<=t&&Q[t]<=a[i])t--;Q[++t]=a[i],D[t]=i;",
            "        while(h<t&&D[h]+k-1<i)h++;",
            "        if(i>=k)printf(\"%d \",Q[h]);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 滑动窗口"
    },
    "黑匣子": {
        "prefix": "acm-2.1优先队列",
        "body": [
            "#include<bits/stdc++.h>",
            "#define itn int",
            "#define mian main",
            "using namespace std;",
            "int len,a[30005],piu,op;",
            "char s;",
            "priority_queue<int,vector<int>, greater<int> >sak;",
            "priority_queue<int,vector<int>,less<int> >b;",
            "int main(){",
            "    while(scanf(\"%c\",&s)){",
            "        if(s=='A'){",
            "            while(s!='(') scanf(\"%c\",&s);",
            "            scanf(\"%d\",&a[++len]);",
            "            getchar();",
            "            piu++;",
            "        }",
            "        if(s=='G'){",
            "            getchar();",
            "            getchar();",
            "\t\t\twhile(op<piu){",
            "            \top++;",
            "           \t \tb.push(a[op]);",
            "           \t \tsak.push(b.top());",
            "            \tb.pop();",
            "        \t}",
            "        \tprintf(\"%d \",sak.top());",
            "        \tb.push(sak.top());",
            "        \tsak.pop();",
            "        }",
            "        getchar();",
            "    } ",
            "    return 0;",
            "}",
            ""
        ],
        "description": "插入 黑匣子"
    },
    "manacher": {
        "prefix": "acm-6.2标准700ms",
        "body": [
            "// luogu-judger-enable-o2",
            "#include<algorithm>",
            "#include<cstdio>",
            "using namespace std;",
            "const int N=22000003;",
            "char a[N]={'$','|'},c=getchar();int r[N],mid,ans,R,n=1,i;",
            "int main(){",
            "    while(c>='a'&&c<='z')a[++n]=c,a[++n]='|',c=getchar();",
            "    for(i=1;i<=n;i++){",
            "        if(i<=R)r[i]=min(r[(mid<<1)-i],R-i+1);",
            "        else r[i]=1;",
            "        while(a[i-r[i]]==a[i+r[i]])r[i]++;",
            "        if(i+r[i]-1>R)mid=i,R=i+r[i]-1;",
            "        ans=max(ans,r[i]-1);",
            "    }",
            "    printf(\"%d\",ans);",
            "}",
            ""
        ],
        "description": "插入 manacher"
    },
    "manacher(仅适用于找最长回文长度)": {
        "prefix": "acm-6.2玄学150ms",
        "body": [
            "// luogu-judger-enable-o2",
            "#include<cstdio>",
            "char a[11550000]={'$'};int T,i,s,l,r;",
            "int main(){",
            "    gets(a+1);",
            "    for(i=1;a[i];++i){",
            "        l=r=i;",
            "        while(a[i]==a[r+1])++r;",
            "        i=r;",
            "        while(a[r+1]==a[l-1])++r,--l;",
            "        if(r-l+1>s)s=r-l+1;",
            "    }",
            "    printf(\"%d\",s);",
            "}",
            ""
        ],
        "description": "插入 manacher(仅适用于找最长回文长度)"
    },
    "Trie树": {
        "prefix": "acm-6.3前缀统计",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "#define R register int",
            "using namespace std;",
            "const int SP=500003;",
            "int trie[SP][26],pan[SP],ed[SP],re,t=1,n,m;char ch[55];",
            "inline void add(char ch[]){",
            "    R a,i=0,p=1,l=strlen(ch);",
            "    for(;i<l;i++){",
            "        a=ch[i]-'a';",
            "        if(!trie[p][a])trie[p][a]=++t;",
            "        p=trie[p][a];",
            "    }",
            "    ++ed[p];",
            "}",
            "inline int find(char ch[]){",
            "    R i=0,p=1,ans=0,l=strlen(ch);",
            "    for(;i<l;i++){",
            "        p=trie[p][ch[i]-'a'];",
            "        ans+=ed[p];",
            "        if(!p)return ans;",
            "    }",
            "    return ans;",
            "}",
            "int main(){",
            "    scanf(\"%d%d\",&n,&m);",
            "    while(n--){scanf(\"%s\",ch);add(ch);}",
            "    while(m--){scanf(\"%s\",ch);printf(\"%d\\n\",find(ch));}",
            "}",
            ""
        ],
        "description": "插入 Trie树"
    },
    "可持久化Trie树": {
        "prefix": "acm-6.3最大异或和",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=6e5+5,logN=24;",
            "int n,x,y,z,T,A[N],pt[N];char op;",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "struct Trie{",
            "\tint O,cnt[N*(logN+2)],tr[N*(logN+2)][2];",
            "\tinline void insert(Re p,Re q,Re o,Re x){",
            "\t\tif(o<0)return;Re i=(x>>o)&1;",
            "\t\ttr[p][i]=++O,tr[p][i^1]=tr[q][i^1];",
            "\t\tcnt[tr[p][i]]=cnt[tr[q][i]]+1;",
            "\t\tinsert(tr[p][i],tr[q][i],o-1,x);",
            "\t}",
            "\tinline int ask(Re p,Re q,Re o,Re x){",
            "\t\tif(o<0)return 0;Re i=(x>>o)&1;",
            "\t\tif(cnt[tr[q][i^1]]>cnt[tr[p][i^1]])return (1<<o)+ask(tr[p][i^1],tr[q][i^1],o-1,x);",
            "\t\telse return ask(tr[p][i],tr[q][i],o-1,x);",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T);",
            "\tfor(Re i=1;i<=n;++i)in(A[i]),A[i]^=A[i-1],T1.insert(pt[i]=++T1.O,pt[i-1],logN,A[i]);",
            "\tT1.insert(pt[0]=++T1.O,0,logN,0);",
            "\twhile(T--){",
            "\t\tscanf(\" %c\",&op),in(x);",
            "\t\tif(op=='A')++n,A[n]=A[n-1]^x,T1.insert(pt[n]=++T1.O,pt[n-1],logN,A[n]);",
            "\t\telse in(y),in(z),--x,--y,printf(\"%d\\n\",T1.ask(x?pt[x-1]:0,pt[y],logN,z^A[n]));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 可持久化Trie树"
    },
    "Snowflake Snow Snowflakes": {
        "prefix": "acm-6.5最小表示法+Hash",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<map>",
            "#define R register int",
            "#define uLL long long",
            "int n,t,p=13333331,re,A[13];",
            "std::map<uLL,int>pan;",
            "inline int sakura(int a[]){",
            "    R i=1,j=2,k;",
            "    while(i<=6&&j<=6){",
            "        k=0;",
            "        while(k<6&&a[i+k]==a[j+k])++k;",
            "        if(k==6)break;",
            "        if(a[i+k]>a[j+k]){i+=k+1;if(i==j)++i;}",
            "        else{j+=k+1;if(i==j)++j;}",
            "    }",
            "    return i<j?i:j;",
            "}",
            "inline uLL Hash(int a[],int st){",
            "    R i=0;uLL x=0;",
            "    for(;i<6;++i)x=x*p+(uLL)a[st+i];",
            "    return x;",
            "}",
            "inline uLL find(int a[]){",
            "    R x,y,i=1,k=0,b[13];",
            "    for(;i<=6;i++)b[i]=a[7-i];",
            "    for(i=1;i<=6;i++)a[i+6]=a[i],b[i+6]=b[i];",
            "\tx=sakura(a),y=sakura(b);",
            "    for(i=0;i<6;i++)",
            "\t\tif(a[x+i]<b[y+i])return Hash(a,x);",
            "\t\telse if(a[x+i]>b[y+i])return Hash(b,y);",
            "    return Hash(a,x);",
            "}",
            "int main(){",
            "    scanf(\"%d\",&n);R i,j;",
            "    for(i=1;i<=n;i++){",
            "        for(j=1;j<=6;j++)scanf(\"%d\",&A[j]);",
            "        uLL re=find(A);",
            "        if(pan[re]){printf(\"Twin snowflakes found.\");return 0;}",
            "    \tpan[re]=1;",
            "\t}",
            "    printf(\"No two snowflakes are alike.\");",
            "}",
            ""
        ],
        "description": "插入 Snowflake Snow Snowflakes"
    },
    "字符串Hash表": {
        "prefix": "acm-6.4兔子与兔子",
        "body": [
            "#include<iostream>",
            "#include<string>",
            "#include<cstdio>",
            "#define LL long long",
            "using namespace std;",
            "const int N=1e6+5;",
            "int l1,r1,l2,r2,n,m,i,p=27;",
            "LL f[N],mi[N];string a;",
            "inline LL Hash(int l,int r){return f[r]-f[l-1]*mi[r-l+1];}",
            "int main(){",
            "    cin>>a;n=a.size();a='$'+a;mi[0]=1;",
            "    for(i=1;i<=n;i++)f[i]=f[i-1]*p+a[i]-'a'+1,mi[i]=mi[i-1]*p;",
            "    scanf(\"%d\",&m);",
            "    while(m--){",
            "        scanf(\"%d%d%d%d\",&l1,&r1,&l2,&r2);",
            "        if(Hash(l1,r1)==Hash(l2,r2))printf(\"Yes\\n\");",
            "        else printf(\"No\\n\");",
            "    }",
            "}",
            ""
        ],
        "description": "插入 字符串Hash表"
    },
    "Necklace": {
        "prefix": "acm-6.5最小表示法判断同构",
        "body": [
            "#include<cstring>",
            "#include<cstdio>",
            "int i,j,k,n,m,x,y,st;char a[2000003],b[2000003];",
            "inline int sakura(char a[]){",
            "    i=1,j=2;",
            "    while(i<=n&&j<=n){",
            "        k=0;",
            "        while(k<n&&a[i+k]==a[j+k])++k;",
            "        if(k==n)break;",
            "        if(a[i+k]>a[j+k]){i+=k+1;if(i==j)++i;}",
            "        else{j+=k+1;if(i==j)++j;}",
            "    }",
            "    return i<j?i:j;",
            "}",
            "inline int judge(char a[],char b[]){",
            "    n=strlen(a+1);",
            "    for(i=1;i<=n;++i)a[i+n]=a[i],b[i+n]=b[i];",
            "    x=sakura(a),y=sakura(b);",
            "    a[x+n]=b[y+n]='\\0';",
            "    return !strcmp(a+x,b+y);",
            "}",
            "int main(){",
            "    scanf(\"%s%s\",a+1,b+1);",
            "    if(judge(a,b)){printf(\"Yes\\n\");puts(a+x);}",
            "    else printf(\"No\");",
            "}",
            ""
        ],
        "description": "插入 Necklace"
    },
    "最小表示法": {
        "prefix": "acm-6.5工艺",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=3e5+5;",
            "int n,s[N<<1];",
            "inline void in(Re &x){",
            "    Re f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int main(){",
            "\tin(n);",
            "\tfor(Re i=1;i<=n;++i)in(s[i]),s[i+n]=s[i];",
            "\tRe i=1,j=2;",
            "\twhile(i<=n&&j<=n){",
            "\t\tRe k=1;",
            "\t\twhile(k<=n&&s[i+k-1]==s[j+k-1])++k;",
            "\t\tif(k>n)break;",
            "\t\tif(s[i+k-1]>s[j+k-1])i+=k;",
            "\t\telse j+=k;",
            "\t\tif(i==j)++i;",
            "\t}",
            "\tRe st=min(i,j);",
            "\tfor(Re i=0;i<n;++i)printf(\"%d \",s[st+i]);",
            "}",
            ""
        ],
        "description": "插入 最小表示法"
    },
    "Cyclical Quest": {
        "prefix": "acm-6.6暴力解法-广义SAM不加特判会MLE",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<vector>",
            "#include<map>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=3e6+5,M=1e6+3,logN=21;",
            "int n,T,len[M],vis[N<<1],tmp[N<<1];LL ans;char s[M];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "vector<int>Q[M];",
            "struct Suffix_Automaton{",
            "\tint O,last,siz[N<<1],link[N<<1],maxlen[N<<1];map<int,int>trans[N<<1];",
            "\tSuffix_Automaton(){O=1;}",
            "\tinline int insert(Re ch,Re op,Re last){",
            "\t\tif(trans[last].find(ch)!=trans[last].end()){",
            "\t\t\tRe p=last,x=trans[p][ch];",
            "            if(maxlen[p]+1==maxlen[x])return x;",
            "            else{",
            "                Re y=++O;maxlen[y]=maxlen[p]+1;",
            "                for(map<int,int>::iterator it=trans[x].begin();it!=trans[x].end();++it)trans[y].insert(*it);",
            "                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "                link[y]=link[x],link[x]=y;",
            "                return y;",
            "            }",
            "\t\t}",
            "\t\tRe z=++O,p=last;if(op)siz[z]=1;maxlen[z]=maxlen[p]+1;",
            "\t\twhile(p&&trans[p].find(ch)==trans[p].end())trans[p][ch]=z,p=link[p];",
            "\t\tif(!p)link[z]=1;",
            "\t\telse{",
            "\t\t\tRe x=trans[p][ch];",
            "\t\t\tif(maxlen[x]==maxlen[p]+1)link[z]=x;",
            "\t\t\telse{",
            "\t\t\t\tRe y=++O;maxlen[y]=maxlen[p]+1;",
            "\t\t\t\tfor(map<int,int>::iterator it=trans[x].begin();it!=trans[x].end();++it)trans[y].insert(*it);",
            "\t\t\t\twhile(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "\t\t\t\tlink[y]=link[x],link[x]=link[z]=y;",
            "\t\t\t}",
            "\t\t}",
            "\t\treturn z;",
            "\t}",
            "\tint o,head[N<<1];",
            "\tstruct QAQ{int to,next;}a[N<<1];",
            "\tinline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tinline void dfs(Re x){",
            "\t\tfor(Re i=head[x];i;i=a[i].next)dfs(a[i].to),siz[x]+=siz[a[i].to];",
            "\t}",
            "\tinline void build(){",
            "\t\tfor(Re i=2;i<=O;++i)add(link[i],i);dfs(1);",
            "\t}",
            "\tinline int ask(Re p,Re len){",
            "\t\twhile(maxlen[link[p]]>=len)p=link[p];return p;",
            "\t}",
            "}SAM;",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    scanf(\"%s\",s+1),n=strlen(s+1),in(T);",
            "    for(Re i=1,last=1;s[i];++i)last=SAM.insert(s[i]-'a',1,last);",
            "    for(Re i=1;i<=T;++i){",
            "    \tscanf(\"%s\",s+1),len[i]=strlen(s+1);Re last=1;",
            "    \tfor(Re j=1;j<len[i];++j)last=SAM.insert(s[j]-'a',0,last);",
            "    \tQ[i].push_back(last=SAM.insert(s[len[i]]-'a',0,last));",
            "    \tfor(Re j=1;j<len[i];++j)Q[i].push_back(last=SAM.insert(s[j]-'a',0,last));",
            "\t}",
            "\tSAM.build();",
            "    for(Re i=1;i<=T;++i){",
            "    \ttmp[0]=ans=0;",
            "    \tfor(Re j=0,SZ=Q[i].size();j<SZ;++j){",
            "    \t\tRe x=SAM.ask(Q[i][j],len[i]);",
            "    \t\tif(vis[x])continue;",
            "    \t\ttmp[++tmp[0]]=x,vis[x]=1,ans+=SAM.siz[x];",
            "\t\t}",
            "\t\tfor(Re j=1;j<=tmp[0];++j)vis[tmp[j]]=0;",
            "\t\tprintf(\"%lld\\n\",ans);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 Cyclical Quest"
    },
    "Sevenk Love Oimaster": {
        "prefix": "acm-6.6离线广义SAM",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=2e5+5;",
            "int n,t,T,Len[N];char s[N],ch[360003];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Trie{",
            "\tint O,c[N],fa[N],tr[N][26];",
            "\tTrie(){O=1;}",
            "\tinline void insert(char ch[],Re id){",
            "\t\tRe p=1;",
            "\t\tfor(Re i=1;ch[i];Len[id]=i,++i){",
            "\t\t\tRe a=ch[i]-'a';s[++t]=a;",
            "\t\t\tif(!tr[p][a])tr[p][a]=++O,fa[O]=p,c[O]=a;",
            "\t\t\tp=tr[p][a];",
            "\t\t}",
            "\t}",
            "}T1;",
            "struct Suffix_Automaton{",
            "\tint O,pos[N],cnt[N],link[N],maxlen[N],trans[N][26];queue<int>Q;",
            "\tSuffix_Automaton(){O=1;}",
            "\tinline int insert(Re ch,Re last){",
            "\t\tRe x,y,z=++O,p=last,flag=0;maxlen[z]=maxlen[last]+1;",
            "\t\twhile(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];",
            "\t\tif(!p)link[z]=1;",
            "\t\telse{",
            "\t\t\tx=trans[p][ch];",
            "\t\t\tif(maxlen[p]+1==maxlen[x])link[z]=x;",
            "\t\t\telse{",
            "\t\t\t\ty=++O;maxlen[y]=maxlen[p]+1;",
            "\t\t\t\tfor(Re i=0;i<26;++i)trans[y][i]=trans[x][i];",
            "\t\t\t\twhile(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "\t\t\t\tlink[y]=link[x],link[z]=link[x]=y;",
            "\t\t\t}",
            "\t\t}",
            "\t\treturn flag?y:z;",
            "\t}",
            "\tint co[N];",
            "\tinline void updata(Re p,Re id){",
            "\t\twhile(p&&co[p]!=id)++cnt[p],co[p]=id,p=link[p];",
            "\t}",
            "\tinline void build(){",
            "\t\tfor(Re i=0;i<26;++i)if(T1.tr[1][i])Q.push(T1.tr[1][i]);",
            "\t\tpos[1]=1;",
            "\t\twhile(!Q.empty()){",
            "\t\t\tRe x=Q.front();Q.pop();",
            "\t\t\tpos[x]=insert(T1.c[x],pos[T1.fa[x]]);",
            "\t\t\tfor(Re i=0;i<26;++i)if(T1.tr[x][i])Q.push(T1.tr[x][i]);",
            "\t\t}",
            "\t\tfor(Re i=1,t=0;i<=n;++i)",
            "\t\t\tfor(Re j=1,p=1;j<=Len[i];++j)",
            "\t\t\t\tupdata(pos[p=T1.tr[p][s[++t]]],i);",
            "\t}",
            "\tinline void ask(char ch[]){",
            "\t\tRe p=1,flag=1;",
            "\t\tfor(Re i=1;ch[i]&&flag;++i){",
            "\t\t\tRe a=ch[i]-'a';",
            "\t\t\tif(trans[p][a])p=trans[p][a];",
            "\t\t\telse flag=0;",
            "\t\t}",
            "\t\tprintf(\"%d\\n\",flag?cnt[p]:0);",
            "\t}",
            "}SAM;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T);",
            "\tfor(Re i=1;i<=n;++i)scanf(\"%s\",ch+1),T1.insert(ch,i);",
            "\tSAM.build();",
            "\twhile(T--)scanf(\"%s\",ch+1),SAM.ask(ch);",
            "}",
            ""
        ],
        "description": "插入 Sevenk Love Oimaster"
    },
    "AC自动机": {
        "prefix": "acm-6.6Trie图",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=2e5+3;",
            "int n;char ch[N*10];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct AC_Automaton{",
            "\tint O,edp[N],fail[N],tr[N][26];queue<int>Q;",
            "\tAC_Automaton(){O=1;}",
            "\tinline void insert(char ch[],Re id){",
            "\t\tRe p=1;",
            "\t\tfor(Re i=1;ch[i];++i){",
            "\t\t\tRe a=ch[i]-'a';",
            "\t\t\tif(!tr[p][a])tr[p][a]=++O;",
            "\t\t\tp=tr[p][a];",
            "\t\t}",
            "\t\tedp[id]=p;",
            "\t}",
            "\tinline void get_fail(){",
            "\t\tfor(Re i=0;i<26;++i)tr[0][i]=1;",
            "\t\tQ.push(1);",
            "\t\twhile(!Q.empty()){",
            "\t\t\tRe x=Q.front();Q.pop();",
            "\t\t\tfor(Re i=0;i<26;++i)",
            "\t\t\t\tif(tr[x][i])fail[tr[x][i]]=tr[fail[x]][i],Q.push(tr[x][i]);",
            "\t\t\t\telse tr[x][i]=tr[fail[x]][i];",
            "\t\t}",
            "\t}",
            "\tint ru[N],cnt[N];",
            "\tinline void sakura(char ch[]){",
            "\t\tfor(Re i=1,p=1;ch[i];++i)p=tr[p][ch[i]-'a'],++cnt[p];",
            "\t\tfor(Re i=2;i<=O;++i)++ru[fail[i]];",
            "\t\tfor(Re i=1;i<=O;++i)if(!ru[i])Q.push(i);",
            "\t\twhile(!Q.empty()){",
            "\t\t\tRe x=Q.front();Q.pop();",
            "\t\t\tcnt[fail[x]]+=cnt[x];",
            "\t\t\tif(!(--ru[fail[x]]))Q.push(fail[x]);",
            "\t\t}",
            "\t\tfor(Re i=1;i<=n;++i)printf(\"%d\\n\",cnt[edp[i]]);",
            "\t}",
            "}AC;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n);",
            "\tfor(Re i=1;i<=n;++i)scanf(\"%s\",ch+1),AC.insert(ch,i);",
            "\tAC.get_fail();",
            "\tscanf(\"%s\",ch+1);AC.sakura(ch);",
            "}",
            ""
        ],
        "description": "插入 AC自动机"
    },
    "LCT动态维护SAM": {
        "prefix": "acm-6.6Substring[Bzoj2555]",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<string>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=12e5+3;",
            "int T,ans,mask;char op[10],s[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline string In(Re mask){",
            "    scanf(\"%s\",s);string chars=s;",
            "    for(int j=0;j<chars.length();j++){",
            "        mask=(mask*131+j)%chars.length();",
            "        char t=chars[j];",
            "        chars[j]=chars[mask];",
            "        chars[mask]=t;",
            "    }",
            "    return chars;",
            "}",
            "struct Suffix_Automaton{",
            "\tstruct Link_Cut_Tree{",
            "\t\t#define pl tr[p].ps[0]",
            "\t\t#define pr tr[p].ps[1]",
            "\t\t#define pf tr[p].fa",
            "\t\tint Q[N];",
            "\t\tstruct QAQ{int fa,ans,add,ps[2];}tr[N];",
            "\t\tinline void add(Re p,Re v){tr[p].ans+=v,tr[p].add+=v;}",
            "\t\tinline void pushdown(Re p){",
            "\t\t\tRe v=tr[p].add;",
            "\t\t\tif(v){",
            "\t\t\t\tif(pl)add(pl,v);",
            "\t\t\t\tif(pr)add(pr,v);",
            "\t\t\t\ttr[p].add=0;",
            "\t\t\t}",
            "\t\t}",
            "\t\tinline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}",
            "\t\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\t\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\t\tinline void rotate(Re p){",
            "\t\t\tRe fa=pf,fas=which(p);",
            "\t\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\t\tRe x=tr[p].ps[fas^1];",
            "\t\t\tif(nort(fa))tr[pa].ps[pas]=p;pf=pa;",
            "\t\t\tconnect(x,fa,fas),connect(fa,p,fas^1);",
            "\t\t}",
            "\t\tinline void splay(Re p){",
            "\t\t\tRe x=p,t=0;Q[++t]=x;",
            "\t\t\twhile(nort(x))Q[++t]=x=tr[x].fa;",
            "\t\t\twhile(t)pushdown(Q[t--]);",
            "\t\t\tfor(Re fa;nort(p);rotate(p))",
            "\t\t\t\tif(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);",
            "\t\t}",
            "\t\tinline void access(Re p){for(Re son=0;p;son=p,p=pf)splay(p),pr=son;}",
            "\t\tinline void link(Re x,Re y){tr[x].fa=y,access(y),splay(y),add(y,tr[x].ans);}",
            "\t\tinline void cut(Re x){",
            "\t\t\taccess(x),splay(x),add(tr[x].ps[0],-tr[x].ans);",
            "\t\t\ttr[tr[x].ps[0]].fa=0,tr[x].ps[0]=0;",
            "\t\t}",
            "\t\tinline int ask(Re x){splay(x);return tr[x].ans;}",
            "\t}LCT;",
            "\tint O,last,link[N],maxlen[N],trans[N][30];",
            "\tSuffix_Automaton(){last=O=1;}",
            "\tinline void insert(char ch){",
            "\t\tRe z=++O,p=last;LCT.tr[z].ans=1,maxlen[z]=maxlen[last]+1;",
            "\t\twhile(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];",
            "\t\tif(!p)link[z]=1,LCT.link(z,1);",
            "\t\telse{",
            "\t\t\tRe x=trans[p][ch];",
            "\t\t\tif(maxlen[x]==maxlen[p]+1)link[z]=x,LCT.link(z,x);",
            "\t\t\telse{",
            "\t\t\t\tRe y=++O;maxlen[y]=maxlen[p]+1;",
            "\t\t\t\tfor(Re i=0;i<26;++i)trans[y][i]=trans[x][i];",
            "\t\t\t\twhile(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "\t\t\t\tlink[y]=link[x],LCT.cut(x),LCT.link(y,link[y]);",
            "\t\t\t\tlink[x]=link[z]=y,LCT.link(x,y),LCT.link(z,y);",
            "\t\t\t}",
            "\t\t}",
            "\t\tlast=z;",
            "\t}",
            "\tinline void add(string ch){",
            "\t\tfor(Re i=0;ch[i];++i)insert(ch[i]-'A');",
            "\t}",
            "\tinline int ask(string ch){",
            "\t\tRe p=1;",
            "\t\tfor(Re i=0;ch[i];++i)if(!(p=trans[p][ch[i]-'A']))return 0;",
            "\t\treturn LCT.ask(p);",
            "\t}",
            "}SAM;",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    in(T),scanf(\"%s\",s+1);",
            "    for(Re i=1;s[i];++i)SAM.insert(s[i]-'A');",
            "\twhile(T--){",
            "\t\tscanf(\"%s\",op);string s=In(mask);",
            "\t\tif(op[0]=='A')SAM.add(s);",
            "\t\telse mask^=(ans=SAM.ask(s)),printf(\"%d\\n\",ans);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 LCT动态维护SAM"
    },
    "SAM后缀自动机": {
        "prefix": "acm-6.6Suffix_Automaton",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=2e6+5;",
            "char ch[2000003];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Suffix_Automaton{",
            "\tint O,last,ru[N],siz[N],link[N],maxlen[N],minlen[N],trans[N][26];queue<int>Q;",
            "\tSuffix_Automaton(){last=O=1;}",
            "\tinline void insert(char ch){",
            "\t\tRe z=++O,p=last;siz[z]=1,maxlen[z]=maxlen[last]+1;",
            "\t\twhile(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];",
            "\t\tif(!p)link[z]=1;//û�ҵ�trans[...][ch]",
            "\t\telse{",
            "\t\t\tRe x=trans[p][ch];",
            "\t\t\tif(maxlen[p]+1==maxlen[x])link[z]=x;",
            "\t\t\telse{",
            "\t\t\t\tRe y=++O;maxlen[y]=maxlen[p]+1;",
            "\t\t\t\t",
            "\t\t\t\tfor(Re i=0;i<26;++i)trans[y][i]=trans[x][i];",
            "\t\t\t\twhile(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "\t\t\t\tlink[y]=link[x];",
            "\t\t\t\t",
            "\t\t\t\tlink[z]=link[x]=y;",
            "\t\t\t}",
            "\t\t}",
            "\t\tlast=z;",
            "\t}",
            "\tinline void Tuopu(){",
            "\t\tfor(Re i=2;i<=O;++i)++ru[link[i]];",
            "\t\tfor(Re i=1;i<=O;++i)if(!ru[i])Q.push(i);",
            "\t\twhile(!Q.empty()){",
            "\t\t\tRe x=Q.front();Q.pop();",
            "\t\t\tsiz[link[x]]+=siz[x];",
            "\t\t\tif(!(--ru[link[x]]))Q.push(link[x]);",
            "\t\t}",
            "\t}",
            "\tinline void sakura(){",
            "\t\tfor(Re i=2;i<=O;++i)minlen[i]=maxlen[link[i]]+1;",
            "\t\tTuopu();Re ans=0;",
            "\t\tfor(Re i=1;i<=O;++i)if(siz[i]>1)ans=max(ans,siz[i]*maxlen[i]);",
            "\t\tprintf(\"%d\\n\",ans);",
            "\t}",
            "}SAM;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tscanf(\"%s\",ch+1);",
            "\tfor(Re i=1;ch[i];++i)SAM.insert(ch[i]-'a');",
            "\tSAM.sakura();",
            "}",
            ""
        ],
        "description": "插入 SAM后缀自动机"
    },
    "SAM转后缀树": {
        "prefix": "acm-6.6字母 letter",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=4e5+10;",
            "int n,x,y,T;LL P,M,G,K;char s[N>>1];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Sakura2{",
            "    int O,last,pos[N],siz[N],link[N],maxlen[N],trans[N][26];",
            "    // siz[x]: 节点x的出现次数 (endpos的大小)",
            "    inline void insert(Re ch,Re id){",
            "        Re z=++O,p=last;pos[z]=id,siz[z]=1,maxlen[z]=maxlen[last]+1;",
            "        while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];",
            "        if(!p)link[z]=1;",
            "        else{",
            "            Re x=trans[p][ch];",
            "            if(maxlen[p]+1==maxlen[x])link[z]=x;",
            "            else{",
            "                Re y=++O;maxlen[y]=maxlen[p]+1,pos[y]=pos[x];",
            "                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];",
            "                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "                link[y]=link[x],link[z]=link[x]=y;",
            "            }",
            "        }",
            "        last=z;",
            "    }",
            "    int t,ID[N],to[N][26];LL S[N];",
            "    inline void dfs1(Re x){",
            "        for(Re i=0;i<26;++i)",
            "            if(to[x][i])dfs1(to[x][i]),siz[x]+=siz[to[x][i]];",
            "    }",
            "    inline void dfs2(Re x){",
            "        if(x!=1)ID[++t]=x;",
            "        for(Re i=0;i<26;++i)if(to[x][i])dfs2(to[x][i]);",
            "    }",
            "    inline LL calc(Re L,Re R){return 1ll*(L+R)*(R-L+1)/2;}",
            "    inline void build(){",
            "        last=O=1;",
            "        for(Re i=1;i<=n/2;++i)swap(s[i],s[n-i+1]);",
            "        for(Re i=1;i<=n;++i)insert(s[i]-'a',i);",
            "        for(Re i=2;i<=O;++i)to[link[i]][s[pos[i]-maxlen[link[i]]]-'a']=i;",
            "        dfs1(1),dfs2(1);",
            "        for(Re i=1;i<=t;++i)x=ID[i],S[i]=S[i-1]+1ll*siz[x]*calc(maxlen[link[x]]+1,maxlen[x]);",
            "    }",
            "    inline char ask(LL K){",
            "        Re l=1,r=t,x;",
            "        while(l<r){",
            "            Re mid=l+r>>1;",
            "            if(S[mid]<K)l=mid+1;",
            "            else r=mid;",
            "        }",
            "        x=ID[l],K-=S[l-1],l=maxlen[link[x]]+1,r=maxlen[x];",
            "        while(l<r){",
            "            Re mid=l+r>>1;",
            "            if(1ll*siz[x]*calc(maxlen[link[x]]+1,mid)<K)l=mid+1;",
            "            else r=mid;",
            "        }",
            "        K-=1ll*siz[x]*calc(maxlen[link[x]]+1,l-1),K=(K-1)%l+1;",
            "        return s[pos[x]-K+1];",
            "    }",
            "    char ans;",
            "    inline void sakura(){",
            "        build();",
            "        while(T--)scanf(\"%lld%lld\",&P,&M),K=P*G%M+1,G+=(ans=ask(K)),putchar(ans),puts(\"\");",
            "    }",
            "}T2;",
            "int main(){",
            "    freopen(\"letter.in\",\"r\",stdin);",
            "    freopen(\"letter.out\",\"w\",stdout);",
            "    scanf(\"%s\",s+1),n=strlen(s+1);in(T);",
            "    T2.sakura();",
            "    fclose(stdin);",
            "    fclose(stdout);",
            "}",
            ""
        ],
        "description": "插入 SAM转后缀树"
    },
    "SAM转后缀树转后缀数组": {
        "prefix": "acm-6.6不同子串个数",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+5;",
            "int n;char s[N];LL ans;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Suffix_Array{",
            "\tint H[N],SA[N],rank[N],height[N];",
            "\tinline void get_height(){",
            "\t\tfor(Re i=1;i<=n;++i)rank[SA[i]]=i;",
            "\t\tfor(Re i=1,k=0;i<=n;++i){",
            "\t\t\tif(rank[i]==1)continue;",
            "\t\t\tif(k)--k;",
            "\t\t\tRe j=SA[rank[i]-1];",
            "\t\t\twhile(i+k<=n&&j+k<=n&&s[i+k]==s[j+k])++k;",
            "\t\t\theight[rank[i]]=H[i]=k;",
            "\t\t}",
            "\t}",
            "}SA;",
            "int pan[N<<1],pos[N<<1];",
            "struct Suffix_Tree{",
            "\tint t,tr[N<<1][26];",
            "\tinline void add(Re x,Re y,Re c){tr[x][c]=y;}",
            "\tinline void dfs(Re x){",
            "\t\tif(pan[x])SA.SA[++t]=pos[x];",
            "\t\tfor(Re i=0;i<26;++i)if(tr[x][i])dfs(tr[x][i]);",
            "\t}",
            "}ST;",
            "struct Suffix_Automaton{",
            "\tint O,last,link[N<<1],maxlen[N<<1],trans[N<<1][26];",
            "\tSuffix_Automaton(){last=O=1;}",
            "\tinline void insert(Re ch,Re id){",
            "\t\tRe z=++O,p=last;maxlen[z]=maxlen[p]+1,pan[z]=1,pos[z]=id;",
            "\t\twhile(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];",
            "\t\tif(!p)link[z]=1;",
            "\t\telse{",
            "\t\t\tRe x=trans[p][ch];",
            "\t\t\tif(maxlen[p]+1==maxlen[x])link[z]=x;",
            "\t\t\telse{",
            "\t\t\t\tRe y=++O;maxlen[y]=maxlen[p]+1;",
            "\t\t\t\tfor(Re i=0;i<26;++i)trans[y][i]=trans[x][i];",
            "\t\t\t\twhile(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "\t\t\t\tpos[y]=pos[x],link[y]=link[x],link[x]=link[z]=y;",
            "\t\t\t}",
            "\t\t}",
            "\t\tlast=z;",
            "\t}",
            "\tinline void build(){",
            "\t\tfor(Re i=n;i>=1;--i)insert(s[i]-'a',i);",
            "\t\tfor(Re i=2;i<=O;++i)ST.add(link[i],i,s[pos[i]+maxlen[link[i]]]-'a');",
            "\t}",
            "}SAM;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),scanf(\"%s\",s+1),SAM.build(),ST.dfs(1),SA.get_height();",
            "\tfor(Re i=1;i<=n;++i)ans+=n-SA.SA[i]+1-SA.height[i];",
            "\tprintf(\"%lld\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 SAM转后缀树转后缀数组"
    },
    "后缀数组": {
        "prefix": "acm-6.6倍增",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=1e6+3;",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Suffix_Array{",
            "\tint n,m,x[N],y[N],H[N],SA[N],cnt[N],rank[N],Height[N];char s[N];",
            "\t//Suf[i]: s[i,n]",
            "\tinline void get_SA(){",
            "\t\tm=128;",
            "\t\tfor(Re i=1;i<=n;++i)++cnt[x[i]=s[i]];",
            "\t\tfor(Re i=2;i<=m;++i)cnt[i]+=cnt[i-1];",
            "\t\tfor(Re i=n;i>=1;--i)SA[cnt[x[i]]--]=i;",
            "\t\tfor(Re len=1;len<=n;len<<=1){",
            "\t\t\tRe t=0;",
            "\t\t\tfor(Re i=n-len+1;i<=n;++i)y[++t]=i;",
            "\t\t\tfor(Re i=1;i<=n;++i)if(SA[i]>len)y[++t]=SA[i]-len;",
            "\t\t\t",
            "\t\t\tfor(Re i=1;i<=m;++i)cnt[i]=0;",
            "\t\t\tfor(Re i=1;i<=n;++i)++cnt[x[i]];",
            "\t\t\tfor(Re i=2;i<=m;++i)cnt[i]+=cnt[i-1];",
            "\t\t\tfor(Re i=n;i>=1;--i)SA[cnt[x[y[i]]]--]=y[i],y[i]=0;",
            "\t\t\t",
            "\t\t\tswap(x,y);",
            "\t\t\tx[SA[1]]=m=1;",
            "\t\t\tfor(Re i=2;i<=n;++i)",
            "\t\t\t\tx[SA[i]]=(y[SA[i]]==y[SA[i-1]]&&y[SA[i]+len]==y[SA[i-1]+len])?m:++m;",
            "\t\t\tif(m==n)break;",
            "\t\t}",
            "\t\tfor(Re i=1;i<=n;++i)printf(\"%d \",SA[i]);",
            "\t}",
            "\tinline void get_Height(){",
            "\t\tfor(Re i=1;i<=n;++i)rank[SA[i]]=i;",
            "\t\tfor(Re i=1,k=0;i<=n;++i){",
            "\t\t\tif(rank[i]==1)continue;",
            "\t\t\tif(k)--k;//H[i-1]-1<=H[i]",
            "\t\t\tRe j=SA[rank[i]-1];",
            "\t\t\twhile(i+k<=n&&j+k<=n&&s[i+k]==s[j+k])++k;",
            "\t\t\tHeight[rank[i]]=k;",
            "\t\t}",
            "//\t\tfor(Re i=1;i<=n;++i)printf(\"%d \",Height[i]);",
            "\t}",
            "}SA;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tscanf(\"%s\",SA.s+1),SA.n=strlen(SA.s+1);",
            "\tSA.get_SA(),SA.get_Height();",
            "}",
            ""
        ],
        "description": "插入 后缀数组"
    },
    "回文自动机": {
        "prefix": "acm-6.6回文树",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e5+5;",
            "char s[N];",
            "inline void in(Re &x){",
            "    Re f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Palindromic_Automaton{",
            "\tint O,last,siz[N],cnt[N],len[N],fail[N],trans[N][26];",
            "\tPalindromic_Automaton(){O=1,len[1]=-1,fail[0]=fail[1]=last=1;}",
            "\t// 0:偶数回文的根节点",
            "\t// 1:奇数回文的根节点",
            "\tinline int find(Re p,Re id){while(s[id-1-len[p]]!=s[id])p=fail[p];return p;}",
            "\tinline void insert(Re ch,Re id){",
            "\t\tRe cur=find(last,id),now=trans[cur][ch];",
            "\t\tif(!now){",
            "\t\t\tnow=++O,len[now]=len[cur]+2;",
            "\t\t\tfail[now]=trans[find(fail[cur],id)][ch];",
            "\t\t\tcnt[now]=cnt[fail[now]]+1;",
            "\t\t\ttrans[cur][ch]=now;",
            "\t\t}",
            "\t\t++siz[now],last=now;",
            "\t}",
            "\tinline void sakura(){",
            "\t\tfor(Re i=O;i>=2;--i)siz[fail[i]]+=siz[i];",
            "\t}",
            "}PAM;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tscanf(\"%s\",s+1);",
            "\tfor(Re i=1,k=0;s[i];++i){",
            "\t\ts[i]=(s[i]-'a'+k)%26+'a';",
            "\t\tPAM.insert(s[i]-'a',i);",
            "\t\tprintf(\"%d \",k=PAM.cnt[PAM.last]);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 回文自动机"
    },
    "广义SAM": {
        "prefix": "acm-6.6离线dfs",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=2e6+5,M=1e6+3;",
            "int n,t;char ch[N];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Trie{",
            "    int O,c[M],fa[M],tr[M][26];",
            "    Trie(){O=1;}",
            "    inline void insert(char ch[]){",
            "        Re p=1;",
            "        for(Re i=1;ch[i];++i){",
            "            Re a=ch[i]-'a';",
            "            if(!tr[p][a])tr[p][a]=++O,fa[O]=p,c[O]=a;",
            "            p=tr[p][a];",
            "        }",
            "    }",
            "}T1;",
            "struct Suffix_Automaton{",
            "    int O,pos[N],link[N],maxlen[N],trans[N][26];queue<int>Q;",
            "    //trans[i]: 状态转移指针",
            "    Suffix_Automaton(){O=1;}",
            "    inline int insert(Re ch,Re last){",
            "        Re x,y,z=++O,p=last;maxlen[z]=maxlen[last]+1;",
            "        while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];",
            "        if(!p)link[z]=1;",
            "        else{",
            "            x=trans[p][ch];",
            "            if(maxlen[p]+1==maxlen[x])link[z]=x;",
            "            else{",
            "                y=++O;maxlen[y]=maxlen[p]+1;",
            "                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];",
            "                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "                link[y]=link[x],link[z]=link[x]=y;",
            "            }",
            "        }",
            "        return z;",
            "    }",
            "    inline void dfs(Re x){",
            "\t\tfor(Re i=0,to;i<26;++i)if(to=T1.tr[x][i])",
            "\t\t\tpos[to]=insert(T1.c[to],pos[x]),dfs(to);",
            "\t}",
            "    inline void build(){pos[1]=1,dfs(1);}",
            "    inline void sakura(){",
            "        LL ans=0;",
            "        for(Re i=2;i<=O;++i)ans+=maxlen[i]-maxlen[link[i]];",
            "        printf(\"%lld\\n\",ans);",
            "    }",
            "}SAM;",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    in(n);",
            "    for(Re i=1;i<=n;++i)scanf(\"%s\",ch+1),T1.insert(ch);",
            "    SAM.build(),SAM.sakura();",
            "}",
            ""
        ],
        "description": "插入 广义SAM"
    },
    "广义SAM+线段树合并维护siz+倍增": {
        "prefix": "acm-6.6Forensic Examination",
        "body": [
            "#include<algorithm>",
            "#include<iostream>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<string>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e5+3,M=5e4+3,logN=21;",
            "int n,m,x,y,l,r,T,pos[N];char s[N],ch[M];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct QWQ{",
            "    int x,id;QWQ(Re X=0,Re ID=0){x=X,id=ID;}",
            "    inline bool operator>(const QWQ &O)const{return x!=O.x?x>O.x:id<O.id;}",
            "};",
            "inline QWQ max(QWQ A,QWQ B){return A>B?A:B;}",
            "int pt[N+M<<1];",
            "struct Segment_Tree{",
            "    #define pl (tr[p].lp)",
            "    #define pr (tr[p].rp)",
            "    #define mid ((L+R)>>1)",
            "    int O;",
            "    struct QAQ{int lp,rp;QWQ ans;}tr[(M<<1)*30];",
            "    inline void pushup(Re p){",
            "        tr[p].ans=max(tr[pl].ans,tr[pr].ans);",
            "    }",
            "    inline void change(Re &p,Re L,Re R,Re x){",
            "        if(!p)p=++O;",
            "        if(L==R){++tr[p].ans.x,tr[p].ans.id=L;return;}",
            "        if(x<=mid)change(pl,L,mid,x);",
            "        else change(pr,mid+1,R,x);",
            "        pushup(p);",
            "    }",
            "    inline int merge(Re p,Re q,Re L,Re R){",
            "        if(!p||!q)return p+q;",
            "        Re x=++O;",
            "        if(L==R){tr[x]=tr[p],tr[x].ans.x+=tr[q].ans.x;return x;}",
            "        tr[x].lp=merge(pl,tr[q].lp,L,mid);",
            "        tr[x].rp=merge(pr,tr[q].rp,mid+1,R);",
            "        pushup(x);return x;",
            "    }",
            "    inline QWQ ask(Re p,Re L,Re R,Re l,Re r){",
            "        if(!p)return QWQ(0,m+1);",
            "        if(l<=L&&R<=r)return tr[p].ans;",
            "        QWQ ans=QWQ(0,m+1);",
            "        if(l<=mid)ans=max(ans,ask(pl,L,mid,l,r));",
            "        if(r>mid)ans=max(ans,ask(pr,mid+1,R,l,r));",
            "        return ans;",
            "    }",
            "}TR;",
            "struct Suffix_Automaton{",
            "    int O,link[N+M<<1],maxlen[N+M<<1],trans[N+M<<1][26];",
            "    Suffix_Automaton(){O=1;}",
            "    inline int insert(Re ch,Re last,Re id){",
            "        if(trans[last][ch]){",
            "            Re p=last,x=trans[p][ch];",
            "            if(maxlen[p]+1==maxlen[x]){if(id)TR.change(pt[x],1,m,id);return x;}",
            "            else{",
            "                Re y=++O;maxlen[y]=maxlen[p]+1;",
            "                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];",
            "                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "                link[y]=link[x],link[x]=y;",
            "                if(id)TR.change(pt[y],1,m,id);",
            "                return y;",
            "            }",
            "        }",
            "        Re z=++O,p=last;maxlen[z]=maxlen[p]+1;",
            "        while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];",
            "        if(!p)link[z]=1;",
            "        else{",
            "            Re x=trans[p][ch];",
            "            if(maxlen[x]==maxlen[p]+1)link[z]=x;",
            "            else{",
            "                Re y=++O;maxlen[y]=maxlen[p]+1;",
            "                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];",
            "                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "                link[y]=link[x],link[x]=link[z]=y;",
            "            }",
            "        }",
            "        if(id)TR.change(pt[z],1,m,id);",
            "        return z;",
            "    }",
            "    int o,deep[N+M<<1],head[N+M<<1],ant[N+M<<1][23];",
            "    struct QAQ{int to,next;}a[N+M<<1];",
            "    inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "    inline void dfs(Re x,Re fa){",
            "        deep[x]=deep[ant[x][0]=fa]+1;",
            "        for(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];",
            "        for(Re i=head[x],to;i;i=a[i].next)",
            "            dfs(to=a[i].to,x),pt[x]=TR.merge(pt[x],pt[to],1,m);",
            "    }",
            "    inline void build(){",
            "        for(Re i=2;i<=O;++i)add(link[i],i);dfs(1,0);",
            "    }",
            "    inline int get(Re x,Re len){",
            "        Re p=pos[x];",
            "        for(Re i=logN;i>=0;--i)if(ant[p][i]&&maxlen[ant[p][i]]>=len)p=ant[p][i];",
            "        return p;",
            "    }",
            "    inline void sakura(Re l,Re r,Re x,Re y){",
            "        QWQ ans=TR.ask(pt[get(y,y-x+1)],1,m,l,r);",
            "        if(ans.x==0)ans.id=l;",
            "        printf(\"%d %d\\n\",ans.id,ans.x);",
            "    }",
            "}SAM;",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    scanf(\"%s\",s+1),n=strlen(s+1),in(m);",
            "    for(Re i=1;i<=m;++i){",
            "        scanf(\"%s\",ch+1);Re last=1;",
            "        for(Re j=1;ch[j];++j)last=SAM.insert(ch[j]-'a',last,i);",
            "    }",
            "    for(Re i=1,last=1;i<=n;++i)pos[i]=last=SAM.insert(s[i]-'a',last,0);",
            "    SAM.build(),in(T);",
            "    while(T--)in(l),in(r),in(x),in(y),SAM.sakura(l,r,x,y);",
            "}",
            ""
        ],
        "description": "插入 广义SAM+线段树合并维护siz+倍增"
    },
    "区间本质不同子串个数": {
        "prefix": "acm-6.6SAM+LCT+线段树",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,M=2e5+3;",
            "int n,T;LL Ans[M];char s[N];",
            "struct Query{int l,r,id;inline bool operator<(const Query &O)const{return r<O.r;}}Q[M];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tstruct QAQ{LL S,add;}tr[N<<2];",
            "\tinline void updata(Re p,Re L,Re R,LL v){tr[p].add+=v,tr[p].S+=v*(R-L+1);}",
            "\tinline void pushdown(Re p,Re L,Re R){",
            "\t\tif(tr[p].add)updata(pl,L,mid,tr[p].add),updata(pr,mid+1,R,tr[p].add),tr[p].add=0;",
            "\t}",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Re v){",
            "\t\tif(l<=L&&R<=r){updata(p,L,R,v);return;}",
            "\t\tpushdown(p,L,R);",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,v);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,v);",
            "\t\ttr[p].S=tr[pl].S+tr[pr].S;",
            "\t}",
            "\tinline LL ask(Re p,Re L,Re R,Re l,Re r){",
            "\t\tif(l<=L&&R<=r)return tr[p].S;",
            "\t\tpushdown(p,L,R);LL ans=0;",
            "\t\tif(l<=mid)ans+=ask(pl,L,mid,l,r);",
            "\t\tif(r>mid)ans+=ask(pr,mid+1,R,l,r);",
            "\t\treturn ans;",
            "\t}",
            "\t#undef pl",
            "\t#undef pr",
            "}TR;",
            "struct Suffix_Automaton{",
            "\tint O,last,pos[N],link[N<<1],maxlen[N<<1],trans[N<<1][26];",
            "\tSuffix_Automaton(){last=O=1;}",
            "\tinline void insert(Re ch,Re id){",
            "\t\tRe z=++O,p=last;maxlen[z]=maxlen[p]+1;",
            "\t\twhile(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];",
            "\t\tif(!p)link[z]=1;",
            "\t\telse{",
            "\t\t\tRe x=trans[p][ch];",
            "\t\t\tif(maxlen[x]==maxlen[p]+1)link[z]=x;",
            "\t\t\telse{",
            "\t\t\t\tRe y=++O;maxlen[y]=maxlen[p]+1;",
            "\t\t\t\tfor(Re i=0;i<26;++i)trans[y][i]=trans[x][i];",
            "\t\t\t\twhile(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "\t\t\t\tlink[y]=link[x],link[z]=link[x]=y;",
            "\t\t\t}",
            "\t\t}",
            "\t\tpos[id]=last=z;",
            "\t}",
            "}SAM;",
            "struct Link_Cut_Tree{",
            "\t#define pl (tr[p].ps[0])",
            "\t#define pr (tr[p].ps[1])",
            "\t#define pf (tr[p].fa)",
            "\t#define pv (tr[p].v)",
            "\tint Q[N<<1];",
            "\tstruct QAQ{int v,fa,tag,ps[2];}tr[N<<1];",
            "\tinline void updata(Re p,Re v){tr[p].tag=tr[p].v=v;}",
            "\tinline void pushdown(Re p){",
            "\t\tif(tr[p].tag){",
            "\t\t\tif(pl)updata(pl,tr[p].tag);",
            "\t\t\tif(pr)updata(pr,tr[p].tag);",
            "\t\t\ttr[p].tag=0;",
            "\t\t}",
            "\t}",
            "\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\tinline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}",
            "\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\tinline void rotate(Re p){",
            "\t\tRe fa=pf,fas=which(p);",
            "\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\tRe x=tr[p].ps[fas^1];",
            "\t\tif(nort(fa))tr[pa].ps[pas]=p;pf=pa;",
            "\t\tconnect(x,fa,fas),connect(fa,p,fas^1);",
            "\t}",
            "\tinline void splay(Re p){",
            "\t\tRe x=p,t=0;Q[++t]=x;",
            "\t\twhile(tr[x].fa)Q[++t]=x=tr[x].fa;",
            "\t\twhile(t)pushdown(Q[t--]);",
            "\t\tfor(Re fa;nort(p);rotate(p))",
            "\t\t\tif(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);",
            "\t}",
            "\tinline void access(Re p,Re r){",
            "\t\tRe son=0;",
            "\t\tfor(;p;son=p,p=pf){",
            "\t\t\tsplay(p);",
            "\t\t\tif(pv)TR.change(1,1,n,pv-SAM.maxlen[p]+1,pv-SAM.maxlen[pf],-1);",
            "\t\t\tpr=son;",
            "\t\t}",
            "\t\tupdata(son,r),TR.change(1,1,n,1,r,1);",
            "\t}",
            "}T1;",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    scanf(\"%s\",s+1),n=strlen(s+1),in(T);",
            "\tfor(Re i=1;i<=n;++i)SAM.insert(s[i]-'a',i);",
            "\tfor(Re i=2;i<=SAM.O;++i)T1.tr[i].fa=SAM.link[i];",
            "\tfor(Re i=1;i<=T;++i)in(Q[i].l),in(Q[i].r),Q[i].id=i;",
            "    sort(Q+1,Q+T+1);",
            "    for(Re i=1,r=0;i<=T;++i){",
            "    \twhile(r<Q[i].r)++r,T1.access(SAM.pos[r],r);",
            "    \tAns[Q[i].id]=TR.ask(1,1,n,Q[i].l,Q[i].r);",
            "\t}",
            "\tfor(Re i=1;i<=T;++i)printf(\"%lld\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 区间本质不同子串个数"
    },
    "喵星球上的点名": {
        "prefix": "acm-6.6广义SAM",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#include<map>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=2e5+5;",
            "int n,t,T,x,s[N],ch[N],Len[N];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Suffix_Automaton{\t",
            "\tint O,pos[N],cnt[N],link[N],maxlen[N],minlen[N];queue<int>Q;map<int,int>trans[N];",
            "\tSuffix_Automaton(){O=1;}",
            "\tinline int insert(Re ch,Re last){",
            "\t\tif(trans[last][ch]&&maxlen[last]+1==maxlen[trans[last][ch]])return trans[last][ch];",
            "\t\tRe x,y,z=++O,p=last,flag=0;maxlen[z]=maxlen[last]+1;",
            "\t\twhile(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];",
            "\t\tif(!p)link[z]=1;",
            "\t\telse{",
            "\t\t\tx=trans[p][ch];",
            "\t\t\tif(maxlen[p]+1==maxlen[x])link[z]=x;",
            "\t\t\telse{",
            "\t\t\t\tif(maxlen[p]+1==maxlen[z])flag=1;",
            "\t\t\t\ty=++O;maxlen[y]=maxlen[p]+1;",
            "\t\t\t\ttrans[y]=trans[x];",
            "\t\t\t\twhile(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "\t\t\t\tlink[y]=link[x],link[z]=link[x]=y;",
            "\t\t\t}",
            "\t\t}",
            "\t\treturn flag?y:z;",
            "\t}",
            "\tint co[N];",
            "\tinline void updata(Re p,Re id){",
            "\t\twhile(p&&co[p]!=id)++cnt[p],co[p]=id,p=link[p];",
            "\t}",
            "\tint gs[N],Ans[N];",
            "\tinline void updata_(Re p,Re id){",
            "\t\twhile(p&&co[p]!=id)Ans[id]+=gs[p],co[p]=id,p=link[p];",
            "\t}",
            "\tinline void ask(Re ch[],Re L){",
            "\t\tRe p=1,flag=1;",
            "\t\tfor(Re i=1;i<=L&&flag;++i){",
            "\t\t\tRe a=ch[i];",
            "\t\t\tif(trans[p][a])p=trans[p][a];",
            "\t\t\telse flag=0;",
            "\t\t}",
            "\t\tif(flag)++gs[p];",
            "\t\tprintf(\"%d\\n\",flag?cnt[p]:0);",
            "\t}",
            "}SAM;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T);",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tin(Len[(i<<1)-1]);Re last=1;",
            "\t\tfor(Re j=1;j<=Len[(i<<1)-1];++j)in(x),last=SAM.insert(s[++t]=x,last);",
            "\t\tin(Len[i<<1]);last=1;",
            "\t\tfor(Re j=1;j<=Len[i<<1];++j)in(x),last=SAM.insert(s[++t]=x,last);",
            "\t}",
            "\tfor(Re i=1,t=0;i<=n;++i){",
            "\t\tfor(Re j=1,p=1;j<=Len[(i<<1)-1];++j)",
            "\t\t\tSAM.updata(p=SAM.trans[p][s[++t]],i);",
            "\t\tfor(Re j=1,p=1;j<=Len[i<<1];++j)",
            "\t\t\tSAM.updata(p=SAM.trans[p][s[++t]],i);",
            "\t}",
            "\twhile(T--){",
            "\t\tin(Len[0]);",
            "\t\tfor(Re i=1;i<=Len[0];++i)in(ch[i]);",
            "\t\tSAM.ask(ch,Len[0]);",
            "\t}",
            "\tmemset(SAM.co,0,sizeof(SAM.co));",
            "\tfor(Re i=1,t=0;i<=n;++i){",
            "\t\tfor(Re j=1,p=1;j<=Len[(i<<1)-1];++j)",
            "\t\t\tSAM.updata_(p=SAM.trans[p][s[++t]],i);",
            "\t\tfor(Re j=1,p=1;j<=Len[i<<1];++j)",
            "\t\t\tSAM.updata_(p=SAM.trans[p][s[++t]],i);",
            "\t}",
            "\tfor(Re i=1;i<=n;++i)printf(\"%d \",SAM.Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 喵星球上的点名"
    },
    "回文串": {
        "prefix": "acm-6.6PAM",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=3e5+5;",
            "char s[N];",
            "inline void in(Re &x){",
            "    Re f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Palindromic_Automaton{",
            "\tint O,last,siz[N],len[N],fail[N],trans[N][26];",
            "\tPalindromic_Automaton(){O=1,len[1]=-1,fail[0]=fail[1]=last=1;}",
            "\tinline int find(Re p,Re id){while(s[id-1-len[p]]!=s[id])p=fail[p];return p;}",
            "\tinline void insert(Re ch,Re id){",
            "\t\tRe cur=find(last,id),now=trans[cur][ch];",
            "\t\tif(!now){",
            "\t\t\tnow=++O,len[now]=len[cur]+2;",
            "\t\t\tfail[now]=trans[find(fail[cur],id)][ch];",
            "\t\t\ttrans[cur][ch]=now;",
            "\t\t}",
            "\t\t++siz[now],last=now;",
            "\t}",
            "\tinline void sakura(){",
            "\t\tLL ans=0;",
            "\t\tfor(Re i=O;i>=2;--i)siz[fail[i]]+=siz[i],ans=max(ans,(LL)siz[i]*len[i]);",
            "\t\tprintf(\"%lld\\n\",ans);",
            "\t}",
            "}PAM;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tscanf(\"%s\",s+1);",
            "\tfor(Re i=1;s[i];++i)PAM.insert(s[i]-'a',i);",
            "\tPAM.sakura();",
            "}",
            ""
        ],
        "description": "插入 回文串"
    },
    "找相同子串 (广义SAM记录siz)": {
        "prefix": "acm-6.6在线",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=8e5+5;",
            "char ch[200003];LL ans;",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Suffix_Automaton{",
            "    int O,ru[N],link[N],maxlen[N],siz[N][2],trans[N][26];queue<int>Q;",
            "    // siz[x]: |endpos[x]| 节点x的endpos大小",
            "    Suffix_Automaton(){O=1;}",
            "    inline int insert(Re ch,Re last,Re id){",
            "        if(trans[last][ch]){",
            "            Re p=last,x=trans[p][ch];",
            "            if(maxlen[p]+1==maxlen[x]){siz[x][id]=1;return x;} ",
            "            else{",
            "                Re y=++O;maxlen[y]=maxlen[p]+1;",
            "                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];",
            "                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "                link[y]=link[x],link[x]=y;",
            "                siz[y][id]=1;return y;",
            "            }",
            "        }",
            "        Re z=++O,p=last;maxlen[z]=maxlen[last]+1;",
            "        while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];",
            "        if(!p)link[z]=1;",
            "        else{",
            "            Re x=trans[p][ch];",
            "            if(maxlen[p]+1==maxlen[x])link[z]=x;",
            "            else{",
            "                Re y=++O;maxlen[y]=maxlen[p]+1;",
            "                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];",
            "                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];",
            "                link[y]=link[x],link[z]=link[x]=y;",
            "            }",
            "        }",
            "        siz[z][id]=1;",
            "        return z;",
            "    }",
            "    inline void sakura(){",
            "        for(Re i=2;i<=O;++i)++ru[link[i]];",
            "        for(Re i=1;i<=O;++i)if(!ru[i])Q.push(i);",
            "        while(!Q.empty()){",
            "            Re x=Q.front();Q.pop();",
            "            siz[link[x]][0]+=siz[x][0];",
            "            siz[link[x]][1]+=siz[x][1];",
            "            if(!(--ru[link[x]]))Q.push(link[x]);",
            "        }",
            "        for(Re i=2;i<=O;++i)//ͳ�ƴ�",
            "            ans+=(LL)siz[i][0]*siz[i][1]*(maxlen[i]-maxlen[link[i]]);",
            "        printf(\"%lld\\n\",ans);",
            "    }",
            "}SAM;",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    for(Re i=0;i<2;++i){",
            "        scanf(\"%s\",ch+1);Re last=1;",
            "        for(Re j=1;ch[j];++j)last=SAM.insert(ch[j]-'a',last,i);",
            "    }",
            "    SAM.sakura();",
            "}",
            ""
        ],
        "description": "插入 找相同子串 (广义SAM记录siz)"
    },
    "求等比数列和": {
        "prefix": "acm-7.1二分",
        "body": [
            "#include<cstdio>",
            "#define R register int",
            "int n,t,px[10005],pk[10005];",
            "inline void prime_devisor(int x){",
            "\tif(x%2==0){",
            "\t\tpx[++t]=2;",
            "\t\twhile(x%2==0)pk[t]++,x/=2;",
            "\t}",
            "\tfor(R i=3;i*i<=x;i+=2){",
            "\t\tif(x%i==0){",
            "\t\t\tpx[++t]=i;",
            "\t\t\twhile(x%i==0)pk[t]++,x/=i;",
            "\t\t}",
            "\t}",
            "\tif(x!=1)px[++t]=x,pk[t]=1;",
            "}",
            "inline int sakura(){",
            "\tscanf(\"%d\",&n);",
            "\tprintf(\"%d=\",n);",
            "\tprime_devisor(n);",
            "\tfor(R i=1;i<=t;i++){",
            "\t\tprintf(\"%d^%d\",px[i],pk[i]);",
            "\t\tif(i<t)printf(\"+\");",
            "\t}",
            "}",
            "int QAQWQ=sakura();",
            "int main(){}",
            ""
        ],
        "description": "插入 求等比数列和"
    },
    "对抗搜索+Alpha-Beta  (一双木棋chess TLE)": {
        "prefix": "acm-7.3最大分数",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=13,inf=2e9;",
            "int n,m,cnt,h[N],can[N],vis[N][N],A[2][N][N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int findmin(Re alpha,Re op);",
            "inline int findmax(Re beta,Re op);",
            "inline int findmin(Re alpha,Re op){",
            "\tif(cnt==n*m)return 0;",
            "\tRe ans=inf;",
            "\tfor(Re i=1,j;i<=n;++i)",
            "\t\tif(h[i]<m&&vis[i][j=h[i]+1]==-1&&h[i-1]>=j){",
            "\t\t\tvis[i][j]=op,++cnt,++h[i];",
            "\t\t\tans=min(ans,-A[op][i][j]+findmax(ans+A[op][i][j],op^1));",
            "\t\t\tvis[i][j]=-1,--cnt,--h[i];",
            "\t\t\tif(ans<=alpha)return ans;",
            "\t\t}",
            "\treturn ans;",
            "}",
            "inline int findmax(Re beta,Re op){",
            "\tif(cnt==n*m)return 0;",
            "\tRe ans=-inf;",
            "\tfor(Re i=1,j;i<=n;++i)",
            "\t\tif(h[i]<m&&vis[i][j=h[i]+1]==-1&&h[i-1]>=j){",
            "\t\t\tvis[i][j]=op,++cnt,++h[i];",
            "\t\t\tans=max(ans,A[op][i][j]+findmin(ans-A[op][i][j],op^1));",
            "\t\t\tvis[i][j]=-1,--cnt,--h[i];",
            "\t\t\tif(ans>=beta)return ans;",
            "\t\t}",
            "\treturn ans;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m);",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\tin(A[1][i][j]);",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\tin(A[0][i][j]);",
            "\tmemset(vis,-1,sizeof(vis));",
            "\th[0]=inf; ",
            "\tprintf(\"%d\\n\",findmax(inf,1));",
            "}",
            ""
        ],
        "description": "插入 对抗搜索+Alpha-Beta  (一双木棋chess TLE)"
    },
    "对抗搜索+Alpha-Beta  (Find the Winning Move)": {
        "prefix": "acm-7.3胜负",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=6,inf=2e9;",
            "int n=4,cnt,ansX,ansY,A[N][N];char op[5],s[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int check(Re op){",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tRe cnt1=0,cnt2=0;",
            "\t\tfor(Re j=1;j<=n;++j)cnt1+=(A[i][j]==op),cnt2+=(A[j][i]==op);",
            "\t\tif(cnt1==4||cnt2==4)return 1;",
            "\t}",
            "\tRe cnt1=0,cnt2=0;",
            "\tfor(Re i=1;i<=n;++i)cnt1+=(A[i][i]==op),cnt2+=(A[i][n-i+1]==op);",
            "\tif(cnt1==4||cnt2==4)return 1;",
            "\treturn 0;",
            "}",
            "inline int findmin(Re alpha,Re op);",
            "inline int findmax(Re beta,Re op);//[op=1:�ҵĻغ�]",
            "inline int findmin(Re alpha,Re op){",
            "\tif(cnt==16)return 0;",
            "\tif(check(op^1))return inf;",
            "\tRe ans=inf;",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=n;++j)",
            "\t\t\tif(A[i][j]==-1){",
            "\t\t\t\tA[i][j]=op,++cnt;",
            "\t\t\t\tans=min(ans,findmax(ans,op^1));",
            "\t\t\t\tA[i][j]=-1,--cnt;",
            "\t\t\t\tif(ans<=alpha)return ans;",
            "\t\t\t}",
            "\treturn ans;",
            "}",
            "inline int findmax(Re beta,Re op){",
            "\tif(cnt==16)return 0;",
            "\tif(check(op^1))return -inf;",
            "\tRe ans=-inf;",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=n;++j)",
            "\t\t\tif(A[i][j]==-1){",
            "\t\t\t\tA[i][j]=op,++cnt;",
            "\t\t\t\tans=max(ans,findmin(ans,op^1));",
            "\t\t\t\tA[i][j]=-1,--cnt;",
            "\t\t\t\tansX=i,ansY=j;",
            "\t\t\t\tif(ans>=beta)return ans;",
            "\t\t\t}",
            "\treturn ans;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\twhile(~scanf(\"%s\",op)&&op[0]!='$'){",
            "\t\tcnt=0;",
            "\t\tfor(Re i=1;i<=n;++i){",
            "\t\t\tscanf(\"%s\",s+1);",
            "\t\t\tfor(Re j=1;j<=n;++j)",
            "\t\t\t\tif(s[j]=='.')A[i][j]=-1,++cnt;",
            "\t\t\t\telse A[i][j]=(s[j]=='x');",
            "\t\t}",
            "\t\tif(cnt<=4)puts(\"#####\");",
            "\t\telse if(findmax(inf,1)==inf)printf(\"(%d,%d)\\n\",ansX-1,ansY-1);",
            "\t\telse puts(\"#####\");",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 对抗搜索+Alpha-Beta  (Find the Winning Move)"
    },
    "对抗搜索+记忆化  (一双木棋chess)": {
        "prefix": "acm-7.3最大分数",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<map>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=13,inf=2e9;",
            "int n,m,cnt,h[N],can[N],vis[N][N],A[2][N][N];",
            "map<LL,int>pan;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline LL Hash(Re op){LL ans=op+1;for(Re i=1;i<=n;++i)ans=ans*11ll+h[i];return ans;}",
            "inline int dfs(Re op){",
            "\tif(cnt==n*m)return 0;",
            "\tLL H=Hash(op);",
            "\tif(pan.find(H)!=pan.end())return pan[H];",
            "\tRe ans=op?-inf:inf;",
            "\tfor(Re i=1,j;i<=n;++i)",
            "\t\tif(h[i]<m&&vis[i][j=h[i]+1]==-1&&h[i-1]>=j){",
            "\t\t\tvis[i][j]=op,++cnt,++h[i];",
            "\t\t\tif(op)ans=max(ans,dfs(op^1)+A[op][i][j]);",
            "\t\t\telse ans=min(ans,dfs(op^1)-A[op][i][j]);",
            "\t\t\tvis[i][j]=-1,--cnt,--h[i];",
            "\t\t}",
            "\treturn pan[H]=ans;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m);",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\tin(A[1][i][j]);",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tfor(Re j=1;j<=m;++j)",
            "\t\t\tin(A[0][i][j]);",
            "\tmemset(vis,-1,sizeof(vis));",
            "\th[0]=inf;",
            "\tprintf(\"%d\\n\",dfs(1));",
            "}",
            ""
        ],
        "description": "插入 对抗搜索+记忆化  (一双木棋chess)"
    },
    "Perpetual Subtraction": {
        "prefix": "acm-7.4生成函数 移位",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=262144+3,P=998244353,G=3;",
            "int n,invn,invG,f[N],g[N],g0[N],gm[N],f0[N],fm[N],tr[N],jc[N],inv[N],invjc[N];LL m;",
            "template<typename T>inline void in(T &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,LL k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int Inv(Re x){return mi(x,P-2);}",
            "inline void NTT(Re *f,Re n,Re op){",
            "\tfor(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1){",
            "\t\tRe len=p>>1,w1=mi(op?invG:G,(P-1)/p);",
            "\t\tfor(Re st=0;st<n;st+=p)",
            "\t\t\tfor(Re i=st,base=1;i<=st+len-1;++i){",
            "\t\t\t\tRe tmp=(LL)base*f[len+i]%P;",
            "\t\t\t\tf[len+i]=(f[i]-tmp+P)%P,(f[i]+=tmp)%=P,base=(LL)base*w1%P;",
            "\t\t\t}",
            "\t}",
            "}",
            "inline void times(Re *f,Re n,Re *g,Re m){",
            "\tfor(m+=n,n=1;n<=m;n<<=1);invn=Inv(n),invG=Inv(G);",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tNTT(f,n,0),NTT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tNTT(f,n,1);",
            "\tfor(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;",
            "}",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    in(n),in(m);",
            "    for(Re i=0;i<=n;++i)in(f0[i]);",
            "    invjc[1]=invjc[0]=inv[1]=jc[1]=jc[0]=1;",
            "    for(Re i=2;i<=n+1;++i)inv[i]=(LL)inv[P%i]*(P-P/i)%P,jc[i]=(LL)jc[i-1]*i%P,invjc[i]=(LL)invjc[i-1]*inv[i]%P;",
            "    ",
            "\tfor(Re i=0;i<=n;++i)f[i]=(LL)jc[n-i]*f0[n-i]%P,g[i]=invjc[i];",
            "    times(f,n,g,n);",
            "\tfor(Re i=0;i<=n;++i)g0[i]=(LL)f[n-i]*invjc[i]%P;",
            "\t",
            "//\tfor(Re i=0;i<=n;++i)printf(\"%d \",g0[i]);puts(\"\");",
            "\tfor(Re i=0;i<=n;++i)gm[i]=(LL)g0[i]*mi(inv[i+1],m)%P;",
            "//\tfor(Re i=0;i<=n;++i)printf(\"%d \",gm[i]);puts(\"\");",
            "",
            "\tmemset(f,0,sizeof(f)),memset(g,0,sizeof(g));",
            "\tfor(Re i=0;i<=n;++i)f[i]=(LL)jc[n-i]*gm[n-i]%P,g[i]=(LL)invjc[i]*((i&1)?P-1:1)%P;",
            "\ttimes(f,n,g,n);",
            "\tfor(Re i=0;i<=n;++i)fm[i]=(LL)f[n-i]*invjc[i]%P;",
            "\t",
            "\tfor(Re i=0;i<=n;++i)printf(\"%d \",fm[i]);",
            "}",
            ""
        ],
        "description": "插入 Perpetual Subtraction"
    },
    "A×B Problem": {
        "prefix": "acm-7.4FFT",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=2097152+5;",
            "const LD Pi=acos(-1);",
            "int n,m,tr[N],Ans[N];char s1[N>>1],s2[N>>1];",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "struct CP{",
            "\tLD x,y;",
            "\tCP(LD X=0,LD Y=0){x=X,y=Y;}",
            "\tinline CP operator+(const CP &O)const{return CP(x+O.x,y+O.y);}",
            "\tinline CP operator-(const CP &O)const{return CP(x-O.x,y-O.y);}",
            "\tinline CP operator*(const CP &O)const{return CP(x*O.x-y*O.y,x*O.y+y*O.x);}",
            "\tinline CP operator*=(const CP &O){return *this=*this*O;}",
            "}f[N],g[N];",
            "inline void FFT(CP *f,Re n,Re op){",
            "\tfor(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1){",
            "\t\tRe len=p>>1;",
            "\t\tCP w1(cos(2*Pi/p),sin(2*Pi/p));",
            "\t\tif(op)w1.y*=-1;",
            "\t\tfor(Re st=0;st<n;st+=p){",
            "\t\t\tCP base(1,0);",
            "\t\t\tfor(Re i=st;i<=st+len-1;++i){",
            "\t\t\t\tCP tmp=f[len+i]*base;",
            "\t\t\t\tf[len+i]=f[i]-tmp,f[i]=f[i]+tmp,base*=w1;",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tscanf(\"%s%s\",s1,s2),n=strlen(s1),m=strlen(s2);",
            "\tfor(Re i=0;i<n;++i)f[i].x=s1[n-i-1]-'0';",
            "\tfor(Re i=0;i<m;++i)g[i].x=s2[m-i-1]-'0';",
            "\tfor(m+=n,n=1;n<=m;n<<=1);",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tFFT(f,n,0),FFT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]*=g[i];",
            "\tFFT(f,n,1);",
            "\tfor(Re i=0;i<=m;++i){",
            "\t\tAns[i]+=(int)(f[i].x/n+0.5);",
            "\t\tif(Ans[i]>9)Ans[i+1]+=Ans[i]/10,Ans[i]%=10,m+=(i==m);",
            "\t}",
            "\twhile(!Ans[m]&&m>=1)--m;",
            "\tfor(Re i=m;i>=0;--i)printf(\"%d\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 A×B Problem"
    },
    "分治NTT": {
        "prefix": "acm-7.4循环卷积优化",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=131072+3,P=998244353,G=3;",
            "int n,m,invn,invG,f[N],g[N],A[N],tr[N],ans[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "inline void NTT(Re *f,Re n,Re op){",
            "\tfor(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1){",
            "\t\tRe len=p>>1,w1=mi(op?invG:G,(P-1)/p);",
            "\t\tfor(Re st=0;st<n;st+=p)",
            "\t\t\tfor(Re i=st,base=1;i<=st+len-1;++i){",
            "\t\t\t\tRe tmp=(LL)base*f[i+len]%P;",
            "\t\t\t\tf[i+len]=(f[i]-tmp+P)%P;",
            "\t\t\t\tf[i]=(f[i]+tmp)%P;",
            "\t\t\t\tbase=(LL)base*w1%P;",
            "\t\t\t}",
            "\t}",
            "}",
            "inline void times(Re *f,Re n,Re *g,Re m){",
            "\tfor(n=1;n<=m;n<<=1);",
            "\tfor(Re i=m+1;i<=n;++i)f[i]=g[i]=0;",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tNTT(f,n,0),NTT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tNTT(f,n,1);",
            "\tfor(Re i=0,invn=inv(n);i<=m;++i)f[i]=(LL)f[i]*invn%P;",
            "}",
            "inline void CDQ(Re L,Re R){",
            "\tif(L==R)return;",
            "\tRe mid=L+R>>1;CDQ(L,mid);",
            "\tfor(Re i=L;i<=R;++i)g[i-L]=A[i-L];",
            "\tfor(Re i=L;i<=mid;++i)f[i-L]=ans[i];",
            "\tfor(Re i=mid+1;i<=R;++i)f[i-L]=0;",
            "\ttimes(f,mid-L,g,R-L);",
            "\tfor(Re i=mid+1;i<=R;++i)(ans[i]+=f[i-L])%=P;",
            "\tCDQ(mid+1,R);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),invG=inv(G);",
            "\tfor(Re i=1;i<n;++i)in(A[i]);",
            "\tans[0]=1,CDQ(0,n-1);",
            "\tfor(Re i=0;i<n;++i)printf(\"%d \",ans[i]);",
            "}",
            ""
        ],
        "description": "插入 分治NTT"
    },
    "多项式 乘法": {
        "prefix": "acm-7.4NTT",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=2097152+3,P=998244353,G=3;",
            "int n,m,invn,invG,f[N],g[N],tr[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "inline void NTT(Re *f,Re n,Re op){",
            "\tfor(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1){",
            "\t\tRe len=p>>1,w1=mi(op?invG:G,(P-1)/p);",
            "\t\tfor(Re st=0;st<n;st+=p)",
            "\t\t\tfor(Re i=st,base=1;i<=st+len-1;++i){",
            "\t\t\t\tRe tmp=(LL)base*f[len+i]%P;",
            "\t\t\t\tf[len+i]=(f[i]-tmp+P)%P,(f[i]+=tmp)%=P,base=(LL)base*w1%P;",
            "\t\t\t}",
            "\t}",
            "}",
            "inline void times(Re *f,Re n,Re *g,Re m){",
            "\tfor(m+=n,n=1;n<=m;n<<=1);invn=inv(n),invG=inv(G);",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tNTT(f,n,0),NTT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tNTT(f,n,1);",
            "\tfor(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m);",
            "\tfor(Re i=0;i<=n;++i)in(f[i]);",
            "\tfor(Re i=0;i<=m;++i)in(g[i]);",
            "\ttimes(f,n,g,m);",
            "\tfor(Re i=0;i<=n+m;++i)printf(\"%d \",f[i]);",
            "}",
            ""
        ],
        "description": "插入 多项式 乘法"
    },
    "多项式 位运算卷积": {
        "prefix": "acm-7.4FWT",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=131072+3,P=998244353;",
            "int n,m,inv2,A[N],B[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int inv(Re x){",
            "\tRe s=1,k=P-2;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "int id,f[N],g[N];",
            "inline void FWT(Re *f,Re n,Re op){",
            "\tfor(Re p=2;p<=n;p<<=1)",
            "\t\tfor(Re st=1,len=p>>1;st<n;st+=p)",
            "\t\t\tfor(Re j=st;j<=st+len-1;++j)",
            "\t\t\t\tif(id==1)(f[j+len]+=(op?P-f[j]:f[j]))%=P;",
            "\t\t\t\telse if(id==2)(f[j]+=(op?P-f[j+len]:f[j+len]))%=P;",
            "\t\t\t\telse{",
            "\t\t\t\t\tRe g0=f[j],g1=f[j+len];",
            "\t\t\t\t\tf[j]=(g0+g1)%P,f[j+len]=(g0-g1+P)%P;",
            "\t\t\t\t\tif(op)f[j]=(LL)f[j]*inv2%P,f[j+len]=(LL)f[j+len]*inv2%P;",
            "\t\t\t\t}",
            "}",
            "inline void sakura(Re *A,Re *B,Re n,Re id_){",
            "\tfor(Re i=1;i<=n;++i)f[i]=A[i],g[i]=B[i];id=id_;",
            "\tFWT(f,n,0),FWT(g,n,0);",
            "\tfor(Re i=1;i<=n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tFWT(f,n,1);",
            "\tfor(Re i=1;i<=n;++i)printf(\"%d \",f[i]);puts(\"\");",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),n=(1<<n),inv2=inv(2);",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\tfor(Re i=1;i<=n;++i)in(B[i]);",
            "\tsakura(A,B,n,1),sakura(A,B,n,2),sakura(A,B,n,3);",
            "}",
            ""
        ],
        "description": "插入 多项式 位运算卷积"
    },
    "多项式 快速幂": {
        "prefix": "acm-7.4nlog^2n 暴力",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int ",
            "using namespace std;",
            "const int N=262144+3,P=998244353,G=3,phi=P-1;",
            "inline void in(Re &x){",
            "\tint f=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=f?-x:x;",
            "}",
            "inline int in_(){",
            "\tint f=0;LL x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=x*10+(ch^48),x%=P,ch=getchar();",
            "\treturn x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "int invG,tr[N];",
            "inline void NTT(Re *f,Re n,Re op){",
            "\tfor(Re i=1;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1)",
            "\t\tfor(Re st=0,len=p>>1,w1=mi(op?invG:G,(P-1)/p);st<n;st+=p)",
            "\t\t\tfor(Re i=st,base=1;i<=st+len-1;++i){",
            "\t\t\t\tRe tmp=(LL)f[i+len]*base%P;",
            "\t\t\t\tf[i+len]=(f[i]-tmp+P)%P,(f[i]+=tmp)%=P,base=(LL)base*w1%P;",
            "\t\t\t}",
            "}",
            "inline void times(Re *f,Re n,Re *g,Re m){",
            "\tRe n_=n,m_=m;",
            "\tfor(m+=n,n=1;n<=m;n<<=1);invG=inv(G);",
            "\tfor(Re i=n_+1;i<n;++i)f[i]=0;",
            "\tfor(Re i=m_+1;i<n;++i)g[i]=0;",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tNTT(f,n,0),NTT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tNTT(f,n,1);Re invn=inv(n);",
            "\tfor(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;",
            "}",
            "int c[N];",
            "inline void polymi(Re *x,Re n,Re k,Re *s){",
            "\tk%=P,s[0]=1;",
            "\tfor(Re i=1;i<=n;++i)s[i]=0;",
            "\twhile(k){",
            "\t\tif(k&1){for(Re i=0;i<=n;++i)c[i]=x[i];times(s,n,c,n);}",
            "\t\tfor(Re i=0;i<=n;++i)c[i]=x[i];times(x,n,c,n),k>>=1;",
            "\t}",
            "}",
            "int n,K,f[N],g[N];",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),--n,K=in_();",
            "\tfor(Re i=0;i<=n;++i)in(f[i]);",
            "\tpolymi(f,n,K,g);",
            "\tfor(Re i=0;i<=n;++i)printf(\"%d \",g[i]);",
            "}",
            ""
        ],
        "description": "插入 多项式 快速幂"
    },
    "多项式 求逆": {
        "prefix": "acm-7.4nlog^2n 暴力分治 FFT",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=262144+3,P=998244353,G=3;",
            "int n,A[N],B[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "int invG,tr[N];",
            "inline void NTT(Re *f,Re n,Re op){",
            "\tfor(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1)",
            "\t\tfor(Re st=0,len=p>>1,w1=mi(op?invG:G,(P-1)/p);st<n;st+=p)",
            "\t\t\tfor(Re j=st,base=1;j<=st+len-1;++j){",
            "\t\t\t\tRe tmp=(LL)base*f[j+len]%P;",
            "\t\t\t\tf[j+len]=(f[j]-tmp+P)%P,(f[j]+=tmp)%=P,base=(LL)base*w1%P;",
            "\t\t\t}",
            "}",
            "inline void times(Re *f,Re n,Re *g,Re m){",
            "\tfor(n=1;n<=m;n<<=1);invG=inv(G);",
            "\tfor(Re i=m+1;i<n;++i)f[i]=g[i]=0;",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tNTT(f,n,0),NTT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tNTT(f,n,1);Re invn=inv(n);",
            "\tfor(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;",
            "}",
            "int f[N],g[N],c[N],ans[N];",
            "inline void CDQ(Re L,Re R){",
            "\tif(L==R)return;",
            "\tRe mid=L+R>>1;CDQ(L,mid);",
            "\tfor(Re i=L;i<=R;++i)g[i-L]=c[i-L];",
            "\tfor(Re i=L;i<=mid;++i)f[i-L]=ans[i];",
            "\tfor(Re i=mid+1;i<=R;++i)f[i-L]=0;",
            "\ttimes(f,mid-L,g,R-L);",
            "\tfor(Re i=mid+1;i<=R;++i)(ans[i]+=f[i-L])%=P;",
            "\tCDQ(mid+1,R);",
            "}",
            "inline void polyinv(Re *a,Re n,Re *b){",
            "\tRe tmp=inv(a[0]);c[0]=0;",
            "\tfor(Re i=1;i<=n;++i)c[i]=(LL)(P-a[i])*tmp%P;",
            "\tans[0]=tmp,CDQ(0,n);",
            "\tfor(Re i=0;i<=n;++i)b[i]=ans[i];",
            "}",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),--n;",
            "\tfor(Re i=0;i<=n;++i)in(A[i]),A[i]%=P;",
            "\tpolyinv(A,n,B);",
            "\tfor(Re i=0;i<=n;++i)printf(\"%d \",B[i]);",
            "}",
            ""
        ],
        "description": "插入 多项式 求逆"
    },
    "字符串匹配": {
        "prefix": "acm-7.4NTT",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=1048576+3,P=998244353,G=3;",
            "int n,m,ans,invG,f[N],g[N],tr[N],S1[N],S2[N],PA[N],nex[N];char A[N],B[N];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void get_next(){",
            "\tfor(Re i=2,j=0;i<=m;++i){",
            "\t\twhile(j&&B[i]!=B[j+1])j=nex[j];",
            "\t\tif(B[i]==B[j+1])++j;nex[i]=j;",
            "\t}",
            "\tfor(Re i=1;i<=m;++i)printf(\"%d \",nex[i]);",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "inline void NTT(Re *f,Re n,Re op){",
            "\tfor(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1){",
            "\t\tRe len=p>>1,w1=mi(op?invG:G,(P-1)/p);",
            "\t\tfor(Re st=0;st<n;st+=p)",
            "\t\t\tfor(Re j=st,base=1;j<=st+len-1;++j){",
            "\t\t\t\tRe tmp=(LL)base*f[j+len]%P;",
            "\t\t\t\tf[j+len]=(f[j]-tmp+P)%P,(f[j]+=tmp)%=P;",
            "\t\t\t\tbase=(LL)base*w1%P;",
            "\t\t\t}",
            "\t}",
            "}",
            "inline void sakura(Re *f,Re n,Re *g,Re m){",
            "\tfor(m=n+1,n=1;n<=m;n<<=1);Re invn=inv(n);",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tNTT(f,n,0),NTT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tNTT(f,n,1);",
            "\tfor(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tscanf(\"%s%s\",A+1,B+1),invG=inv(G);",
            "\tn=strlen(A+1),m=strlen(B+1);",
            "\tfor(Re i=1;i<=n;++i)f[i]=A[n-i+1]-'A'+1,S1[i]=S1[i-1]+f[i]*f[i];",
            "\tfor(Re i=1;i<=m;++i)g[i]=B[i]-'A'+1,S2[i]=S2[i-1]+g[i]*g[i];",
            "\tsakura(f,n,g,m);",
            "\tfor(Re i=m;i<=n;++i)PA[n-i+1]=((S1[i]-S1[i-m]+S2[m])%P-2*f[i+1]%P+P)%P;",
            "\tfor(Re i=1;i<=n-m+1;++i)if(PA[i]==0)printf(\"%d\\n\",i);",
            "\tget_next();",
            "}",
            ""
        ],
        "description": "插入 字符串匹配"
    },
    "拉格朗日插值": {
        "prefix": "acm-7.4x从0到n连续",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1048576+3,P=998244353,G=3;",
            "int jc[N],inv[N],invjc[N];",
            "inline void in(Re &x){",
            "\tint f=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int Inv(Re x){return mi(x,P-2);}",
            "int invG,tr[N];",
            "inline void NTT(Re *f,Re n,Re op){",
            "\tfor(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1){",
            "\t\tRe len=p>>1,w1=mi(op?invG:G,(P-1)/p);",
            "\t\tfor(Re st=0;st<n;st+=p)",
            "\t\t\tfor(Re i=st,base=1;i<=st+len-1;++i){",
            "\t\t\t\tRe tmp=(LL)base*f[len+i]%P;",
            "\t\t\t\tf[len+i]=(f[i]-tmp+P)%P,(f[i]+=tmp)%=P,base=(LL)base*w1%P;",
            "\t\t\t}",
            "\t}",
            "}",
            "inline void times(Re *f,Re n,Re *g,Re m){",
            "\tfor(m+=n,n=1;n<=m;n<<=1);invG=Inv(G);",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tNTT(f,n,0),NTT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tNTT(f,n,1);Re invn=Inv(n);",
            "\tfor(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;",
            "}",
            "int n,m,y[N],f[N],g[N],F[N];",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),jc[0]=jc[1]=inv[1]=invjc[0]=invjc[1]=1;",
            "\tfor(Re i=2;i<=n;++i)inv[i]=(LL)inv[P%i]*(P-P/i)%P,jc[i]=(LL)jc[i-1]*i%P,invjc[i]=(LL)invjc[i-1]*inv[i]%P;",
            "\tfor(Re i=0;i<=n;++i)in(y[i]),g[i]=(LL)y[i]*((n-i&1)?P-1:1)%P*invjc[i]%P*invjc[n-i]%P;",
            "\tfor(Re i=0;i<=(n<<1);++i)f[i]=Inv(m-n+i);",
            "\ttimes(f,n<<1,g,n);Re tmp=1;",
            "\tfor(Re i=m-n;i<=m;++i)tmp=(LL)tmp*i%P;",
            "\tfor(Re i=0;i<=n;tmp=(LL)tmp*Inv(m-n+i)%P,++i,tmp=(LL)tmp*(m+i)%P)F[i]=(LL)tmp*f[n+i]%P;",
            "\tfor(Re i=m;i<=m+n;++i)printf(\"%d \",F[i-m]);",
            "}",
            ""
        ],
        "description": "插入 拉格朗日插值"
    },
    "字符串匹配套路一：通配符 (NTT)": {
        "prefix": "acm-7.4残缺的字符串",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=524288+3,P=998244353,G=3;",
            "int n,m,ans,invG,a[N],b[N],f[N],g[N],tr[N],PA[N];char A[N],B[N];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "inline void NTT(Re *f,Re n,Re op){",
            "\tfor(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1){",
            "\t\tRe len=p>>1,w1=mi(op?invG:G,(P-1)/p);",
            "\t\tfor(Re st=0;st<n;st+=p)",
            "\t\t\tfor(Re j=st,base=1;j<=st+len-1;++j){",
            "\t\t\t\tRe tmp=(LL)base*f[j+len]%P;",
            "\t\t\t\tf[j+len]=(f[j]-tmp+P)%P,(f[j]+=tmp)%=P;",
            "\t\t\t\tbase=(LL)base*w1%P;",
            "\t\t\t}",
            "\t}",
            "}",
            "inline void sakura(Re *f,Re n,Re *g,Re m){",
            "\tfor(m=n+1,n=1;n<=m;n<<=1);Re invn=inv(n);",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tNTT(f,n,0),NTT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tNTT(f,n,1);",
            "\tfor(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(m),in(n),scanf(\"%s%s\",B+1,A+1),invG=inv(G);",
            "\tfor(Re i=1;i<=n/2;++i)swap(A[i],A[n-i+1]);",
            "\tfor(Re i=1;i<=n;++i)a[i]=(A[i]=='*'?0:A[i]-'a'+1);",
            "\tfor(Re i=1;i<=m;++i)b[i]=(B[i]=='*'?0:B[i]-'a'+1);",
            "\tfor(Re i=1;i<=n;++i)f[i]=(LL)a[i]*a[i]%P*a[i]%P;",
            "\tfor(Re i=1;i<=m;++i)g[i]=b[i];",
            "\tsakura(f,n,g,m);",
            "\tfor(Re i=m;i<=n;++i)(PA[n-i+1]+=f[i+1])%=P;",
            "\tmemset(f,0,sizeof(f)),memset(g,0,sizeof(g));",
            "\tfor(Re i=1;i<=n;++i)f[i]=a[i];",
            "\tfor(Re i=1;i<=m;++i)g[i]=(LL)b[i]*b[i]%P*b[i]%P;",
            "\tsakura(f,n,g,m);",
            "\tfor(Re i=m;i<=n;++i)(PA[n-i+1]+=f[i+1])%=P;",
            "\tmemset(f,0,sizeof(f)),memset(g,0,sizeof(g));",
            "\tfor(Re i=1;i<=n;++i)f[i]=(LL)a[i]*a[i]%P;",
            "\tfor(Re i=1;i<=m;++i)g[i]=(LL)b[i]*b[i]%P;",
            "\tsakura(f,n,g,m);",
            "\tfor(Re i=m;i<=n;++i)(PA[n-i+1]+=P-2*f[i+1]%P)%=P;",
            "\tRe ans=0;",
            "\tfor(Re i=1;i<=n-m+1;++i)ans+=(PA[i]==0);",
            "\tprintf(\"%d\\n\",ans);",
            "\tfor(Re i=1;i<=n-m+1;++i)if(PA[i]==0)printf(\"%d \",i);",
            "}",
            ""
        ],
        "description": "插入 字符串匹配套路一：通配符 (NTT)"
    },
    "字符串匹配套路二：较小字符集 (NTT)": {
        "prefix": "acm-7.4Fuzzy Search",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=262144+3,P=998244353,G=3;",
            "int n,m,K,invG,a[N],b[N],f[N],g[N],S[N],tr[N],PA[N],id[200];char A[N],B[N];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "inline void NTT(Re *f,Re n,Re op){",
            "\tfor(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1){",
            "\t\tRe len=p>>1,w1=mi(op?invG:G,(P-1)/p);",
            "\t\tfor(Re st=0;st<n;st+=p)",
            "\t\t\tfor(Re j=st,base=1;j<=st+len-1;++j){",
            "\t\t\t\tRe tmp=(LL)base*f[j+len]%P;",
            "\t\t\t\tf[j+len]=(f[j]-tmp+P)%P,(f[j]+=tmp)%=P;",
            "\t\t\t\tbase=(LL)base*w1%P;",
            "\t\t\t}",
            "\t}",
            "}",
            "inline void sakura(Re *f,Re n,Re *g,Re m){",
            "\tfor(m=n+1,n=1;n<=m;n<<=1);Re invn=inv(n);",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tNTT(f,n,0),NTT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tNTT(f,n,1);",
            "\tfor(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),in(K),scanf(\"%s%s\",A+1,B+1),invG=inv(G);",
            "\tid['A']=1,id['T']=2,id['C']=3,id['G']=4;",
            "\tfor(Re i=1;i<=n;++i)a[i]=id[A[n-i+1]];",
            "\tfor(Re i=1;i<=m;++i)b[i]=id[B[i]];",
            "\tfor(Re o=1;o<=4;++o){",
            "\t\tfor(Re i=1;i<=n;++i)S[i]=S[i-1]+(a[i]==o);",
            "\t\tfor(Re i=1;i<=n;++i)f[i]=(S[i]-S[max(i-K-1,0)]||S[min(i+K,n)]-S[i-1]);",
            "\t\tfor(Re i=1;i<=m;++i)g[i]=(b[i]==o);",
            "\t\tsakura(f,n,g,m);",
            "\t\tfor(Re i=m;i<=n;++i)(PA[n-i+1]+=f[i+1])%=P;",
            "\t\tmemset(f,0,sizeof(f)),memset(g,0,sizeof(g));",
            "\t}",
            "\tRe ans=0;",
            "\tfor(Re i=1;i<=n-m+1;++i)ans+=(PA[i]==m);",
            "\tprintf(\"%d\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 字符串匹配套路二：较小字符集 (NTT)"
    },
    "Polya定理": {
        "prefix": "acm-7.2mi",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e6+3,P=1e9+7;",
            "int n,T,pri[N/3];bool pan[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "inline int phi(Re x){",
            "\tRe ans=x;",
            "\tfor(Re i=2;i*i<=x;i++)",
            "\t\tif(x%i==0){",
            "\t\t\tans/=i,ans*=i-1;",
            "\t\t\twhile(x%i==0)x/=i;",
            "\t\t}",
            "\tif(x>1)ans/=x,ans*=x-1;",
            "\treturn ans;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(T);",
            "\twhile(T--){",
            "\t\tin(n);Re ans=0;",
            "\t\tfor(Re i=1;i*i<=n;++i)",
            "\t\t\tif(n%i==0){",
            "\t\t\t\t(ans+=(LL)mi(n,i-1)*phi(n/i)%P)%=P;",
            "\t\t\t\tif(i!=n/i)(ans+=(LL)mi(n,n/i-1)*phi(i)%P)%=P;",
            "\t\t\t}",
            "\t\tprintf(\"%d\\n\",ans);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 Polya定理"
    },
    "卡特兰数Catalan": {
        "prefix": "acm-7.2质因数分解 高精度",
        "body": [
            "#include<cstdio>",
            "#define R register int",
            "int n,t,x,len,ans[100000],pan[120005];",
            "void cf(int x){",
            "    R i,j;",
            "    for(i=1;i<=len;i++)ans[i]*=x;",
            "    len+=6;",
            "    for(i=1;i<=len;i++)ans[i+1]+=ans[i]/10,ans[i]%=10;",
            "    while(!ans[len])len--;",
            "}",
            "int main(){",
            "    scanf(\"%d\",&n);R i,j;len=ans[1]=1;",
            "    for(i=2;i<=2*n;i++)",
            "        if(pan[i]==0){",
            "            x=i;t=0;",
            "            while(x<=2*n){t+=2*n/x-n/x-(n+1)/x;x*=i;}",
            "            while(t--)cf(i);",
            "            for(j=i;j<=2*n/i;j++)pan[i*j]=1;",
            "        }",
            "    for(i=len;i>=1;i--)printf(\"%d\",ans[i]);",
            "}",
            ""
        ],
        "description": "插入 卡特兰数Catalan"
    },
    "卢卡斯定理": {
        "prefix": "acm-7.2mi",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "int n,m,P,T,jc[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "inline int C(Re m,Re n){",
            "\treturn m>n?0:(LL)jc[n]*inv(jc[m])%P*inv(jc[n-m])%P;",
            "}",
            "inline int Lucas(Re m,Re n){",
            "\treturn m==0?1:(LL)Lucas(m/P,n/P)*C(m%P,n%P)%P;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(T);",
            "\twhile(T--){",
            "\t\tin(n),in(m),in(P),jc[0]=1;",
            "\t\tfor(Re i=1;i<=P-1;++i)jc[i]=(LL)jc[i-1]*i%P;",
            "\t\tprintf(\"%d\\n\",Lucas(n,n+m));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 卢卡斯定理"
    },
    "康托展开": {
        "prefix": "acm-7.2optimize",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<cstdio>",
            "#define LL long long",
            "const int N=1e6+5,P=998244353;",
            "int n,i,ans,a[N],g[N],C[N],jc[N]={1};",
            "inline void add(int x){while(x<=n)++C[x],x+=x&-x;}",
            "inline int ask(int x){",
            "\tint ans=0;",
            "\twhile(x)ans+=C[x],x-=x&-x;",
            "\treturn ans;",
            "}",
            "int main(){",
            "\tscanf(\"%d\",&n);",
            "\tfor(i=1;i<=n;++i)scanf(\"%d\",&a[i]);",
            "\tfor(i=n;i;--i)g[i]=ask(a[i]-1),add(a[i]);",
            "\tfor(i=1;i<=n;++i)jc[i]=(LL)jc[i-1]*i%P;",
            "\tfor(i=1;i<=n;++i)(ans+=(LL)g[i]*jc[n-i]%P)%=P;",
            "\tprintf(\"%d\",ans+1);",
            "}",
            ""
        ],
        "description": "插入 康托展开"
    },
    "球盒模型全套": {
        "prefix": "acm-7.2Cat",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int P=998244353,N=1e6+5;",
            "LL T,a,b,f,opt,cnt,jc[N*2+5],dp[205][205],S[105][105];",
            "inline void in(Re &x){",
            "    x=f=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    if(f)x=-x;",
            "}",
            "inline LL mi(Re x,Re k){",
            "    Re ans=1;",
            "    while(k){",
            "        if(k&1)ans=(ans*x)%P;",
            "        x=(x*x)%P;k>>=1;",
            "    }",
            "    return ans%P;",
            "} ",
            "inline LL niv(Re x){return mi(x,P-2);}",
            "inline LL c(Re m,Re n){",
            "    if(n<m)return 0;",
            "    if(n<P)return jc[n]*niv(jc[m])%P*niv(jc[n-m])%P;",
            "    return c(m/P,n/P)*c(m%P,n%P)%P;",
            "}",
            "inline void Stirling(){",
            "    for(Re i=0;i<=100;++i)S[i][i]=1;",
            "    for(Re i=1;i<=100;++i)",
            "        for(Re j=1;j<=100;++j)",
            "            S[i][j]=(S[i-1][j-1]+S[i-1][j]*j%P)%P;",
            "}",
            "inline void DP(){",
            "    dp[0][0]=1;",
            "    for(Re i=1;i<=200;++i)",
            "        for(Re j=1;j<=i;++j)",
            "            dp[i][j]=(dp[i-j][j]+dp[i-1][j-1])%P;",
            "}",
            "inline LL Catalan(Re n){return c(n,n<<1)*niv(n+1)%P;}",
            "int main(){",
            "//  freopen(\"cat.in\",\"r\",stdin);",
            "//  freopen(\"cat.out\",\"w\",stdout);",
            "    jc[0]=1;for(Re i=1;i<=N*2;i++)jc[i]=jc[i-1]*i%P;",
            "    in(T);Stirling();DP();",
            "    while(T--){",
            "        in(opt),in(a),in(b);",
            "        if(opt==1)printf(\"%lld\\n\",mi(b,a));",
            "        else if(opt==2)printf(\"%lld\\n\",c(b-1,a-1));",
            "        else if(opt==3)printf(\"%lld\\n\",c(b-1,a+b-1));",
            "        else if(opt==4)printf(\"%lld\\n\",S[a][b]);",
            "        else if(opt==5)printf(\"%lld\\n\",jc[b]*S[a][b]%P);",
            "        else if(opt==6){",
            "            Re ans=0;",
            "            for(Re i=1;i<=b;++i)(ans+=S[a][i])%=P;",
            "            printf(\"%lld\\n\",ans);",
            "        }",
            "        else if(opt==7)printf(\"%lld\\n\",dp[a+b][b]);",
            "        else if(opt==8)printf(\"%lld\\n\",dp[a][b]);",
            "        else if(opt==9)printf(\"%lld\\n\",Catalan(a));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 球盒模型全套"
    },
    "第一类斯特林数": {
        "prefix": "acm-7.2n^2递推",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1003,P=998244353;",
            "int s[N][N]; ",
            "inline void get_stiring(Re N){",
            "\tfor(Re i=0;i<=N;++i)s[i][i]=1;",
            "\tfor(Re i=1;i<=N;++i)",
            "\t\tfor(Re j=1;j<i;++j)",
            "\t\t\ts[j][i]=s[j-1][i-1]+(LL)(i-1)*s[j][i-1]%P;",
            "}",
            "int main(){}",
            ""
        ],
        "description": "插入 第一类斯特林数"
    },
    "第一类斯特林数·行": {
        "prefix": "acm-7.2nlog^2n 暴力分治 NTT",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=262144+3,P=167772161,G=3;",
            "int n,m,invn,invG,tr[N],A[20][N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "inline void NTT(Re *f,Re n,Re op){",
            "\tfor(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1)",
            "\t\tfor(Re st=0,len=p>>1,w1=mi(op?invG:G,(P-1)/p);st<n;st+=p)",
            "\t\t\tfor(Re i=st,base=1;i<=st+len-1;++i){",
            "\t\t\t\tRe tmp=(LL)base*f[i+len]%P;",
            "\t\t\t\tf[i+len]=(f[i]-tmp+P)%P,f[i]=(f[i]+tmp)%P,base=(LL)base*w1%P;",
            "\t\t\t}",
            "}",
            "inline void times(Re *f,Re n,Re *g,Re m){",
            "\tRe n_=n,m_=m;",
            "\tfor(m+=n,n=1;n<=m;n<<=1);",
            "\tfor(Re i=n_+1;i<=n;++i)f[i]=0;",
            "\tfor(Re i=m_+1;i<=n;++i)g[i]=0;",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tNTT(f,n,0),NTT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tNTT(f,n,1);",
            "\tfor(Re i=0,invn=inv(n);i<=m;++i)f[i]=(LL)f[i]*invn%P;",
            "}",
            "inline void CDQ(Re L,Re R,Re deep){",
            "\tif(L==R){A[deep][0]=L,A[deep][1]=1;return;}",
            "\tRe mid=L+R>>1;",
            "\tCDQ(L,mid,deep+1);",
            "\tfor(Re i=0;i<=mid-L+1;++i)A[deep][i]=A[deep+1][i];",
            "\tCDQ(mid+1,R,deep+1);",
            "\ttimes(A[deep],mid-L+1,A[deep+1],R-mid);",
            "}",
            "int s[N];",
            "inline void get_Stirling(Re n){",
            "\tinvG=inv(G),CDQ(0,n-1,0);",
            "\tfor(Re i=0;i<=n;++i)s[i]=A[0][i];",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),get_Stirling(n);",
            "\tfor(Re i=0;i<=n;++i)printf(\"%d \",s[i]);",
            "}",
            ""
        ],
        "description": "插入 第一类斯特林数·行"
    },
    "第二类斯特林数": {
        "prefix": "acm-7.2n^2递推",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1003,P=998244353;",
            "int S[N][N]; ",
            "inline void get_Stiring(Re N){",
            "\tfor(Re i=0;i<=N;++i)S[i][i]=1;",
            "\tfor(Re i=1;i<=N;++i)",
            "\t\tfor(Re j=1;j<i;++j)",
            "\t\t\tS[j][i]=S[j-1][i-1]+(LL)j*S[j][i-1]%P;",
            "}",
            "int main(){}",
            ""
        ],
        "description": "插入 第二类斯特林数"
    },
    "第二类斯特林数·行": {
        "prefix": "acm-7.2NTT",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=524288+3,P=167772161,G=3;",
            "int n,invG,f[N],g[N],tr[N],jc[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "inline void NTT(Re *f,Re n,Re op){",
            "\tfor(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);",
            "\tfor(Re p=2;p<=n;p<<=1)",
            "\t\tfor(Re st=0,len=p>>1,w1=mi(op?invG:G,(P-1)/p);st<n;st+=p)",
            "\t\t\tfor(Re i=st,base=1;i<=st+len-1;++i){",
            "\t\t\t\tRe tmp=(LL)f[i+len]*base%P;",
            "\t\t\t\tf[i+len]=(f[i]-tmp+P)%P,(f[i]+=tmp)%=P,base=(LL)base*w1%P;",
            "\t\t\t}",
            "}",
            "inline void sakura(Re *f,Re n,Re *g,Re m){",
            "\tfor(m+=n,n=1;n<=m;n<<=1);",
            "\tfor(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);",
            "\tNTT(f,n,0),NTT(g,n,0);",
            "\tfor(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;",
            "\tNTT(f,n,1);",
            "\tfor(Re i=0,invn=inv(n);i<=m;++i)f[i]=(LL)f[i]*invn%P;",
            "}",
            "int S[N];",
            "inline void get_Stirling(Re n){",
            "\tjc[0]=1,invG=inv(G);",
            "\tfor(Re i=1;i<=n;++i)jc[i]=(LL)jc[i-1]*i%P;",
            "\tfor(Re i=0;i<=n;++i)f[i]=(LL)inv(jc[i])*((i&1)?P-1:1)%P,g[i]=(LL)mi(i,n)*inv(jc[i])%P;",
            "\tsakura(f,n,g,n);",
            "\tfor(Re i=0;i<=n;++i)S[i]=f[i];",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),get_Stirling(n);",
            "\tfor(Re i=0;i<=n;++i)printf(\"%d \",S[i]);",
            "}",
            ""
        ],
        "description": "插入 第二类斯特林数·行"
    },
    "组合数": {
        "prefix": "acm-7.2n^2递推",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1003,P=998244353;",
            "int C[N][N];",
            "inline void get_C(Re N){",
            "\tfor(Re i=0;i<=N;++i)C[0][i]=C[i][i]=1;",
            "\tfor(Re i=1;i<=N;++i)",
            "\t\tfor(Re j=1;j<i;++j)",
            "\t\t\tC[j][i]=(C[j-1][i-1]+C[j][i-1])%P;",
            "}",
            "int main(){}",
            ""
        ],
        "description": "插入 组合数"
    },
    "贝尔数Bell": {
        "prefix": "acm-7.2n^2递推",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1003,P=998244353;",
            "int B[N],C[N][N],S[N][N];",
            "inline void get_C(Re N){",
            "\tfor(Re i=0;i<=N;++i)C[0][i]=C[i][i]=1;",
            "\tfor(Re i=1;i<=N;++i)",
            "\t\tfor(Re j=1;j<i;++j)",
            "\t\t\tC[j][i]=(C[j-1][i-1]+C[j][i-1])%P;",
            "}",
            "inline void get_Bell(Re N){",
            "\tB[0]=1,get_C(N);",
            "\tfor(Re i=1;i<=N;++i)",
            "\t\tfor(Re j=0;j<=i-1;++j)",
            "\t\t\t(B[i]+=(LL)C[j][i-1]*B[j]%P)%=P;",
            "}",
            "inline void get_Stiring(Re N){",
            "\tfor(Re i=0;i<=N;++i)S[i][i]=1;",
            "\tfor(Re i=1;i<=N;++i)",
            "\t\tfor(Re j=1;j<i;++j)",
            "\t\t\tS[j][i]=S[j-1][i-1]+(LL)j*S[j][i-1]%P;",
            "}",
            "inline void get_Bell_(Re N){",
            "\tB[0]=1,get_Stiring(N);",
            "\tfor(Re i=1;i<=N;++i)",
            "\t\tfor(Re j=1;j<=i;++j)",
            "\t\t\t(B[i]+=S[j][i])%=P;",
            "}",
            "int main(){}",
            ""
        ],
        "description": "插入 贝尔数Bell"
    },
    "gcd": {
        "prefix": "acm-7.1辗转相模",
        "body": [
            "#include<cstdio>",
            "int n,a,b;",
            "inline int GCD(int a,int b){while(b^=a^=b^=a%=b);return a;}",
            "inline int gcd(int a,int b){return b==0?a:gcd(b,a%b);}",
            "int main(){",
            "\tscanf(\"%d\",&n);",
            "\twhile(n--)scanf(\"%d%d\",&a,&b),printf(\"%d\\n\",GCD(a,b));",
            "}"
        ],
        "description": "插入 gcd"
    },
    "Mobius函数": {
        "prefix": "acm-7.1线筛",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<cstdio>",
            "const int N=1e7+3;",
            "int i,j,n,cnt,pri[N>>1],pan[N],miu[N];",
            "inline void get_miu(){",
            "\tpan[1]=1,miu[1]=1;",
            "\tfor(i=2;i<=n;++i){",
            "\t\tif(!pan[i])pri[++cnt]=i,miu[i]=-1;",
            "\t\tfor(j=1;j<=cnt&&i*pri[j]<=n;++j){",
            "            pan[i*pri[j]]=1;",
            "            if(i%pri[j])miu[i*pri[j]]=-miu[i];",
            "            else{miu[i*pri[j]]=0;break;}",
            "        }",
            "\t}",
            "}",
            "int main(){",
            "\tn=N;",
            "\tget_miu();",
            "\tfor(i=1;i<=n;++i)printf(\"%d: %d\\n\",i,miu[i]);",
            "}",
            ""
        ],
        "description": "插入 Mobius函数"
    },
    "最值反演  (Card Collector)": {
        "prefix": "acm-7.1Min-Max容斥",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=23,M=1048576+3;",
            "int n,V,cnt[M];LD ans,p[N],Min[M];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char ch=getchar();",
            "    while(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();",
            "    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "    x=f?-x:x;",
            "}",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    while(~scanf(\"%d\",&n)){",
            "        V=(1<<n)-1,ans=0;",
            "        for(Re i=1;i<=n;++i)scanf(\"%lf\",&p[i]);",
            "        for(Re s=1;s<=V;++s){",
            "            Min[s]=0,cnt[s]=cnt[s>>1]+(s&1);",
            "            for(Re i=1;i<=n;++i)if(s&(1<<i-1))Min[s]+=p[i];",
            "            Min[s]=1.0/Min[s];",
            "        }",
            "        for(Re t=1;t<=V;++t)ans+=(cnt[t]&1)?Min[t]:-Min[t];",
            "        printf(\"%lf\\n\",ans);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 最值反演  (Card Collector)"
    },
    "杜教筛": {
        "prefix": "acm-7.1数组记忆化",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N23=1664511+3,N13=1303,N=2147483647;",
            "int x,T,cnt,pan[N23],pri[N23],phi[N23],miu[N23];",
            "int TO,vis1[N13],vis2[N13],Smiu[N23],Smiu_[N13];",
            "LL Sphi[N23],Sphi_[N13];",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "inline void get_(Re N){",
            "\tmiu[1]=phi[1]=pan[1]=1;",
            "\tfor(Re i=2;i<=N;++i){",
            "\t\tif(!pan[i])pri[++cnt]=i,miu[i]=-1,phi[i]=i-1;",
            "\t\tfor(Re j=1;j<=cnt&&pri[j]<=N/i;++j){",
            "\t\t\tpan[i*pri[j]]=1;",
            "\t\t\tif(i%pri[j])miu[i*pri[j]]=-miu[i],phi[i*pri[j]]=phi[i]*phi[pri[j]];",
            "\t\t\telse{miu[i*pri[j]]=0,phi[i*pri[j]]=phi[i]*pri[j];break;}",
            "\t\t}",
            "\t}",
            "\tfor(Re i=1;i<=N;++i)Smiu[i]=Smiu[i-1]+miu[i],Sphi[i]=Sphi[i-1]+phi[i];",
            "}",
            "inline LL get_Sphi(Re n){",
            "\tif(n<=TO)return Sphi[n];",
            "\tRe nn=N/n;",
            "\tif(vis1[nn])return Sphi_[nn];",
            "\tLL ans=(LL)n*(n+1)>>1;",
            "\tfor(Re l=2,r;l<=n;l=r+1){",
            "\t\tr=n/(n/l);",
            "\t\tans-=(LL)(r-l+1)*get_Sphi(n/l);",
            "\t}",
            "\tvis1[nn]=1;",
            "\treturn Sphi_[nn]=ans;",
            "}",
            "inline int get_Smiu(Re n){",
            "\tif(n<=TO)return Smiu[n];",
            "\tRe nn=N/n;",
            "\tif(vis2[nn])return Smiu_[nn];",
            "\tRe ans=1;",
            "\tfor(Re l=2,r;l<=n;l=r+1){",
            "\t\tr=n/(n/l);",
            "\t\tans-=(r-l+1)*get_Smiu(n/l);",
            "\t}",
            "\tvis2[nn]=1;",
            "\treturn Smiu_[nn]=ans;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(T),get_(TO=N23-3);",
            "\twhile(T--){",
            "\t\tin(x),printf(\"%lld %d\\n\",get_Sphi(x),get_Smiu(x));",
            "\t\tmemset(vis1,0,sizeof(vis1));",
            "\t\tmemset(vis2,0,sizeof(vis2));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 杜教筛"
    },
    "欧拉函数 暴力)": {
        "prefix": "acm-7.1sqrt(n",
        "body": [
            "#include<cstdio>",
            "#define Re register int",
            "int n;",
            "inline int phi(Re x){",
            "\tRe ans=x;",
            "\tfor(Re i=2;i*i<=x;i++)",
            "\t\tif(x%i==0){",
            "\t\t\tans/=i,ans*=i-1;",
            "\t\t\twhile(x%i==0)x/=i;",
            "\t\t}",
            "\tif(x>1)ans/=x,ans*=x-1;",
            "\treturn ans;",
            "}",
            "int main(){",
            "\tscanf(\"%d\",&n),printf(\"%d\\n\",phi(n));",
            "}",
            ""
        ],
        "description": "插入 欧拉函数 暴力)"
    },
    "欧拉函数": {
        "prefix": "acm-7.1线筛",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<cstdio>",
            "const int N=1e6;",
            "int cnt,i,j,pan[N+1],pri[N/3],phi[N+1];",
            "inline void get_phi(int N){",
            "    pan[1]=1,phi[1]=1;",
            "    for(int i=2;i<=N;++i){",
            "        if(!pan[i])pri[++cnt]=i,phi[i]=i-1;",
            "        for(int j=1;j<=cnt&&pri[j]<=N/i;++j){",
            "            pan[i*pri[j]]=1;",
            "            if(i%pri[j])phi[i*pri[j]]=phi[i]*(pri[j]-1);",
            "            else{phi[i*pri[j]]=phi[i]*pri[j];break;}",
            "        }",
            "    }",
            "}",
            "int main(){",
            "\tget_phi(N);",
            "\tfor(i=1;i<=N;++i)printf(\"%d: %d\\n\",i,phi[i]);",
            "}",
            ""
        ],
        "description": "插入 欧拉函数"
    },
    "Power Tower  (欧拉定理)": {
        "prefix": "acm-7.1炸勃龙弱化",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<cstdio>",
            "#include<cmath>",
            "#include<map>",
            "#define LL long long",
            "#define Re register LL",
            "using namespace std;",
            "const int N=1e5+3;",
            "LL n,l,r,T,P,fu,a[N];char ch;map<LL,LL>phi;",
            "inline void in(Re &x){",
            "    x=fu=0;ch=getchar();",
            "    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();x=fu?-x:x;",
            "}",
            "inline LL Phi(Re x){",
            "    Re ans=x,pos=x;",
            "    if(phi.count(x))return phi[x];",
            "    for(Re i=2;i<=sqrt(x);i++)",
            "        if(!(x%i)){",
            "            ans=ans/i*(i-1);",
            "            while(!(x%i)) x/=i;",
            "        }",
            "    if(x>1)ans=ans/x*(x-1);",
            "    return phi[pos]=ans;",
            "}",
            "inline LL mi(Re x,Re k,Re P){",
            "    Re s=1,ok=0,flag=0;ok|=(x>=P);x%=P;",
            "    while(k){",
            "        if(k&1){s*=x;flag|=(ok||s>=P);s%=P;}",
            "        x*=x;ok|=(x>=P);x%=P;k>>=1;",
            "    }",
            "    return s+(flag?P:0);",
            "}",
            "inline LL sakura(Re l,Re r,Re P){",
            "    if(P==1|l>r)return 1;",
            "    return mi(a[l],sakura(l+1,r,Phi(P)),P);",
            "}",
            "int main(){",
            "    in(n),in(P);",
            "    for(Re i=1;i<=n;++i)in(a[i]);",
            "    in(T);",
            "    while(T--){",
            "        in(l),in(r);",
            "    \tprintf(\"%lld\\n\",sakura(l,r,P)%P);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 Power Tower  (欧拉定理)"
    },
    "BSGS拔山盖世": {
        "prefix": "acm-7.1可爱的质数",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#include<map>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "int x,y,m,P;map<int,int>B;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "//x^k = y (mod P)",
            "//k = am-b (m=sqrt(P)+1, a\\in[1,m], b\\in[0,m-1])",
            "//(x^m)^a = y x^b (mod P)",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(P),in(x),in(y),m=sqrt(P)+1;",
            "\tfor(Re b=0,s=y;b<m;++b)B[s]=b,s=(LL)s*x%P;",
            "\tRe tmp=mi(x,m);",
            "\tfor(Re a=1,s=1;a<=m;++a){",
            "\t\ts=(LL)s*tmp%P;",
            "\t\tif(B.find(s)!=B.end()){printf(\"%d\\n\",a*m-B[s]);return 0;}",
            "\t}",
            "\tputs(\"no solution\");",
            "}",
            ""
        ],
        "description": "插入 BSGS拔山盖世"
    },
    "CRT中国剩余定理 (P两两互质)": {
        "prefix": "acm-7.1同余方程组",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=13;",
            "LL n,ans,lcm=1,a[N],m[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void exgcd(Re a,Re b,Re &x,Re &y){",
            "\tif(!b){x=1,y=0;return;}",
            "\texgcd(b,a%b,x,y);Re x0=x,y0=y;",
            "\tx=y0,y=x0-a/b*y0;return;",
            "}",
            "inline LL cf(Re x,Re k,Re P){",
            "\tRe s=0;",
            "\twhile(k){",
            "\t\tif(k&1)(s+=x)%=P;",
            "\t\t(x+=x)%=P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    in(n);",
            "    for(Re i=1;i<=n;++i)in(m[i]),in(a[i]),lcm*=m[i];",
            "    for(Re i=1;i<=n;++i){",
            "\t\tRe x,y,M=lcm/m[i];exgcd(M,m[i],x,y);//M[i]*inv+m[i]*y=1",
            "\t\tx=(x%m[i]+m[i])%m[i],(ans+=cf(cf(a[i],M,lcm),x,lcm))%=lcm;",
            "\t}",
            "\tprintf(\"%lld\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 CRT中国剩余定理 (P两两互质)"
    },
    "EXBSGS扩展拔山盖世": {
        "prefix": "acm-7.1mi",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#include<map>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "int x,y,z;map<int,int>B;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k,Re P){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int gcd(Re a,Re b){return !b?a:gcd(b,a%b);}",
            "inline void exBSGS(Re x,Re y,Re P){",
            "\tif(y==1){puts(\"0\");return;}",
            "\tRe d=gcd(x,P),tmp=1,t=0;",
            "\twhile(d!=1){",
            "\t\tif(y%d){puts(\"No Solution\");return;}",
            "\t\t++t,y/=d,P/=d,tmp=(LL)tmp*(x/d)%P;",
            "\t\tif(y==tmp){printf(\"%d\\n\",t);return;}",
            "\t\td=gcd(x,P);",
            "\t}",
            "\tRe m=sqrt(P)+1;B.clear();",
            "\tfor(Re b=0,s=y;b<m;++b)B[s]=b,s=(LL)s*x%P;",
            "\tRe s=tmp;tmp=mi(x,m,P);",
            "\tfor(Re a=1;a<=m;++a){",
            "\t\ts=(LL)s*tmp%P;",
            "\t\tif(B.find(s)!=B.end()){printf(\"%d\\n\",a*m-B[s]+t);return;}",
            "\t}",
            "\tputs(\"No Solution\");",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\twhile(1){",
            "\t\tin(x),in(y),in(z);",
            "\t\tif(!x&&!y&&!z)break;",
            "\t\texBSGS(x,z,y);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 EXBSGS扩展拔山盖世"
    },
    "EXCRT扩展中国剩余定理": {
        "prefix": "acm-7.1P不一定两两互质",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "const int N=1e5+3;",
            "LL n,ans,lcm=1,a[N],m[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline LL exgcd(Re a,Re b,Re &x,Re &y){",
            "\tif(!b){x=1,y=0;return a;}",
            "\tRe gcd=exgcd(b,a%b,x,y);Re x0=x,y0=y;",
            "\tx=y0,y=x0-a/b*y0;return gcd;",
            "}",
            "inline LL cf(Re x,Re k,Re P){",
            "\tRe s=0;",
            "\twhile(k){",
            "\t\tif(k&1)(s+=x)%=P;",
            "\t\t(x+=x)%=P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    in(n);",
            "    for(Re i=1;i<=n;++i)in(m[i]),in(a[i]),lcm*=m[i];",
            "    ans=a[1]%m[1],lcm=m[1];",
            "    for(Re i=2;i<=n;++i){//ans+lcm*k=a[i](mod m[i]) -> lcm*k=a[i]-ans(mod m[i]) -> lcm*k+m[i]*y=a[i]-ans",
            "\t\tRe c=((a[i]-ans)%m[i]+m[i])%m[i],x,y;",
            "\t\tRe gcd=exgcd(lcm,m[i],x,y);",
            "\t\tRe k=cf(x,c/gcd,m[i]/gcd);",
            "\t\tans+=lcm*k,lcm*=m[i]/gcd,ans=(ans%lcm+lcm)%lcm;",
            "\t}",
            "\tprintf(\"%lld\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 EXCRT扩展中国剩余定理"
    },
    "EXGCD": {
        "prefix": "acm-7.1线性同余方程",
        "body": [
            "#include<cstdio>",
            "#define Re register int",
            "int a,b,x,y;",
            "inline void exgcd(Re a,Re b,Re &x,Re &y){",
            "\tif(!b){x=1,y=0;return;}",
            "\texgcd(b,a%b,x,y);Re x0=x,y0=y;",
            "\tx=y0,y=x0-a/b*y0;return;",
            "}",
            "int main(){",
            "    scanf(\"%d%d\",&a,&b),exgcd(a,b,x,y);",
            "\tprintf(\"%d\\n\",(x%b+b)%b);",
            "}",
            ""
        ],
        "description": "插入 EXGCD"
    },
    "二次剩余": {
        "prefix": "acm-7.1mi",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "int n,T,P,W,det;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "struct CP{",
            "\tint x,y;CP(Re X=0,Re Y=0){x=X,y=Y;}",
            "\tinline CP operator*(const CP &O)const{return CP(((LL)x*O.x%P+(LL)y*O.y%P*W%P)%P,((LL)x*O.y%P+(LL)y*O.x%P)%P);}",
            "\tinline CP operator*=(const CP &O){return *this=*this*O;}",
            "};",
            "inline CP mi_(CP x,Re k){",
            "\tCP s=CP(1,0);",
            "\twhile(k){",
            "\t\tif(k&1)s*=x;",
            "\t\tx*=x,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline LL Sqrt(Re n){",
            "    if(!n)return 0;Re x;",
            "    while(1){",
            "        x=rand()%P,W=((LL)x*x%P-n+P)%P;",
            "        if(mi(W,(P-1)/2)==P-1)break;",
            "    }",
            "    return mi_(CP(x,1),(P+1)/2).x;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(T);",
            "\twhile(T--){",
            "\t\tin(n),in(P);",
            "\t\tif(mi(n,(P-1)/2)==P-1)puts(\"Hola!\");//�޽�",
            "\t    else{",
            "\t\t    det=Sqrt(n);",
            "\t\t    if(det)printf(\"%d %d\\n\",min(det,P-det),max(det,P-det));",
            "\t\t    else printf(\"%d\\n\",det);",
            "\t\t}",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 二次剩余"
    },
    "扩展欧拉定理": {
        "prefix": "acm-7.1a^b%m",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<cstdio>",
            "#include<cctype>",
            "#define LL long long",
            "#define Re register LL",
            "LL i,a,b,m,x,s,phi,flag;char c;",
            "inline LL cf(Re x,Re k){",
            "\tRe s=0;",
            "\twhile(k){",
            "\t\tif(k&1)(s+=x)%=m;",
            "\t\t(x<<=1)%=m,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "int main(){",
            "    scanf(\"%lld%lld\",&a,&m);phi=x=m;",
            "    for(i=2;i*i<=m;++i)if(!(x%i)){phi-=phi/i;while(!(x%i))x/=i;}",
            "    if(x>1)phi-=phi/x;",
            "    while(!isdigit(c=getchar()));",
            "    while(isdigit(c))flag|=((b=(b<<1)+(b<<3)+(c^48))>=phi),b%=phi,c=getchar();",
            "    b+=flag?phi:0;x=1;",
            "    while(b){if(b&1)x=cf(x,a)%m;a=cf(a,a)%m,b>>=1;}",
            "    printf(\"%lld\",x);",
            "}",
            ""
        ],
        "description": "插入 扩展欧拉定理"
    },
    "有理数取模": {
        "prefix": "acm-7.1mi",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "using namespace std;",
            "const LL N=1e4+3,P=19260817;",
            "LL a,b;",
            "inline void in(Re &x){",
            "    Re f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),x%=P,c=getchar();",
            "}",
            "inline LL mi(Re x,Re k){",
            "    Re s=1;",
            "    while(k){",
            "        if(k&1)(s*=x)%=P;",
            "        (x*=x)%=P,k>>=1;",
            "    }",
            "    return s;",
            "}",
            "int main(){",
            "    // freopen(\"123.txt\",\"r\",stdin);",
            "    in(a),in(b);",
            "    if(b)printf(\"%lld\\n\",a%P*mi(b,P-2)%P);",
            "    else puts(\"Angry!\");",
            "}"
        ],
        "description": "插入 有理数取模"
    },
    "逆元": {
        "prefix": "acm-7.1递推",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "const int N=3e6+3;",
            "int n,P,inv[N];",
            "int main(){",
            "    scanf(\"%d%d\",&n,&P);",
            "    inv[1]=1;",
            "    for(Re i=2;i<=n;++i)inv[i]=(LL)(P-P/i)*inv[P%i]%P;",
            "    for(Re i=1;i<=n;++i)printf(\"%d\\n\",inv[i]);",
            "}",
            ""
        ],
        "description": "插入 逆元"
    },
    "炸勃龙": {
        "prefix": "acm-2.5树状数组+扩展欧拉定理",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "#define F(a,b) for(i=a;i<=b;++i)",
            "const int N=5e5+3,Np=2e7;",
            "LL i,j,n,x,l,r,K,T,fu,cnt,c[N],C[N],pan[Np+1],pri[Np+1],phi[Np+1];char ch;",
            "inline void in(Re &x){",
            "    x=fu=0;ch=getchar();",
            "    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();x=fu?-x:x;",
            "}",
            "inline void add(Re x,Re k){while(x<=n)C[x]+=k,x+=x&-x;}",
            "inline LL ask(Re x){Re tmp=0;while(x)tmp+=C[x],x-=x&-x;return tmp;}",
            "inline LL mi(Re x,Re k,Re P){",
            "    Re s=1,ok=0,flag=0;ok|=(x>=P);x%=P;",
            "    while(k){",
            "        if(k&1){s*=x;flag|=(ok||s>=P);s%=P;}",
            "        x*=x;ok|=(x>=P);x%=P;k>>=1;",
            "    }",
            "    return s+(flag?P:0);",
            "}",
            "",
            "inline LL sakura(Re l,Re r,Re P){",
            "    if(P==1|l>r)return 1;",
            "    return mi(ask(l),sakura(l+1,r,phi[P]),P);",
            "}",
            "int main(){",
            "    for(i=2;i<=Np;++i){",
            "        if(!pan[i])pri[++cnt]=i,phi[i]=i-1;",
            "        for(j=1;j<=cnt;++j){",
            "      \t\tif(i*pri[j]>Np)break;",
            "      \t\tpan[i*pri[j]]=1;",
            "      \t\tif(i%pri[j])phi[i*pri[j]]=phi[i]*(pri[j]-1);",
            "      \t\telse{phi[i*pri[j]]=phi[i]*pri[j];break;}",
            "   \t\t}",
            "    }",
            "    in(n),in(T);",
            "    F(1,n)in(x),add(i,x-l),l=x;",
            "    while(T--){",
            "        in(K),in(l),in(r),in(x);",
            "        if(K<2)add(l,x),add(r+1,-x);",
            "        else printf(\"%lld\\n\",sakura(l,r,x)%x);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 炸勃龙"
    },
    "判素数": {
        "prefix": "acm-7.1暴力",
        "body": [
            "#include<cstdio>",
            "#include<cmath>",
            "int x;",
            "inline bool judge(int n){",
            "\tif(n<4)return 1;",
            "\tif(n%2==0)return 0;",
            "\tint half=sqrt(n);",
            "\tfor(int i=3;i<=half;i+=2)",
            "\t\tif(n%i==0)return 0;",
            "\treturn 1;",
            "}",
            "int main(){",
            "\tscanf(\"%d\",&x);",
            "\tputs(judge(x)?\"YES\":\"NO\");",
            "}",
            ""
        ],
        "description": "插入 判素数"
    },
    "筛素数": {
        "prefix": "acm-7.1埃氏筛",
        "body": [
            "#include<cstdio>",
            "#define R register int",
            "int pri[10005],pan[10005],gs;",
            "inline void creat_prime(){",
            "\tfor(R i=2;i<=10000;i++)",
            "\t\tif(pan[i]==0){",
            "\t\t\tpri[++gs]=i;",
            "\t\t\tfor(R j=2;i*j<=10000;j++)pan[i*j]=1;",
            "\t\t}",
            "}",
            "inline int sakura(){",
            "\tcreat_prime();",
            "\tfor(R i=1;i<=gs;i++)printf(\"%d\\n\",pri[i]);",
            "}",
            "int QAQWQ=sakura();",
            "int main(){}",
            ""
        ],
        "description": "插入 筛素数"
    },
    "筛质数": {
        "prefix": "acm-7.1线筛",
        "body": [
            "#include<cstdio>",
            "#include<ctime>",
            "const int N=1e6;",
            "int cnt,i,j,pri[N/3];bool pan[N+1];",
            "inline void get_pri(){",
            "\tpan[0]=pan[1]=1;",
            "\tfor(i=2;i<=N;++i){",
            "\t\tif(!pan[i])pri[++cnt]=i;",
            "\t\tfor(j=1;j<=cnt&&i*pri[j]<=N;++j){",
            "\t\t\tpan[i*pri[j]]=1;",
            "\t\t\tif(i%pri[j]==0)break;",
            "\t\t}",
            "\t}",
            "}",
            "int main(){",
            "\tget_pri();",
            "\tfor(j=0,i=1;i<=cnt;++i)printf(\"%d \",pri[i]);",
            "}"
        ],
        "description": "插入 筛质数"
    },
    "前缀线性基": {
        "prefix": "acm-7.5Ivan and Burgers",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e5+3,logN=20,inf=2e9;",
            "int n,x,y,T;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct JI{",
            "\tint p[logN+1],ip[logN+1];JI(){memset(p,0,sizeof(p));}",
            "\tinline void insert(Re x,Re id){",
            "\t\tfor(Re i=logN;i>=0;--i)",
            "\t\t\tif((x>>i)&1){",
            "\t\t\t\tif(!p[i]){p[i]=x,ip[i]=id;break;}",
            "\t\t\t\tif(ip[i]<id)swap(p[i],x),swap(ip[i],id);",
            "\t\t\t\tx^=p[i];",
            "\t\t\t}",
            "\t}",
            "\tinline int ask(Re L){",
            "\t\tRe ans=0;",
            "\t\tfor(Re i=logN;i>=0;--i)if(ip[i]>=L)ans=max(ans,ans^p[i]);",
            "\t\treturn ans;",
            "\t}",
            "}A[N],S[N];",
            "int main(){",
            "//    freopen(\"456.txt\",\"r\",stdin);",
            "    in(n);",
            "    for(Re i=1;i<=n;++i)in(x),S[i]=S[i-1],S[i].insert(x,i);",
            "    in(T);",
            "    while(T--)in(x),in(y),printf(\"%d\\n\",S[y].ask(x));",
            "}",
            ""
        ],
        "description": "插入 前缀线性基"
    },
    "线性基": {
        "prefix": "acm-7.5insert",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register LL",
            "using namespace std;",
            "const int N=55;",
            "LL n,x,ans,p[N];",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "inline void insert(Re x){",
            "\tfor(Re i=50;i>=0;--i)",
            "\t\tif((x>>i)&1){",
            "\t\t\tif(!p[i]){p[i]=x;break;}",
            "\t\t\tx^=p[i];",
            "\t\t}",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n);",
            "\tfor(Re i=1;i<=n;++i)in(x),insert(x);",
            "\tfor(Re i=50;i>=0;--i)ans=max(ans,ans^p[i]);",
            "\tprintf(\"%lld\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 线性基"
    },
    "线性基合并": {
        "prefix": "acm-7.5幸运数字",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register LL",
            "using namespace std;",
            "const LL N=2e4+3,M=2e5+3,inf=2e18,logN=14;",
            "LL n,m,o,x,y,T,A[N],head[N];",
            "struct QAQ{LL to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct JI{",
            "    LL p[61];JI(){memset(p,0,sizeof(p));}",
            "    inline void insert(Re x){",
            "        for(Re i=60;i>=0;--i)",
            "            if((x>>i)&1){",
            "                if(!p[i]){p[i]=x;break;}",
            "                x^=p[i];",
            "            }",
            "    }",
            "    inline void merge(JI O){",
            "        for(Re i=60;i>=0;--i)if(O.p[i])insert(O.p[i]);",
            "    }",
            "    inline LL ask(){",
            "        Re ans=0;",
            "        for(Re i=60;i>=0;--i)ans=max(ans,ans^p[i]);",
            "        return ans;",
            "    }",
            "};",
            "struct LCA{",
            "    LL deep[N],fa[N][15],ant[N][15];JI dp[N][15];",
            "    inline void dfs(Re x,Re fa){",
            "        deep[x]=deep[ant[x][0]=fa]+1,dp[x][0].insert(A[fa]);",
            "        for(Re j=1;(1<<j)<=deep[x];++j)ant[x][j]=ant[ant[x][j-1]][j-1],dp[x][j]=dp[x][j-1],dp[x][j].merge(dp[ant[x][j-1]][j-1]);",
            "        for(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);",
            "    }",
            "    inline JI ask(Re x,Re y){",
            "        JI Ans;Ans.insert(A[x]),Ans.insert(A[y]);",
            "        if(deep[x]<deep[y])swap(x,y);",
            "        for(Re i=logN;i>=0;--i)if(deep[ant[x][i]]>=deep[y])Ans.merge(dp[x][i]),x=ant[x][i];",
            "        if(x==y)return Ans;",
            "        for(Re i=logN;i>=0;--i)if(ant[x][i]!=ant[y][i])Ans.merge(dp[x][i]),Ans.merge(dp[y][i]),x=ant[x][i],y=ant[y][i];",
            "        Ans.merge(dp[x][0]);",
            "        return Ans;",
            "    }",
            "}T1;",
            "int main(){",
            "//    freopen(\"lucky.in\",\"r\",stdin);",
            "//    freopen(\"lucky.out\",\"w\",stdout);",
            "    in(n),in(T),m=n-1;",
            "    for(Re i=1;i<=n;++i)in(A[i]);",
            "    while(m--)in(x),in(y),add(x,y),add(y,x);",
            "    T1.dfs(1,0);",
            "    while(T--)in(x),in(y),printf(\"%lld\\n\",T1.ask(x,y).ask());",
            "}",
            ""
        ],
        "description": "插入 线性基合并"
    },
    "三点坐标解圆方程  (Circle Through Three Points)": {
        "prefix": "acm-8.3解方程",
        "body": [
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "#define S(a) ((a)*(a))",
            "using namespace std;",
            "struct Point{LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}};",
            "struct Circle{Point O;LD r;Circle(Point P,LD R=0){O=P,r=R;}};",
            "inline Circle getcircle(Point A,Point B,Point C){",
            "\tLD x1=A.x,y1=A.y,x2=B.x,y2=B.y,x3=C.x,y3=C.y;",
            "\tLD D=((S(x2)+S(y2)-S(x3)-S(y3))*(y1-y2)-(S(x1)+S(y1)-S(x2)-S(y2))*(y2-y3))/((x1-x2)*(y2-y3)-(x2-x3)*(y1-y2));",
            "\tLD E=(S(x1)+S(y1)-S(x2)-S(y2)+D*(x1-x2))/(y2-y1);",
            "\tLD F=-(S(x1)+S(y1)+D*x1+E*y1);",
            "//\tprintf(\"(%.3lf,%.3lf), D=%.3lf E=%.3lf F=%.3lf\\n\",D/2.0,E/2.0,D,E,F);",
            "\treturn Circle(Point(-D/2.0,-E/2.0),sqrt((S(D)+S(E)-4.0*F)/4.0));",
            "}",
            "#define abs(x) (x<0?-x:x)",
            "#define sakura(x) (x<0?'-':'+')",
            "inline void print(Point O,LD r){",
            "\tLD a=-O.x,b=-O.y,c=r,d=-2.0*O.x,e=-2.0*O.y,f=S(O.x)+S(O.y)-S(r);",
            "\tif(a!=0)printf(\"(x %c %.3lf)^2 \",sakura(a),abs(a));",
            "    else printf(\"x^2 \");",
            "    if(b!=0)printf(\"+ (y %c %.3lf)^2 \",sakura(b),abs(b));",
            "    else printf(\"+ y^2 \");",
            "    printf(\"= %.3lf^2\\n\",c);",
            "    printf(\"x^2 + y^2\");",
            "    if(d!=0)printf(\" %c %.3lf%c\",sakura(d),abs(d),'x');",
            "    if(e!=0)printf(\" %c %.3lf%c\",sakura(e),abs(e),'y');",
            "    if(f!=0)printf(\" %c %.3lf%c\",sakura(f),abs(f),' ');",
            "    printf(\"= 0\\n\\n\");",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tLD a,b,c,d,e,f;",
            "\twhile(scanf(\"%lf%lf%lf%lf%lf%lf\",&a,&b,&c,&d,&e,&f)!=EOF){",
            "\t\tCircle C=getcircle(Point(a,b),Point(c,d),Point(e,f));print(C.O,C.r);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 三点坐标解圆方程  (Circle Through Three Points)"
    },
    "三角剖分": {
        "prefix": "acm-8.3Hdu4404 多边形与圆的交",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Vector Point",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "const LD eps=1e-8,Pi=acos(-1.0);",
            "inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}",
            "inline LD Abs(LD a){return a*dcmp(a);}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline LD LDin(){",
            "    LD X=0,Y=1.0;int f=0;char c=getchar();",
            "    while(c<'0'||c>'9'){f|=c=='-';c=getchar();} ",
            "    while(c>='0'&&c<='9')X=X*10+(c^48),c=getchar(); ",
            "    if(c=='.'){c=getchar();while(c>='0'&&c<='9')X+=(Y/=10)*(c^48),c=getchar();}",
            "    return f?-X:X;",
            "}",
            "struct Point{",
            "    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}",
            "    inline void in(){x=LDin(),y=LDin();}",
            "    inline bool operator<(const Point &O)const{return x!=O.x?x<O.x:y<O.y;}",
            "};",
            "inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}",
            "inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}",
            "inline LD Len(Vector a){return sqrt(Dot(a,a));}",
            "inline LD Angle(Vector a,Vector b){return acos(Dot(a,b)/Len(a)/Len(b));}",
            "inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}",
            "inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}",
            "inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}",
            "inline bool operator==(Vector a,Vector b){return !dcmp(a.x-b.x)&&!dcmp(a.y-b.y);}",
            "inline Point turn_P(Point a,LD theta){",
            "    LD x=a.x*cos(theta)+a.y*sin(theta);",
            "    LD y=-a.x*sin(theta)+a.y*cos(theta);",
            "    return Point(x,y);",
            "}",
            "inline Point cross_LL(Point a,Point b,Point c,Point d){",
            "    Vector x=b-a,y=d-c,z=a-c;",
            "    return a+x*(Cro(y,z)/Cro(x,y));",
            "}",
            "inline LD dis_PL(Point p,Point a,Point b){",
            "    if(a==b)return Len(p-a);",
            "    Vector x=p-a,y=p-b,z=b-a;",
            "    if(dcmp(Dot(x,z))<0)return Len(x);",
            "    if(dcmp(Dot(y,z))>0)return Len(y);",
            "    return Abs(Cro(x,z)/Len(z));",
            "}",
            "inline Point FootPoint(Point p,Point a,Point b){",
            "    Vector x=p-a,y=p-b,z=b-a;",
            "    LD len1=Dot(x,z)/Len(z),len2=-1.0*Dot(y,z)/Len(z);",
            "    return a+z*(len1/(len1+len2));",
            "}",
            "inline LD calc(Point A,Point B,Point O,LD R){",
            "    if((A==O)||(B==O))return 0;",
            "    Re op=(dcmp(Cro(A-O,B-O))>0)?1:-1;LD ans=0;",
            "    Vector x=A-O,y=B-O;",
            "    Re flag1=(int)(dcmp(Len(x)-R)>0),flag2=(int)(dcmp(Len(y)-R)>0);",
            "    if(!flag1&&!flag2)ans=Abs(Cro(A-O,B-O))/2.0;",
            "    else if(flag1&&flag2){",
            "        if(dcmp(dis_PL(O,A,B)-R)>=0)ans=R*R*Angle(x,y)/2.0;",
            "        else{",
            "            if(dcmp(Cro(A-O,B-O))>0)swap(A,B);",
            "            Point F=FootPoint(O,A,B);LD lenx=Len(F-O),len=sqrt(R*R-lenx*lenx);",
            "            Vector z=turn_P(F-O,Pi/2.0)*(len/lenx);Point B_=F+z,A_=F-z;",
            "            ans=R*R*(Angle(A-O,A_-O)+Angle(B-O,B_-O))/2.0+Cro(B_-O,A_-O)/2.0;",
            "        }",
            "    }",
            "    else{",
            "        if(flag1)swap(A,B);",
            "        Point F=FootPoint(O,A,B);LD lenx=Len(F-O),len=sqrt(R*R-lenx*lenx);",
            "        Vector z=turn_P(F-O,Pi/2.0)*(len/lenx);Point C=(dcmp(Cro(A-O,B-O))>0)?(F-z):(F+z);",
            "        ans=Abs(Cro(A-O,C-O))/2.0+R*R*Angle(C-O,B-O)/2.0;",
            "    }",
            "    return ans*op;",
            "}",
            "Point V,P[N];LD h,t,g,v0,ans,theta;int n;Point O;LD R;",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    while(~scanf(\"%lf\",&O.x)){",
            "        O.y=LDin(),v0=LDin(),theta=LDin(),t=LDin(),g=LDin(),R=LDin();",
            "        if(!dcmp(O.x)&&!dcmp(O.y)&&!dcmp(v0)&&!dcmp(theta)&&!dcmp(t)&&!dcmp(g)&&!dcmp(R))break;",
            "        theta=theta/180.0*Pi,O.x+=t*v0*cos(theta),O.y+=t*v0*sin(theta)-0.5*g*t*t,ans=0;",
            "//        printf(\"O=(%.2lf,%.2lf), R=%d\\n\",O.x,O.y,R);",
            "        in(n);for(Re i=1;i<=n;++i)P[i].in();",
            "        for(Re i=1;i<=n;++i)ans+=calc(P[i],P[i<n?i+1:1],O,R);",
            "        if(!dcmp(ans))puts(\"0.00\");",
            "        else printf(\"%.2lf\\n\",Abs(ans));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 三角剖分"
    },
    "三角形面积并": {
        "prefix": "acm-8.3optimize",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#include<map>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "#define Rd register LD",
            "#define Vector Point",
            "using namespace std;",
            "const int N=2003;",
            "const LD eps=1e-9;",
            "int n,m;map<LD,LD>vis;",
            "inline int dcmp(Rd a){return a<-eps?-1:(a>eps?1:0);}",
            "struct Point{",
            "    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}",
            "    inline void in(){scanf(\"%lf%lf\",&x,&y);}",
            "};",
            "struct Segment{",
            "    LD L,R;Segment(LD l=0,LD r=0){L=l,R=r;}",
            "    inline bool operator<(Segment O)const{return L!=O.L?L<O.L:R<O.R;}",
            "}Seg[N];",
            "struct Triangle{",
            "\tLD x,y,m,L,R,D,U;",
            "\tinline void in(){scanf(\"%lf%lf%lf\",&x,&y,&m),L=x,R=x+m,D=y,U=y+m;}",
            "}C[N],C_[N];",
            "inline bool cmp(Triangle A,Triangle B){return A.m<B.m;}",
            "inline LD F(Rd Y){",
            "    if(vis[Y])return vis[Y];",
            "    Re t=0;Rd ans=0;",
            "    for(Re i=1;i<=n;++i)",
            "        if(dcmp(Y-C[i].D)>=0&&dcmp(Y-C[i].U)<0){",
            "\t\t\tRd tmp=C[i].U-Y;",
            "\t\t\tif(dcmp(tmp)>0)Seg[++t]=Segment(C[i].x,C[i].x+tmp);",
            "\t\t}",
            "    if(!t)return 0.0;",
            "    sort(Seg+1,Seg+t+1);",
            "    for(Re i=1,j;i<=t;i=j+1){",
            "        Rd L=Seg[i].L,R=Seg[i].R;j=i;",
            "        while(j<t&&Seg[j+1].L<=R)++j,R=max(R,Seg[j].R);",
            "        ans+=R-L;",
            "    }",
            "    return vis[Y]=ans;",
            "}",
            "inline LD Simpson(Rd L,Rd R){return (R-L)*(F(L)+4.0*F((L+R)*0.5)+F(R))/6.0;}",
            "inline LD sakura(Rd L,Rd R,Rd now){",
            "    Rd mid=(L+R)*0.5,FL=Simpson(L,mid),FR=Simpson(mid,R);",
            "    if(!dcmp(now-FL-FR))return now;",
            "    return sakura(L,mid,FL)+sakura(mid,R,FR);",
            "}",
            "inline int TIT(Triangle A,Triangle B){",
            "\treturn A.L>=B.L&&A.R<=B.R&&A.D>=B.D&&A.U<=B.U&&dcmp(A.R-(B.x+B.U-A.y))<=0;",
            "}",
            "LD ans,YY[N<<1];",
            "int main(){",
            "//\tfreopen(\"456.txt\",\"r\",stdin);",
            "    scanf(\"%d\",&m);Re t=0;",
            "    for(Re i=1;i<=m;++i)C_[i].in();",
            "    sort(C_+1,C_+m+1,cmp),C[++n]=C_[m];",
            "    for(Re i=m-1;i>=1;--i){",
            "        Re flag=1;",
            "        for(Re j=1;j<=n&&flag;++j)if(TIT(C_[i],C[j]))flag=0;",
            "        if(flag)C[++n]=C_[i];",
            "    }",
            "    for(Re i=1;i<=n;++i)YY[++t]=C[i].D,YY[++t]=C[i].U;",
            "\tsort(YY+1,YY+t+1);",
            "    for(Re i=2;i<=t;++i)",
            "\t\tif(dcmp(YY[i]-YY[i-1])>0){",
            "\t\t\tRd D=YY[i-1],U=YY[i]-2*eps;",
            "\t        ans+=sakura(D,U,Simpson(D,U));",
            "    \t}",
            "    printf(\"%.1lf\",ans);",
            "}",
            ""
        ],
        "description": "插入 三角形面积并"
    },
    "二维凸包": {
        "prefix": "acm-8.3周长",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define Vector Point",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e4+3;",
            "const LD eps=1e-8;",
            "inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}",
            "struct Point{LD x,y;Point(LD X=0,LD Y=0):x(X),y(Y){}}Poi[N],cp[N];",
            "inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}",
            "inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}",
            "inline LD Len(Vector a){return sqrt(Dot(a,a));}",
            "inline LD Angle(Vector a,Vector b){return acos(Dot(a,b)/Len(a)/Len(b));}",
            "inline Vector Normal(Vector a){LD L=Len(a);return Vector(-a.y/L,a.x/L);}",
            "inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}",
            "inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}",
            "inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}",
            "inline Vector operator/(Vector a,LD b){return Vector(a.x/b,a.y/b);}",
            "inline bool cmp1(Vector a,Vector b){return a.x==b.x?a.y<b.y:a.x<b.x;};",
            "inline bool cmp2(Vector a,Vector b){",
            "\tLD pan=Cro(a-Poi[0],b-Poi[0]);",
            "\treturn pan>0||(pan==0&&Len(a-Poi[0])<Len(b-Poi[0]));",
            "};",
            "inline int ConvexHull(Point *P,Re n,Point *cp){",
            "\tsort(P+1,P+n+1,cmp1);",
            "\tRe t=0;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\twhile(t>1&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;",
            "\t\tcp[++t]=P[i];",
            "\t}",
            "\tRe St=t;",
            "\tfor(Re i=n-1;i>=1;--i){",
            "\t\twhile(t>St&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;",
            "\t\tcp[++t]=P[i];",
            "\t}",
            "\treturn --t;",
            "}",
            "int n;LD ans;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tscanf(\"%d\",&n);",
            "\tfor(Re i=1;i<=n;++i)scanf(\"%lf%lf\",&Poi[i].x,&Poi[i].y);",
            "\tRe cnt=ConvexHull(Poi,n,cp);",
            "\tfor(Re i=1;i<=cnt;++i)ans+=Len(cp[i<cnt?i+1:1]-cp[i]);",
            "\tprintf(\"%.2lf\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 二维凸包"
    },
    "动态凸包": {
        "prefix": "acm-8.3Professor's task",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<set>",
            "#define LL long long",
            "#define Vector Point",
            "#define Re register int",
            "#define IT set<Point>::iterator",
            "using namespace std;",
            "const int inf=2e9;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Point{",
            "    LL x,y;Point(LL X=0,LL Y=0){x=X,y=Y;}",
            "    inline void In(){Re X,Y;in(X),in(Y),x=X,y=Y;}",
            "    inline bool operator<(const Point &O)const{return x!=O.x?x<O.x:y<O.y;}",
            "}P;",
            "inline LL Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}",
            "inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}",
            "struct ConvexHull{",
            "\tint op;set<Point>s;",
            "\tinline int PIP(Point P){",
            "\t\tIT it=s.lower_bound(Point(P.x,-inf));",
            "\t\tif(it==s.end())return 0;",
            "\t\tif(it->x==P.x)return (P.y-it->y)*op<=0;",
            "\t\tif(it==s.begin())return 0;",
            "\t\tIT j=it,k=it;--j;return Cro(P-*j,*k-*j)*op>=0;",
            "\t}",
            "\tinline int judge(IT it){",
            "\t\tIT j=it,k=it;",
            "\t\tif(j==s.begin())return 0;--j;",
            "\t\tif(++k==s.end())return 0;",
            "\t\treturn Cro(*it-*j,*k-*j)*op>=0;",
            "\t}",
            "\tinline void insert(Point P){",
            "\t\tif(PIP(P))return;",
            "\t\tIT tmp=s.lower_bound(Point(P.x,-inf));if(tmp!=s.end()&&tmp->x==P.x)s.erase(tmp);",
            "\t\ts.insert(P);IT it=s.find(P),p=it;",
            "\t\tif(p!=s.begin()){--p;while(judge(p)){IT tmp=p--;s.erase(tmp);}}",
            "\t\tif((p=++it)!=s.end())while(judge(p)){IT tmp=p++;s.erase(tmp);}",
            "\t}",
            "}up,down;",
            "int x,y,T,op;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(T),up.op=1,down.op=-1;",
            "\twhile(T--){",
            "\t\tin(op),P.In();",
            "\t\tif(op<2)up.insert(P),down.insert(P);",
            "\t\telse puts((up.PIP(P)&&down.PIP(P))?\"YES\":\"NO\");",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 动态凸包"
    },
    "圆的面积并": {
        "prefix": "acm-8.3optimize",
        "body": [
            "//#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#include<map>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "#define Rd register LD",
            "#define Vector Point",
            "using namespace std;",
            "const int N=2003;",
            "const LD eps=1e-13;",
            "int n,m;map<LD,LD>vis;",
            "inline int dcmp(Rd a){return a<-eps?-1:(a>eps?1:0);}",
            "struct Point{",
            "    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}",
            "    inline void in(){scanf(\"%lf%lf\",&x,&y);}",
            "};",
            "struct Segment{",
            "    LD L,R;Segment(LD l=0,LD r=0){L=l,R=r;}",
            "    inline bool operator<(Segment O)const{return L!=O.L?L<O.L:R<O.R;}",
            "}Seg[N];",
            "struct Circle{",
            "    LD x,y,r,L,R,D,U;",
            "    inline void in(){scanf(\"%lf%lf%lf\",&x,&y,&r),L=x-r,R=x+r,D=y-r,U=y+r;}",
            "    inline bool operator<(Circle B)const{return D<B.D;}",
            "}C[N],C_[N];",
            "inline bool cmp(Circle A,Circle B){return A.r<B.r;}",
            "inline LD dis(Circle A,Circle B){return sqrt((A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y));}",
            "inline LD SS(Rd x){return x*x;}",
            "inline LD F(Rd Y){",
            "    if(vis[Y])return vis[Y];",
            "    Re t=0;Rd ans=0;",
            "    for(Re i=1;i<=n;++i)",
            "        if(dcmp(Y-C[i].D)>0&&dcmp(Y-C[i].U)<0){",
            "            Rd tmp=sqrt(SS(C[i].r)-SS(C[i].y-Y));",
            "            if(dcmp(tmp)>0)Seg[++t]=Segment(C[i].x-tmp,C[i].x+tmp);",
            "        }",
            "    if(!t)return 0.0;",
            "    sort(Seg+1,Seg+t+1);",
            "    for(Re i=1,j;i<=t;i=j+1){",
            "        Rd L=Seg[i].L,R=Seg[i].R;j=i;",
            "        while(j<t&&Seg[j+1].L<=R)++j,R=max(R,Seg[j].R);",
            "        ans+=R-L;",
            "    }",
            "    return vis[Y]=ans;",
            "}",
            "inline LD Simpson(Rd L,Rd R){return (R-L)*(F(L)+4.0*F((L+R)*0.5)+F(R))/6.0;}",
            "inline LD sakura(Rd L,Rd R,Rd now){",
            "    Rd mid=(L+R)*0.5,FL=Simpson(L,mid),FR=Simpson(mid,R);",
            "    if(!dcmp(now-FL-FR))return now;",
            "    return sakura(L,mid,FL)+sakura(mid,R,FR);",
            "}",
            "LD ans;",
            "int main(){",
            "//    freopen(\"789.txt\",\"r\",stdin);",
            "    scanf(\"%d\",&m);",
            "    for(Re i=1;i<=m;++i)C_[i].in();",
            "    sort(C_+1,C_+m+1,cmp),C[++n]=C_[m];",
            "    for(Re i=m-1;i>=1;--i){",
            "        Re flag=1;",
            "        for(Re j=1;j<=n&&flag;++j)",
            "\t\t\tif(dcmp(C_[i].r-C[j].r+dis(C_[i],C[j]))<=0)flag=0;",
            "        if(flag)C[++n]=C_[i];",
            "    }",
            "    sort(C+1,C+n+1);",
            "    for(Re i=1,j;i<=n;i=j+1){",
            "        Rd D=C[i].D,U=C[i].U;j=i;",
            "        while(j<n&&C[j+1].D<=U)++j,U=max(U,C[j].U);",
            "        ans+=sakura(D,U,Simpson(D,U));",
            "    }",
            "    printf(\"%.3lf\",ans);",
            "}",
            ""
        ],
        "description": "插入 圆的面积并"
    },
    "旋转卡壳": {
        "prefix": "acm-8.3最远点对距离平方",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Vector Point",
            "#define Rd register LD",
            "#define Re register int",
            "using namespace std;",
            "const int N=50003;",
            "const LD eps=1e-8;",
            "inline int dcmp(Rd a){return a<-eps?-1:(a>eps?1:0);}",
            "struct Point{",
            "    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}",
            "    inline void in(){scanf(\"%lf%lf\",&x,&y);}",
            "}cp[N],Poi[N];",
            "inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}",
            "inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}",
            "inline LD Len(Vector a){return Dot(a,a);}",
            "inline Vector operator-(Point a,Point b){return Vector(a.x-b.x,a.y-b.y);}",
            "inline bool cmp(Point a,Point b){return a.x!=b.x?a.x<b.x:a.y<b.y;}",
            "inline int ConvexHull(Point *P,Re n,Point *cp){",
            "\tsort(P+1,P+n+1,cmp);",
            "\tRe t=0;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\twhile(t>1&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;",
            "\t\tcp[++t]=P[i];",
            "\t}",
            "\tRe St=t;",
            "\tfor(Re i=n-1;i>=1;--i){",
            "\t\twhile(t>St&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;",
            "\t\tcp[++t]=P[i];",
            "\t}",
            "\treturn --t;",
            "}",
            "int n;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tscanf(\"%d\",&n);",
            "\tfor(Re i=1;i<=n;++i)Poi[i].in();",
            "\tRe cnt=ConvexHull(Poi,n,cp);",
            "\tRd Ans=Len(cp[2]-cp[1]);",
            "\tfor(Re i=1,j=3;i<=cnt;++i){",
            "\t\twhile(dcmp(Cro(cp[i+1]-cp[i],cp[j]-cp[i])-Cro(cp[i+1]-cp[i],cp[j+1]-cp[i]))<0)j=j<cnt?j+1:1;",
            "\t\tAns=max(Ans,max(Len(cp[j]-cp[i]),Len(cp[j]-cp[i+1])));",
            "\t}",
            "\tprintf(\"%lld\\n\",(LL)(Ans+0.5));",
            "}",
            ""
        ],
        "description": "插入 旋转卡壳"
    },
    "最小圆覆盖": {
        "prefix": "acm-8.3随机增量法",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Vector Point",
            "#define Re register int",
            "#define S(a) ((a)*(a))",
            "using namespace std;",
            "const int N=1e6+3;",
            "const LD eps=1e-8;",
            "inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}// 撤销操作",
            "int n;",
            "struct Point{",
            "    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}",
            "    inline void in(){scanf(\"%lf%lf\",&x,&y);}",
            "}P[N];",
            "inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}",
            "inline LD Len(Vector a){return sqrt(Dot(a,a));}",
            "inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}",
            "inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}",
            "inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}",
            "struct Circle{Point O;LD r;Circle(Point P,LD R=0){O=P,r=R;}};",
            "inline Circle getcircle(Point A,Point B,Point C){",
            "\tLD x1=A.x,y1=A.y,x2=B.x,y2=B.y,x3=C.x,y3=C.y;",
            "\tLD D=((S(x2)+S(y2)-S(x3)-S(y3))*(y1-y2)-(S(x1)+S(y1)-S(x2)-S(y2))*(y2-y3))/((x1-x2)*(y2-y3)-(x2-x3)*(y1-y2));",
            "\tLD E=(S(x1)+S(y1)-S(x2)-S(y2)+D*(x1-x2))/(y2-y1);",
            "\tLD F=-(S(x1)+S(y1)+D*x1+E*y1);",
            "\treturn Circle(Point(-D/2.0,-E/2.0),sqrt((S(D)+S(E)-4.0*F)/4.0));",
            "}",
            "inline int PIC(Circle &C,Point a){return dcmp(Len(a-C.O)-C.r)<=0;}",
            "inline void Random(){for(Re i=1;i<=n;++i)swap(P[i],P[rand()%n+1]);}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tscanf(\"%d\",&n);",
            "\tfor(Re i=1;i<=n;++i)P[i].in();",
            "//\trandom_shuffle(P+1,P+n+1);",
            "\tRandom();Circle C=Circle(P[1],0);",
            "\tfor(Re i=2;i<=n;++i)",
            "\t\tif(!PIC(C,P[i])){",
            "\t\t\tC=Circle(P[i],0);",
            "\t\t\tfor(Re j=1;j<i;++j)",
            "\t\t\t\tif(!PIC(C,P[j])){",
            "\t\t\t\t\tC.O=(P[i]+P[j])*0.5,C.r=Len(P[j]-C.O);",
            "\t\t\t\t\tfor(Re k=1;k<j;++k)if(!PIC(C,P[k]))C=getcircle(P[i],P[j],P[k]);",
            "\t\t\t\t}",
            "\t\t}",
            "\tprintf(\"%.2lf %.2lf %.2lf\\n\",C.O.x,C.O.y,C.r);",
            "}",
            ""
        ],
        "description": "插入 最小圆覆盖"
    },
    "自适应辛普森积分": {
        "prefix": "acm-8.3局部精度",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "#define Vector Point",
            "using namespace std;",
            "const LD eps=1e-7;",
            "inline int dcmp(LD a,LD eps){return a<-eps?-1:(a>eps?1:0);}",
            "LD a,b,c,d,L,R;",
            "inline LD F(LD x){return (c*x+d)/(a*x+b);}",
            "inline LD Simpson(LD L,LD R){return (R-L)*(F(L)+4.0*F((L+R)*0.5)+F(R))/6.0;}",
            "inline LD sakura(LD L,LD R,LD now,LD eps){",
            "\tLD mid=(L+R)*0.5,FL=Simpson(L,mid),FR=Simpson(mid,R);",
            "\tif(!dcmp(now-FL-FR,eps))return now;",
            "\treturn sakura(L,mid,FL,eps/2)+sakura(mid,R,FR,eps/2);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tscanf(\"%lf%lf%lf%lf%lf%lf\",&a,&b,&c,&d,&L,&R);",
            "\tprintf(\"%lf\\n\",sakura(L,R,Simpson(L,R),eps));",
            "}",
            ""
        ],
        "description": "插入 自适应辛普森积分"
    },
    "计算几何基础": {
        "prefix": "acm-8.3全家桶",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "",
            "",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "#define Vector Point",
            "using namespace std;",
            "const int N=262144+3;",
            "const LD eps=1e-8,Pi=acos(-1.0);",
            "inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}// 撤销操作",
            "inline LD Abs(LD a){return a*dcmp(a);}",
            "struct Point{",
            "    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}",
            "    inline void in(){scanf(\"%lf%lf\",&x,&y);}",
            "    inline void out(){printf(\"%.2lf %.2lf\\n\",x,y);}",
            "};",
            "",
            "",
            "inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}",
            "inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}",
            "inline LD Len(Vector a){return sqrt(Dot(a,a));}",
            "inline LD Angle(Vector a,Vector b){return acos(Dot(a,b)/Len(a)/Len(b));}// 撤销操作�нǡ�",
            "inline Vector Normal(Vector a){return Vector(-a.y,a.x);}",
            "inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}",
            "inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}",
            "inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}",
            "inline bool operator==(Point a,Point b){return !dcmp(a.x-b.x)&&!dcmp(a.y-b.y);}",
            "",
            "",
            "",
            "inline Point turn_P(Point a,LD theta){",
            "    LD x=a.x*cos(theta)+a.y*sin(theta);",
            "    LD y=-a.x*sin(theta)+a.y*cos(theta);",
            "    return Point(x,y);",
            "}",
            "inline Point turn_PP(Point a,Point b,LD theta){",
            "    LD x=(a.x-b.x)*cos(theta)+(a.y-b.y)*sin(theta)+b.x;",
            "    LD y=-(a.x-b.x)*sin(theta)+(a.y-b.y)*cos(theta)+b.y;",
            "    return Point(x,y);",
            "}",
            "",
            "",
            "",
            "inline int pan_PL(Point p,Point a,Point b){",
            "    return !dcmp(Cro(p-a,b-a))&&dcmp(Dot(p-a,p-b))<=0;",
            "}",
            "inline LD dis_PL(Point p,Point a,Point b){",
            "    if(a==b)return Len(p-a);//AB�غ�",
            "    Vector x=p-a,y=p-b,z=b-a;",
            "    if(dcmp(Dot(x,z))<0)return Len(x);",
            "    if(dcmp(Dot(y,z))>0)return Len(y);",
            "    return Abs(Cro(x,z)/Len(z));",
            "}",
            "",
            "inline int pan_PL_(Point p,Point a,Point b){",
            "    return !dcmp(Cro(p-a,b-a));",
            "}",
            "inline Point FootPoint(Point p,Point a,Point b){",
            "    Vector x=p-a,y=p-b,z=b-a;",
            "    LD len1=Dot(x,z)/Len(z),len2=-1.0*Dot(y,z)/Len(z);",
            "    return a+z*(len1/(len1+len2));",
            "}",
            "inline Point Symmetry_PL(Point p,Point a,Point b){",
            "    return p+(FootPoint(p,a,b)-p)*2;",
            "}",
            "",
            "inline Point cross_LL(Point a,Point b,Point c,Point d){",
            "    Vector x=b-a,y=d-c,z=a-c;",
            "    return a+x*(Cro(y,z)/Cro(x,y));",
            "}",
            "inline int pan_cross_L_L(Point a,Point b,Point c,Point d){",
            "    return pan_PL(cross_LL(a,b,c,d),c,d);",
            "}",
            "inline int pan_cross_LL(Point a,Point b,Point c,Point d){",
            "    LD c1=Cro(b-a,c-a),c2=Cro(b-a,d-a);",
            "    LD d1=Cro(d-c,a-c),d2=Cro(d-c,b-c);",
            "    return dcmp(c1)*dcmp(c2)<0&&dcmp(d1)*dcmp(d2)<0;",
            "}",
            "",
            "inline int PIP(Point *P,Re n,Point a){",
            "    Re cnt=0;LD tmp;",
            "    for(Re i=1;i<=n;++i){",
            "        Re j=i<n?i+1:1;",
            "        if(pan_PL(a,P[i],P[j]))return 2;",
            "        if(a.y>=min(P[i].y,P[j].y)&&a.y<max(P[i].y,P[j].y))",
            "            tmp=P[i].x+(a.y-P[i].y)/(P[j].y-P[i].y)*(P[j].x-P[i].x),cnt+=dcmp(tmp-a.x)>0;",
            "    }",
            "    return cnt&1;",
            "}",
            "inline int judge(Point a,Point L,Point R){",
            "    return dcmp(Cro(L-a,R-a))>0;",
            "}",
            "inline int PIP_(Point *P,Re n,Point a){",
            "    if(judge(P[1],a,P[2])||judge(P[1],P[n],a))return 0;",
            "    if(pan_PL(a,P[1],P[2])||pan_PL(a,P[1],P[n]))return 2;",
            "    Re l=2,r=n-1;",
            "    while(l<r){",
            "        Re mid=l+r+1>>1;",
            "        if(judge(P[1],P[mid],a))l=mid;",
            "        else r=mid-1;",
            "    }",
            "    if(judge(P[l],a,P[l+1]))return 0;",
            "    if(pan_PL(a,P[l],P[l+1]))return 2;",
            "    return 1;",
            "}",
            "",
            "",
            "inline int judge_PP(Point *A,Re n,Point *B,Re m){",
            "    for(Re i1=1;i1<=n;++i1){",
            "        Re j1=i1<n?i1+1:1;",
            "        for(Re i2=1;i2<=m;++i2){",
            "            Re j2=i2<m?i2+1:1;",
            "            if(pan_cross_LL(A[i1],A[j1],B[i2],B[j2]))return 0;",
            "            if(PIP(B,m,A[i1])||PIP(A,n,B[i2]))return 0;// 撤销操作�",
            "        }",
            "    }",
            "    return 1;",
            "}",
            "",
            "",
            "",
            "inline LD PolyArea(Point *P,Re n){",
            "    LD S=0;",
            "    for(Re i=1;i<=n;++i)S+=Cro(P[i],P[i<n?i+1:1]);",
            "    return S/2.0;",
            "}",
            "",
            "",
            "",
            "",
            "",
            "inline bool cmp1(Vector a,Vector b){return a.x==b.x?a.y<b.y:a.x<b.x;};",
            "inline int ConvexHull(Point *P,Re n,Point *cp){",
            "    sort(P+1,P+n+1,cmp1);",
            "    Re t=0;",
            "    for(Re i=1;i<=n;++i){",
            "        while(t>1&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;",
            "        cp[++t]=P[i];",
            "    }",
            "    Re St=t;",
            "    for(Re i=n-1;i>=1;--i){",
            "        while(t>St&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;",
            "        cp[++t]=P[i];",
            "    }",
            "    return --t;",
            "}",
            "",
            "struct Line{",
            "    Point a,b;LD k;Line(Point A=Point(0,0),Point B=Point(0,0)){a=A,b=B,k=atan2(b.y-a.y,b.x-a.x);}",
            "    inline bool operator<(const Line &O)const{return dcmp(k-O.k)?dcmp(k-O.k)<0:judge(O.a,O.b,a);}",
            "}L[N],Q[N];",
            "inline Point cross(Line L1,Line L2){return cross_LL(L1.a,L1.b,L2.a,L2.b);}",
            "inline int judge(Line L,Point a){return dcmp(Cro(a-L.a,L.b-L.a))>0;}",
            "inline int halfcut(Line *L,Re n,Point *P){",
            "    sort(L+1,L+n+1);Re m=n;n=0;",
            "    for(Re i=1;i<=m;++i)if(i==1||dcmp(L[i].k-L[i-1].k))L[++n]=L[i];",
            "    Re h=1,t=0;",
            "    for(Re i=1;i<=n;++i){",
            "        while(h<t&&judge(L[i],cross(Q[t],Q[t-1])))--t;",
            "        while(h<t&&judge(L[i],cross(Q[h],Q[h+1])))++h;",
            "        Q[++t]=L[i];",
            "    }",
            "    while(h<t&&judge(Q[h],cross(Q[t],Q[t-1])))--t;",
            "    while(h<t&&judge(Q[t],cross(Q[h],Q[h+1])))++h;",
            "    n=0;",
            "    for(Re i=h;i<=t;++i)P[++n]=cross(Q[i],Q[i<t?i+1:h]);",
            "    return n;",
            "}",
            "",
            "Vector V1[N],V2[N];",
            "inline int Mincowski(Point *P1,Re n,Point *P2,Re m,Vector *V){",
            "    for(Re i=1;i<=n;++i)V1[i]=P1[i<n?i+1:1]-P1[i];",
            "    for(Re i=1;i<=m;++i)V2[i]=P2[i<m?i+1:1]-P2[i];",
            "    Re t=0,i=1,j=1;V[++t]=P1[1]+P2[1];",
            "    while(i<=n&&j<=m)++t,V[t]=V[t-1]+(dcmp(Cro(V1[i],V2[j]))>0?V1[i++]:V2[j++]);",
            "    while(i<=n)++t,V[t]=V[t-1]+V1[i++];",
            "    while(j<=m)++t,V[t]=V[t-1]+V2[j++];",
            "    return t;",
            "}",
            "",
            "",
            "",
            "#define S(a) ((a)*(a))",
            "struct Circle{Point O;LD r;Circle(Point P,LD R=0){O=P,r=R;}};",
            "inline Circle getCircle(Point A,Point B,Point C){",
            "    LD x1=A.x,y1=A.y,x2=B.x,y2=B.y,x3=C.x,y3=C.y;",
            "    LD D=((S(x2)+S(y2)-S(x3)-S(y3))*(y1-y2)-(S(x1)+S(y1)-S(x2)-S(y2))*(y2-y3))/((x1-x2)*(y2-y3)-(x2-x3)*(y1-y2));",
            "    LD E=(S(x1)+S(y1)-S(x2)-S(y2)+D*(x1-x2))/(y2-y1);",
            "    LD F=-(S(x1)+S(y1)+D*x1+E*y1);",
            "    return Circle(Point(-D/2.0,-E/2.0),sqrt((S(D)+S(E)-4.0*F)/4.0));",
            "}",
            "inline Circle getcircle(Point A,Point B,Point C){",
            "    Point P1=(A+B)*0.5,P2=(A+C)*0.5;",
            "    Point O=cross_LL(P1,P1+Normal(B-A),P2,P2+Normal(C-A));",
            "    return Circle(O,Len(A-O));",
            "}",
            "",
            "inline int PIC(Circle C,Point a){return dcmp(Len(a-C.O)-C.r)<=0;}",
            "inline void Random(Point *P,Re n){for(Re i=1;i<=n;++i)swap(P[i],P[rand()%n+1]);}",
            "inline Circle Min_Circle(Point *P,Re n){",
            "//  random_shuffle(P+1,P+n+1);",
            "    Random(P,n);Circle C=Circle(P[1],0);",
            "    for(Re i=2;i<=n;++i)if(!PIC(C,P[i])){",
            "        C=Circle(P[i],0);",
            "        for(Re j=1;j<i;++j)if(!PIC(C,P[j])){",
            "            C.O=(P[i]+P[j])*0.5,C.r=Len(P[j]-C.O);",
            "            for(Re k=1;k<j;++k)if(!PIC(C,P[k]))C=getcircle(P[i],P[j],P[k]);",
            "        }",
            "    }",
            "    return C;",
            "}",
            "",
            "inline LD calc(Point A,Point B,Point O,LD R){",
            "    if(A==O||B==O)return 0;",
            "    Re op=dcmp(Cro(A-O,B-O))>0?1:-1;LD ans=0;",
            "    Vector x=A-O,y=B-O;",
            "    Re flag1=dcmp(Len(x)-R)>0,flag2=dcmp(Len(y)-R)>0;",
            "    if(!flag1&&!flag2)ans=Abs(Cro(A-O,B-O))/2.0;",
            "    else if(flag1&&flag2){",
            "        if(dcmp(dis_PL(O,A,B)-R)>=0)ans=R*R*Angle(x,y)/2.0;",
            "        else{",
            "            if(dcmp(Cro(A-O,B-O))>0)swap(A,B);",
            "            Point F=FootPoint(O,A,B);LD lenx=Len(F-O),len=sqrt(R*R-lenx*lenx);",
            "            Vector z=turn_P(F-O,Pi/2.0)*(len/lenx);Point B_=F+z,A_=F-z;",
            "            ans=R*R*(Angle(A-O,A_-O)+Angle(B-O,B_-O))/2.0+Cro(B_-O,A_-O)/2.0;",
            "        }",
            "    }",
            "    else{",
            "        if(flag1)swap(A,B);",
            "        Point F=FootPoint(O,A,B);LD lenx=Len(F-O),len=sqrt(R*R-lenx*lenx);",
            "        Vector z=turn_P(F-O,Pi/2.0)*(len/lenx);Point C=dcmp(Cro(A-O,B-O))>0?F-z:F+z;",
            "        ans=Abs(Cro(A-O,C-O))/2.0+R*R*Angle(C-O,B-O)/2.0;",
            "    }",
            "    return ans*op;",
            "}",
            "",
            "int main(){}",
            ""
        ],
        "description": "插入 计算几何基础"
    },
    "闵可夫斯基和": {
        "prefix": "acm-8.3战争",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Vector Point",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,inf=1e8;",
            "const LD eps=1e-8;",
            "inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Point{",
            "\tLD x,y;LD k;Point(LD X=0,LD Y=0){x=X,y=Y;}",
            "\tinline void in(){scanf(\"%lf%lf\",&x,&y);}",
            "\tinline void print(Re op=0){printf(\"(%.2lf %.2lf) \",x,y);if(op)puts(\"\");}",
            "};",
            "inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}",
            "inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}",
            "inline LD Len(Vector a){return sqrt(Dot(a,a));}",
            "inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}",
            "inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}",
            "inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}",
            "inline bool cmp1(Vector a,Vector b){return a.x==b.x?a.y<b.y:a.x<b.x;};",
            "inline int ConvexHull(Point *P,Re n,Point *cp){",
            "    sort(P+1,P+n+1,cmp1);",
            "    Re t=0;",
            "    for(Re i=1;i<=n;++i){",
            "        while(t>1&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;",
            "        cp[++t]=P[i];",
            "    }",
            "    Re St=t;",
            "    for(Re i=n-1;i>=1;--i){",
            "        while(t>St&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;",
            "        cp[++t]=P[i];",
            "    }",
            "    return --t;",
            "}",
            "inline int judge(Point a,Point L,Point R){",
            "\treturn dcmp(Cro(L-a,R-a))>0;",
            "}",
            "inline int PIL(Point a,Point b,Point p){",
            "\treturn !dcmp(Cro(p-a,b-a))&&dcmp(Cro(p-a,p-b))<0;",
            "}",
            "inline int PIP(Point *P,Re n,Point a){",
            "\tif(judge(P[1],a,P[2])||judge(P[1],P[n],a))return 0;",
            "\tif(PIL(P[1],P[2],a)||PIL(P[1],P[n],a))return 1;",
            "\tRe l=2,r=n-1;",
            "\twhile(l<r){",
            "\t\tRe mid=l+r+1>>1;",
            "\t\tif(judge(P[1],P[mid],a))l=mid;",
            "\t\telse r=mid-1;",
            "\t}",
            "\tif(judge(P[l],a,P[l+1]))return 0;",
            "\tif(PIL(P[l],P[l+1],a))return 1;",
            "\treturn 1;",
            "}",
            "Vector V1[N],V2[N];",
            "inline int Mincowski(Point *P1,Re n,Point *P2,Re m,Vector *V){",
            "\tfor(Re i=1;i<=n;++i)V1[i]=P1[i<n?i+1:1]-P1[i];",
            "\tfor(Re i=1;i<=m;++i)V2[i]=P2[i<m?i+1:1]-P2[i];",
            "\tRe t=0,i=1,j=1;V[++t]=P1[1]+P2[1];",
            "\twhile(i<=n&&j<=m)++t,V[t]=V[t-1]+(dcmp(Cro(V1[i],V2[j]))>0?V1[i++]:V2[j++]);",
            "\twhile(i<=n)++t,V[t]=V[t-1]+V1[i++];",
            "\twhile(j<=m)++t,V[t]=V[t-1]+V2[j++];",
            "\treturn t;",
            "}",
            "int n,m,T;Point v,P1[N],P2[N],cp1[N],cp2[N];Vector V[N<<1];",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),in(T);",
            "\tfor(Re i=1;i<=n;++i)P1[i].in();",
            "\tfor(Re i=1;i<=m;++i)P2[i].in(),P2[i].x=-P2[i].x,P2[i].y=-P2[i].y;",
            "\tRe cnt1=ConvexHull(P1,n,cp1),cnt2=ConvexHull(P2,m,cp2);",
            "\tRe cnt=Mincowski(cp1,cnt1,cp2,cnt2,V); ",
            "\twhile(T--)v.in(),printf(\"%d\\n\",PIP(V,cnt,v));",
            "}",
            ""
        ],
        "description": "插入 闵可夫斯基和"
    },
    "小凸爱跑步": {
        "prefix": "acm-8.3直线不等式转半平面交",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LD double",
            "#define LL long long",
            "#define Vector Point",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,inf=2e9;",
            "const LD eps=1e-8;",
            "inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Point{",
            "    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}",
            "    inline void in(){scanf(\"%lf%lf\",&x,&y);}",
            "};",
            "inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}",
            "inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}",
            "inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}",
            "inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}",
            "inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}",
            "inline int judge(Point a,Point L,Point R){",
            "    return dcmp(Cro(L-a,R-a))>0;",
            "}",
            "inline Point cross(Point a,Point b,Point c,Point d){",
            "    Vector x=b-a,y=d-c,z=a-c;",
            "    return a+x*(Cro(y,z)/Cro(x,y));",
            "}",
            "inline LD PolyArea(Point *P,Re n){",
            "    LD ans=0;",
            "    for(Re i=1;i<=n;++i)ans+=Cro(P[i],P[i<n?i+1:1]);",
            "    return ans/2.0;",
            "}",
            "struct Line{",
            "    Point a,b;LD k;Line(Point A=Point(0,0),Point B=Point(0,0)){a=A,b=B,k=atan2(b.y-a.y,b.x-a.x);}",
            "    inline bool operator<(const Line &O)const{return dcmp(k-O.k)?dcmp(k-O.k)<0:judge(O.a,O.b,b);}",
            "}Q[N<<1];",
            "inline int judge(Point a,Line L){return dcmp(Cro(a-L.a,L.b-L.a))>0;}",
            "inline Point cross(Line L1,Line L2){return cross(L1.a,L1.b,L2.a,L2.b);}",
            "inline int halfcut(Line *L,Re n,Point *P){",
            "    sort(L+1,L+n+1);Re m=0;",
            "    for(Re i=1;i<=n;++i)if(i==1||dcmp(L[i].k-L[i-1].k))L[++m]=L[i];",
            "    Re h=1,t=0;",
            "    for(Re i=1;i<=m;++i){",
            "        while(h<t&&judge(cross(Q[t],Q[t-1]),L[i]))--t;",
            "        while(h<t&&judge(cross(Q[h],Q[h+1]),L[i]))++h;",
            "        Q[++t]=L[i];",
            "    }",
            "    while(h<t&&judge(cross(Q[t],Q[t-1]),Q[h]))--t;",
            "    while(h<t&&judge(cross(Q[h],Q[h+1]),Q[t]))++h;",
            "    m=0;",
            "    for(Re i=h;i<=t;++i)P[++m]=cross(Q[i],Q[i<t?i+1:h]);",
            "    return m;",
            "}",
            "int n,m;Point P[N],PP[N<<1];Line L[N<<1];",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    in(n);",
            "    for(Re i=1;i<=n;++i)P[i].in();P[n+1]=P[1];",
            "    for(Re i=2;i<=n;++i){",
            "        Point tmp=P[1]-P[2]-P[i]+P[i+1];",
            "        LD a=tmp.y,b=-tmp.x,c=Cro(P[1],P[2])-Cro(P[i],P[i+1]);//ax+by+c<=0",
            "        if(!dcmp(a)&&!dcmp(b)){",
            "            if(dcmp(c)<=0)continue;",
            "            else{puts(\"0\");return 0;}",
            "        }",
            "        if(!dcmp(a)){//by+c<=0",
            "            if(b>0)L[++m]=Line(Point(1,-c/b),Point(0,-c/b));//y<=-c/b",
            "            else L[++m]=Line(Point(0,-c/b),Point(1,-c/b));//y>=-c/b",
            "        }",
            "        else if(!dcmp(b)){//ax+c<=0",
            "            if(a>0)L[++m]=Line(Point(-c/a,0),Point(-c/a,1));//x<=-c/a",
            "            else L[++m]=Line(Point(-c/a,1),Point(-c/a,0));//x>=-c/a",
            "        }",
            "        else if(b>0)L[++m]=Line(Point(1,-a/b-c/b),Point(0,-c/b));//y<=-a/b*x-c/b",
            "        else L[++m]=Line(Point(0,-c/b),Point(1,-a/b-c/b));//y>=-a/b*x-c/b",
            "    }",
            "    for(Re i=1;i<=n;++i)L[++m]=Line(P[i],P[i+1]);",
            "    Re cnt=halfcut(L,m,PP);",
            "    printf(\"%.4lf\\n\",PolyArea(PP,cnt)/PolyArea(P,n));",
            "}",
            ""
        ],
        "description": "插入 小凸爱跑步"
    },
    "逃考": {
        "prefix": "acm-8.3半平面交求点管辖区域",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#include<queue>",
            "#define LD double",
            "#define LL long long",
            "#define Vector Point",
            "#define Re register int",
            "using namespace std;",
            "const int N=610;",
            "const LD eps=1e-8,Pi=acos(-1);",
            "inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}",
            "struct Point{",
            "\tLD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}",
            "\tinline void in(){scanf(\"%lf%lf\",&x,&y);}",
            "\tinline void print(){printf(\"%.2lf %.2lf\\n\",x,y);}",
            "}P[N];",
            "inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}",
            "inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}",
            "inline LD Len(Vector a){return Dot(a,a);}",
            "inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}",
            "inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}",
            "inline Vector operator*(Vector a,LD x){return Vector(a.x*x,a.y*x);}",
            "inline Point cross(Point a,Point b,Point c,Point d){",
            "\tVector x=b-a,y=d-c,z=a-c;",
            "\treturn a+x*(Cro(y,z)/Cro(x,y));",
            "}",
            "inline int judge(Point a,Point L,Point R){",
            "\treturn dcmp(Cro(L-a,R-a))>0;",
            "}",
            "struct Line{",
            "\tPoint a,b;LD k;int id;Line(Point A=Point(0,0),Point B=Point(0,0)){id=0,a=A,b=B,k=atan2(b.y-a.y,b.x-a.x);}",
            "\tinline bool operator<(const Line &O)const{return dcmp(k-O.k)?dcmp(k-O.k)<0:judge(O.a,O.b,b);}",
            "}Q[N];",
            "inline Point cross(Line L1,Line L2){return cross(L1.a,L1.b,L2.a,L2.b);}",
            "inline int judge(Line L,Point a){return dcmp(Cro(a-L.a,L.b-L.a))>0;}",
            "inline void halfcut(Line *L,Re &n){",
            "\tsort(L+1,L+n+1);Re m=n;n=0;",
            "\tfor(Re i=1;i<=m;++i)if(i==1||dcmp(L[i].k-L[i-1].k))L[++n]=L[i];",
            "\tRe h=1,t=0;",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\twhile(h<t&&judge(L[i],cross(Q[t],Q[t-1])))--t;",
            "\t\twhile(h<t&&judge(L[i],cross(Q[h],Q[h+1])))++h;",
            "\t\tQ[++t]=L[i];",
            "\t}",
            "\twhile(h<t&&judge(Q[h],cross(Q[t],Q[t-1])))--t;",
            "\twhile(h<t&&judge(Q[t],cross(Q[h],Q[h+1])))++h;",
            "\tn=0;",
            "\tfor(Re i=h;i<=t;++i)L[++n]=Q[i];",
            "}",
            "inline Point turnP(Point a,LD theta){",
            "\tLD x=a.x*cos(theta)+a.y*sin(theta);",
            "\tLD y=a.y*cos(theta)-a.x*sin(theta);",
            "\treturn Point(x,y);",
            "}",
            "inline Line get_midL(Point a,Point b){",
            "\tPoint M=a+((b-a)*0.5);",
            "\treturn Line(M,M+turnP(a-b,Pi/2.0));",
            "}",
            "int n,m,T,st,ed;Point a,b,c,d,x0,A[N];Line L[N];",
            "struct Dijkstra{",
            "\tint o,dis[N],pan[N],head[N];",
            "\tstruct QAQ{int w,to,next;}a[N*N];",
            "\tinline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}",
            "\tstruct QWQ{int x,d;inline bool operator<(const QWQ &O)const{return d>O.d;}};",
            "\tpriority_queue<QWQ>Q;",
            "\tinline void CL(){memset(head,0,sizeof(head)),o=0;}",
            "\tinline int dijkstra(Re st,Re ed){",
            "\t\tfor(Re i=0;i<=n;++i)dis[i]=2e9,pan[i]=0;",
            "\t\tQ.push((QWQ){st,dis[st]=1});",
            "\t\twhile(!Q.empty()){",
            "\t\t\tRe x=Q.top().x;Q.pop();",
            "\t\t\tif(pan[x])continue;",
            "\t\t\tpan[x]=1;",
            "\t\t\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\t\t\tif(dis[to=a[i].to]>dis[x]+a[i].w)",
            "\t\t\t\t\tQ.push((QWQ){to,dis[to]=dis[x]+a[i].w});",
            "\t\t}",
            "\t\treturn dis[ed];",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"456.txt\",\"r\",stdin);",
            "\tscanf(\"%d\",&T);",
            "\twhile(T--){",
            "\t\tscanf(\"%d\",&n),c.in(),x0.in(),T1.CL();",
            "\t\tif(!n){puts(\"0\");continue;}",
            "\t\ta=Point(0,0),b=Point(c.x,0),d=Point(0,c.y);",
            "\t\tfor(Re i=1;i<=n;++i){",
            "\t\t\tA[i].in();",
            "\t\t\tif(A[i].x>c.x||A[i].y>c.y){--i,--n;continue;}",
            "\t\t\tif(dcmp(Len(A[i]-x0)-Len(A[st]-x0))<0)st=i;",
            "\t\t}",
            "//\t\tprintf(\"st=%d\\n\",st);",
            "\t\tfor(Re i=1;i<=n;++i){",
            "\t\t\tRe m=0;",
            "\t\t\tfor(Re j=1;j<=n;++j)",
            "\t\t\t\tif(i!=j)L[++m]=get_midL(A[i],A[j]),L[m].id=j;",
            "\t\t\tL[++m]=Line(a,b),L[++m]=Line(b,c),L[++m]=Line(c,d),L[++m]=Line(d,a);",
            "\t\t\thalfcut(L,m);",
            "\t\t\tfor(Re j=1;j<=m;++j)T1.add(i,L[j].id,L[j].id>0);",
            "\t\t}",
            "\t\tprintf(\"%d\\n\",T1.dijkstra(st,ed));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 逃考"
    },
    "防线修建": {
        "prefix": "acm-8.3动态凸包 维护周长",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#include<cmath>",
            "#include<set>",
            "#define LD double",
            "#define LL long long",
            "#define Vector Point",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "const LD eps=1e-8,Pi=acos(-1.0);",
            "inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}",
            "inline LD Abs(LD a){return a*dcmp(a);}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Point{",
            "    LL x,y;Point(LL X=0,LL Y=0){x=X,y=Y;}",
            "    inline void In(){Re X,Y;in(X),in(Y),x=X,y=Y;}",
            "    inline bool operator<(const Point &O)const{return x!=O.x?x<O.x:y<O.y;}",
            "};",
            "inline LL Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}",
            "inline LL Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}",
            "inline LD Len(Vector a){return sqrt((LD)Dot(a,a));}",
            "inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}",
            "inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}",
            "inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}",
            "inline bool operator==(Vector a,Vector b){return a.x==b.x&&a.y==b.y;}",
            "struct Splay{",
            "\t#define pl tr[p].ps[0]",
            "\t#define pr tr[p].ps[1]",
            "\t#define pf tr[p].fa",
            "\t#define pv tr[p].v",
            "\tint O,root;queue<int>Q;LD ans;",
            "\tstruct QAQ{int fa,ps[2];Point v;}tr[N];",
            "\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\tinline void rotate(Re p){",
            "\t\tRe fa=pf,fas=which(p);",
            "\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\tRe x=tr[p].ps[fas^1];",
            "\t\tconnect(x,fa,fas),connect(fa,p,fas^1),connect(p,pa,pas);",
            "\t}",
            "\tinline void splay(Re p){",
            "\t\tfor(Re fa;pf;rotate(p))",
            "\t\t\tif(tr[fa=pf].fa)rotate(which(p)==which(fa)?fa:p);",
            "\t\troot=p;",
            "\t}",
            "\tinline void CL(Re p){tr[p].v=Point(),pf=pl=pr=0,p=0;}",
            "\tinline int New(){",
            "\t\tRe p;",
            "\t\tif(Q.empty())p=++O;",
            "\t\telse p=Q.front(),Q.pop();",
            "\t\treturn p;",
            "\t}",
            "\tinline void del(Re p){CL(p),Q.push(p);}",
            "\tinline int pre(Re p){p=pl;while(pr)p=pr;return p;}",
            "\tinline int nex(Re p){p=pr;while(pl)p=pl;return p;}",
            "\tinline void insert(Point v){",
            "\t\tRe p=root,fa=0;",
            "\t\twhile(p)fa=p,p=tr[p].ps[!(pv<v)];",
            "\t\tp=New(),pv=v,pf=fa;",
            "\t\tif(fa)tr[fa].ps[!(tr[fa].v<v)]=p;",
            "\t\tsplay(p);Re p1=0,p2=0;",
            "\t\tif(pl)p1=pre(p);if(pr)p2=nex(p);",
            "\t\tif(p1&&p2)ans-=Len(tr[p2].v-tr[p1].v);",
            "\t\tif(p1)ans+=Len(v-tr[p1].v);",
            "\t\tif(p2)ans+=Len(v-tr[p2].v);",
            "\t}",
            "\tinline void erase(Point v){",
            "\t\tRe p=root;",
            "\t\twhile(!(pv==v))p,p=tr[p].ps[!(pv<v)];",
            "\t\tsplay(p);",
            "\t\tRe p1=0,p2=0;",
            "\t\tif(pl)p1=pre(p);if(pr)p2=nex(p);",
            "\t\tif(p1&&p2)ans+=Len(tr[p2].v-tr[p1].v);",
            "\t\tif(p1)ans-=Len(v-tr[p1].v);",
            "\t\tif(p2)ans-=Len(v-tr[p2].v);",
            "\t\tif(!pl&&!pr){root=0,del(p);return;}",
            "\t\tif(!pl||!pr){tr[root=pl+pr].fa=0,del(p);return;}",
            "\t\tsplay(pre(p)),tr[root].ps[1]=pr,tr[pr].fa=root,del(p);",
            "\t}",
            "};",
            "#define IT set<Point>::iterator",
            "struct ConvexHull{",
            "\tint op;set<Point>s;LD ans;//Splay ss;",
            "\tinline void Insert(Point P){",
            "\t\ts.insert(P);IT p=s.find(P);",
            "\t\tRe o1=0,o2=0;IT p1=p,p2=p;",
            "\t\tif(p1!=s.begin())o1=1,--p1;if(++p2!=s.end())o2=1;",
            "\t\tif(o1&&o2)ans-=Len(*p2-*p1);",
            "\t\tif(o1)ans+=Len(*p-*p1);",
            "\t\tif(o2)ans+=Len(*p-*p2);",
            "\t}",
            "\tinline void Erase(IT p){",
            "\t\tRe o1=0,o2=0;IT p1=p,p2=p;",
            "\t\tif(p1!=s.begin())o1=1,--p1;if(++p2!=s.end())o2=1;",
            "\t\tif(o1&&o2)ans+=Len(*p2-*p1);",
            "\t\tif(o1)ans-=Len(*p-*p1);",
            "\t\tif(o2)ans-=Len(*p-*p2);",
            "\t\ts.erase(p);",
            "\t}",
            "\tinline int PIP(Point P){",
            "\t\tIT it=s.lower_bound(Point(P.x,-2e9));",
            "\t\tif(it==s.end())return 0;",
            "\t\tif(it->x==P.x)return (P.y-it->y)*op<=0;",
            "\t\tif(it==s.begin())return 0;",
            "\t\tIT j=it,k=it;--j;return Cro(P-*j,*k-*j)*op>=0;",
            "\t}",
            "\tinline int judge(IT it){",
            "\t\tIT j=it,k=it;",
            "\t\tif(j==s.begin())return 0;--j;",
            "\t\tif(++k==s.end())return 0;",
            "\t\treturn Cro(*it-*j,*k-*j)*op>=0;",
            "\t}",
            "\tinline void insert(Point P){",
            "\t\tif(PIP(P))return;",
            "\t\tIT tmp=s.lower_bound(Point(P.x,-2e9));if(tmp!=s.end()&&tmp->x==P.x)Erase(tmp);//ss.erase(*tmp),s.erase(tmp);",
            "\t\tInsert(P);/*s.insert(P),ss.insert(P);*/IT it=s.find(P),p=it;",
            "\t\tif(p!=s.begin()){--p;while(judge(p)){IT tmp=p--;Erase(tmp);/*ss.erase(*tmp),s.erase(tmp);*/}}",
            "\t\tif((p=++it)!=s.end())while(judge(p)){IT tmp=p++;Erase(tmp);/*ss.erase(*tmp),s.erase(tmp);*/}",
            "\t}",
            "}up,down;",
            "int n,x,T,X[N],op[N],vis[N];LD Ans[N];Point P[N];",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(x),P[0].In(),up.op=1,down.op=-1;",
            "\tup.insert(P[0]),down.insert(P[0]);",
            "\tup.insert(Point(0,0)),down.insert(Point(0,0));",
            "\tup.insert(Point(x,0)),down.insert(Point(x,0));",
            "\tin(n);for(Re i=1;i<=n;++i)P[i].In();",
            "\tin(T);for(Re i=1;i<=T;++i){in(op[i]);if(op[i]<2)in(x),vis[X[i]=x]=1;}",
            "\tfor(Re i=1;i<=n;++i)if(!vis[i])up.insert(P[i]),down.insert(P[i]);",
            "\tfor(Re i=T;i>=1;--i)",
            "\t\tif(op[i]<2)up.insert(P[X[i]]),down.insert(P[X[i]]);",
            "\t\telse Ans[i]=up.ans+Len(*up.s.begin()-*down.s.begin())+Len(*--up.s.end()-*--down.s.end());",
            "\tfor(Re i=1;i<=T;++i)if(op[i]>1)printf(\"%.2lf\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 防线修建"
    },
    "CDQ分治": {
        "prefix": "acm-2.12三维偏序",
        "body": [
            "//#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "//#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstdio>",
            "#define Re register int",
            "using std::sort;",
            "const int N=1e5+5,K=2e5+5;",
            "int n,m,k,C[K],ans[N];",
            "struct QAQ{int a,b,c,cnt,ans;}a[N],Q[N];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline bool cmp1(QAQ p,QAQ o){return p.a!=o.a?p.a<o.a:(p.b!=o.b?p.b<o.b:p.c<o.c);}",
            "inline bool cmp2(QAQ p,QAQ o){return p.b<o.b;}",
            "inline void add(Re x,Re v){while(x<=k)C[x]+=v,x+=x&-x;}",
            "inline int ask(Re x){",
            "\tRe ans=0;",
            "\twhile(x)ans+=C[x],x-=x&-x;",
            "\treturn ans;",
            "}",
            "inline void CDQ(Re L,Re R){",
            "\tif(L==R)return;",
            "\tRe mid=L+R>>1;",
            "\tCDQ(L,mid),CDQ(mid+1,R);",
            "\tsort(Q+L,Q+mid+1,cmp2),sort(Q+mid+1,Q+R+1,cmp2);",
            "\tRe j=L;",
            "\tfor(Re i=mid+1;i<=R;++i){",
            "\t\twhile(j<=mid&&Q[j].b<=Q[i].b)add(Q[j].c,Q[j].cnt),++j;",
            "\t\tQ[i].ans+=ask(Q[i].c);",
            "\t}",
            "\tfor(Re i=L;i<j;++i)add(Q[i].c,-Q[i].cnt);",
            "}",
            "int main(){",
            "\tin(n),in(k);",
            "\tfor(Re i=1;i<=n;++i)in(a[i].a),in(a[i].b),in(a[i].c);",
            "\tsort(a+1,a+n+1,cmp1);",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tif(i>2&&a[i].a==a[i-1].a&&a[i].b==a[i-1].b&&a[i].c==a[i-1].c)++Q[m].cnt;",
            "\t\telse Q[++m]=a[i],Q[m].cnt=1;",
            "\t}",
            "\tCDQ(1,m);",
            "\tfor(Re i=1;i<=m;++i)ans[Q[i].ans+Q[i].cnt-1]+=Q[i].cnt;",
            "\tfor(Re i=0;i<n;++i)printf(\"%d\\n\",ans[i]);",
            "}",
            ""
        ],
        "description": "插入 CDQ分治"
    },
    "整体二分": {
        "prefix": "acm-2.12静态区间第K小",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=2e5+3,M=2e5+3,inf=1e9;",
            "int n,x,y,z,T,cnt,Ans[M];char op;",
            "struct QAQ{int l,r,k,op,id;}Q[N+M],Q1[N+M],Q2[N+M];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct BIT{",
            "\tint C[N];",
            "\tinline void add(Re x,Re v){while(x<=n)C[x]+=v,x+=x&-x;}",
            "\tinline int ask_(Re x){Re ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}",
            "\tinline int ask(Re l,Re r){return ask_(r)-ask_(l-1);}",
            "}T1;",
            "inline void sakura(Re l,Re r,Re L,Re R){",
            "\tif(L>R)return;",
            "\tif(l==r){",
            "\t\tfor(Re i=L;i<=R;++i)if(Q[i].op>1)Ans[Q[i].id]=l;",
            "\t\treturn;",
            "\t}",
            "\tRe mid=l+r>>1,m1=0,m2=0;",
            "\tfor(Re i=L;i<=R;++i)",
            "\t\tif(Q[i].op&1){",
            "\t\t\tif(Q[i].k<=mid)Q1[++m1]=Q[i],T1.add(Q[i].id,1);",
            "\t\t\telse Q2[++m2]=Q[i];",
            "\t\t}",
            "\t\telse{",
            "\t\t\tRe tmp=T1.ask(Q[i].l,Q[i].r);",
            "\t\t\tif(Q[i].k<=tmp)Q1[++m1]=Q[i];",
            "\t\t\telse Q[i].k-=tmp,Q2[++m2]=Q[i];",
            "\t\t}",
            "\tfor(Re i=1;i<=m1;++i)if(Q1[i].op&1)T1.add(Q1[i].id,-1);",
            "\tfor(Re i=1;i<=m1;++i)Q[L+i-1]=Q1[i];",
            "\tfor(Re i=1;i<=m2;++i)Q[L+m1+i-1]=Q2[i];",
            "\tsakura(l,mid,L,L+m1-1);",
            "\tsakura(mid+1,r,L+m1,R);",
            "}",
            "int main(){",
            "\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T);",
            "\tfor(Re i=1;i<=n;++i)in(x),Q[++cnt]=(QAQ){0,0,x,1,i};",
            "\tfor(Re i=1;i<=T;++i)in(x),in(y),in(z),Q[++cnt]=(QAQ){x,y,z,2,i};",
            "\tsakura(-inf,inf,1,cnt);",
            "\tfor(Re i=1;i<=T;++i)printf(\"%d\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 整体二分"
    },
    "1.区修,单查": {
        "prefix": "acm-2.9optimize",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "#define F(x,a,b) for(Re x=a;x<=b;++x)",
            "const int N=5e4+3,T=230;",
            "int n,t,x,l,r,Q,fu,pt[N],L[T],R[T];LL a[N],S[T],add[T];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void change(Re l,Re r,Re x){",
            "\tRe p=pt[l],q=pt[r];",
            "\tif(p==q){F(i,l,r)a[i]+=x;S[p]+=x*(r-l+1);}",
            "\telse{",
            "\t\tF(i,p+1,q-1)add[i]+=x;",
            "\t\tF(i,l,R[p])a[i]+=x;S[p]+=x*(R[p]-l+1);",
            "\t\tF(i,L[q],r)a[i]+=x;S[q]+=x*(r-L[q]+1);",
            "\t}",
            "}",
            "inline LL ask(Re x){return a[x]+add[pt[x]];}",
            "int main(){",
            "\tin(n),t=sqrt(Q=n);",
            "\tF(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;",
            "\tif(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;",
            "\tF(i,1,n)in(x),a[i]=x;",
            "\tF(i,1,t)F(j,L[i],R[i])pt[j]=i,S[i]+=a[j];",
            "\twhile(Q--){",
            "\t\tin(n),in(l),in(r),in(x);",
            "\t\tif(n)printf(\"%lld\\n\",ask(r));",
            "\t\telse change(l,r,x);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 1.区修,单查"
    },
    "2.区修,区查": {
        "prefix": "acm-2.9小于c2的个数",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "#define F(x,a,b) for(Re x=a;x<=b;++x)",
            "#define lo(l,r,x) (lower_bound(b+l,b+r+1,x)-b)",
            "using namespace std;",
            "const int N=5e4+3,T=230;",
            "int n,t,x,l,r,o,Q,fu,pt[N],L[T],R[T];LL a[N],b[N],add[T];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void sak(Re l,Re r,Re p,Re x){F(i,l,r)a[i]+=x;F(i,L[p],R[p])b[i]=a[i];sort(b+L[p],b+R[p]+1);}",
            "inline void change(Re l,Re r,Re x){",
            "\tRe p=pt[l],q=pt[r];",
            "\tif(p==q)sak(l,r,p,x);",
            "\telse{",
            "\t\tF(i,p+1,q-1)add[i]+=x;",
            "\t\tsak(l,R[p],p,x),sak(L[q],r,q,x);",
            "\t}",
            "}",
            "inline LL ask(Re l,Re r,LL x){",
            "\tRe p=pt[l],q=pt[r];LL ans=0;",
            "\tif(p==q){F(i,l,r)ans+=a[i]+add[p]<x;return ans;}",
            "\telse{",
            "\t\tF(i,p+1,q-1)ans+=lo(L[i],R[i],x-add[i])-L[i];",
            "\t\tF(i,l,R[p])ans+=a[i]+add[p]<x;",
            "\t\tF(i,L[q],r)ans+=a[i]+add[q]<x;",
            "\t}",
            "\treturn ans;",
            "}",
            "int main(){",
            "\tin(n),t=sqrt(Q=n);",
            "\tF(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;",
            "\tif(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;",
            "\tF(i,1,n)in(x),a[i]=b[i]=x;",
            "\tF(i,1,t)F(j,L[i],R[i])pt[j]=i;",
            "\tF(i,1,t)sort(b+L[i],b+R[i]+1);",
            "\twhile(Q--){",
            "\t\tin(o),in(l),in(r),in(x);",
            "\t\tif(o)printf(\"%lld\\n\",ask(l,r,(LL)x*x));",
            "\t\telse change(l,r,x);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 2.区修,区查"
    },
    "3.区修,区查": {
        "prefix": "acm-2.9x的前驱",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define inf -2147483647",
            "#define Re register int",
            "#define F(x,a,b) for(Re x=a;x<=b;++x)",
            "using namespace std;",
            "const int N=1e5+3,T=330;",
            "int n,t,x,l,r,o,Q,fu,pt[N],L[T],R[T],a[N],b[N],add[T];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void sak(Re l,Re r,Re p,Re x){F(i,l,r)a[i]+=x;F(i,L[p],R[p])b[i]=a[i];sort(b+L[p],b+R[p]+1);}",
            "inline void change(Re l,Re r,Re x){",
            "    Re p=pt[l],q=pt[r];",
            "    if(p==q)sak(l,r,p,x);",
            "    else{",
            "        F(i,p+1,q-1)add[i]+=x;",
            "        sak(l,R[p],p,x),sak(L[q],r,q,x);",
            "    }",
            "}",
            "inline int ask(Re l,Re r,Re x){",
            "    Re p=pt[l],q=pt[r],ans=inf,w;",
            "    if(p==q){F(i,l,r)if(a[i]+add[p]<x)ans=max(ans,a[i]+add[p]);}",
            "    else{",
            "        F(i,p+1,q-1)w=lower_bound(b+L[i],b+R[i]+1,x-add[i])-(b+1),ans=w>=L[i]?max(ans,b[w]+add[i]):ans;",
            "        F(i,l,R[p])if(a[i]+add[p]<x)ans=max(ans,a[i]+add[p]);",
            "        F(i,L[q],r)if(a[i]+add[q]<x)ans=max(ans,a[i]+add[q]);",
            "    }",
            "    return ans==inf?-1:ans;",
            "}",
            "int main(){",
            "    in(n),t=sqrt(Q=n);",
            "    F(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;",
            "    if(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;",
            "    F(i,1,n)in(x),a[i]=b[i]=x;",
            "    F(i,1,t)F(j,L[i],R[i])pt[j]=i;",
            "    F(i,1,t)sort(b+L[i],b+R[i]+1);",
            "    while(Q--){",
            "        in(o),in(l),in(r),in(x);",
            "        if(o)printf(\"%d\\n\",ask(l,r,x));",
            "        else change(l,r,x);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 3.区修,区查"
    },
    "4.区修,区查": {
        "prefix": "acm-2.9Sum",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "#define F(x,a,b) for(Re x=a;x<=b;++x)",
            "const int N=5e4+3,T=230;",
            "int n,t,x,l,r,Q,fu,pt[N],L[T],R[T];LL a[N],S[T],add[T];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void change(Re l,Re r,Re x){",
            "\tRe p=pt[l],q=pt[r];",
            "\tif(p==q){F(i,l,r)a[i]+=x;S[p]+=(LL)x*(r-l+1);}",
            "\telse{",
            "\t\tF(i,p+1,q-1)add[i]+=x;",
            "\t\tF(i,l,R[p])a[i]+=x;S[p]+=(LL)x*(R[p]-l+1);",
            "\t\tF(i,L[q],r)a[i]+=x;S[q]+=(LL)x*(r-L[q]+1);",
            "\t}",
            "}",
            "inline LL ask(Re l,Re r){",
            "\tRe p=pt[l],q=pt[r];LL ans=0;",
            "\tif(p==q){F(i,l,r)ans+=a[i];ans+=add[p]*(r-l+1);}",
            "\telse{",
            "\t\tF(i,p+1,q-1)ans+=S[i]+add[i]*(LL)(R[i]-L[i]+1);",
            "\t\tF(i,l,R[p])ans+=a[i];ans+=add[p]*(LL)(R[p]-l+1);",
            "\t\tF(i,L[q],r)ans+=a[i];ans+=add[q]*(LL)(r-L[q]+1);",
            "\t}",
            "\treturn ans;",
            "}",
            "int main(){",
            "\tin(n),t=sqrt(Q=n);",
            "\tF(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;",
            "\tif(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;",
            "\tF(i,1,n)in(x),a[i]=x;",
            "\tF(i,1,t)F(j,L[i],R[i])pt[j]=i,S[i]+=a[j];",
            "\twhile(Q--){",
            "\t\tin(n),in(l),in(r),in(x);",
            "\t\tif(n)printf(\"%lld\\n\",ask(l,r)%(x+1));",
            "\t\telse change(l,r,x);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 4.区修,区查"
    },
    "5.区修,区查(Sum)": {
        "prefix": "acm-2.9Sqrt",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "#define F(x,a,b) for(Re x=a;x<=b;++x)",
            "const int N=5e4+3,T=230;",
            "int n,t,x,l,r,Q,fu,pt[N],L[T],R[T],pan[T];LL a[N],S[T];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void sakura(Re p){",
            "\tif(pan[p])return;pan[p]=1,S[p]=0;",
            "\tF(i,L[p],R[p])S[p]+=(a[i]=sqrt(a[i])),pan[p]&=(a[i]<=1);",
            "}",
            "inline void change(Re l,Re r){",
            "\tRe p=pt[l],q=pt[r];",
            "\tif(p==q){F(i,l,r)S[p]-=a[i],a[i]=sqrt(a[i]),S[p]+=a[i];}",
            "\telse{",
            "\t\tF(i,p+1,q-1)sakura(i);",
            "\t\tF(i,l,R[p])S[p]-=a[i],a[i]=sqrt(a[i]),S[p]+=a[i];",
            "\t\tF(i,L[q],r)S[q]-=a[i],a[i]=sqrt(a[i]),S[q]+=a[i];",
            "\t}",
            "}",
            "inline LL ask(Re l,Re r){",
            "\tRe p=pt[l],q=pt[r];LL ans=0;",
            "\tif(p==q){F(i,l,r)ans+=a[i];}",
            "\telse{",
            "\t\tF(i,p+1,q-1)ans+=S[i];",
            "\t\tF(i,l,R[p])ans+=a[i];",
            "\t\tF(i,L[q],r)ans+=a[i];",
            "\t}",
            "\treturn ans;",
            "}",
            "int main(){",
            "\tin(n),t=sqrt(Q=n);",
            "\tF(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;",
            "\tif(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;",
            "\tF(i,1,n)in(x),a[i]=x;",
            "\tF(i,1,t)F(j,L[i],R[i])pt[j]=i,S[i]+=a[j];",
            "\twhile(Q--){",
            "\t\tin(n),in(l),in(r),in(x);",
            "\t\tif(n)printf(\"%lld\\n\",ask(l,r));",
            "\t\telse change(l,r);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 5.区修,区查(Sum)"
    },
    "6.单插,单查": {
        "prefix": "acm-2.9w前面插入x",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<vector>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define Re register int",
            "#define F(x,a,b) for(Re x=a;x<=b;++x)",
            "using namespace std;",
            "const int N=1e5+3,T=330;",
            "int n,o,t,x,l,r,Q,fu,pt[N],pw[N],L[T],R[T];",
            "vector<int>a[T];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void change(Re w,Re x){",
            "    F(i,1,t)",
            "        if(w>a[i].size())w-=a[i].size();",
            "        else{a[i].insert(a[i].begin()+w-1,x);return;}",
            "}",
            "inline int ask(Re w){",
            "    F(i,1,t)",
            "        if(w>a[i].size())w-=a[i].size();",
            "        else return a[i][w-1];",
            "}",
            "int main(){",
            "    in(n),t=sqrt(Q=n);",
            "    F(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;",
            "    if(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;",
            "    F(i,1,t){F(j,L[i],R[i])in(x),a[i].push_back(x),pt[j]=i;}",
            "    while(Q--){",
            "        in(o),in(l),in(r),in(x);",
            "        if(o)printf(\"%d\\n\",ask(r));",
            "        else change(l,r);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 6.单插,单查"
    },
    "7.区修,单查": {
        "prefix": "acm-2.9+,×",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<cstdio>",
            "#include<cmath>",
            "#define Re register int",
            "#define F(x,a,b) for(Re x=a;x<=b;++x)",
            "const int N=1e5+3,T=320;",
            "int n,t,x,l,r,Q,fu,P=10007,pt[N],L[T],R[T],a[N],add[T],mul[T];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void spread(Re p){",
            "\tF(i,L[p],R[p])(((a[i]*=mul[p])%=P)+=add[p])%=P;",
            "\tadd[p]=0,mul[p]=1;",
            "}",
            "inline void change(Re l,Re r,Re x){",
            "\tRe p=pt[l],q=pt[r];spread(p);",
            "\tif(p==q)F(i,l,r)(a[i]+=x)%=P;",
            "\telse{",
            "\t\tspread(q);",
            "\t\tF(i,p+1,q-1)(add[i]+=x)%P;",
            "\t\tF(i,l,R[p])(a[i]+=x)%=P;",
            "\t\tF(i,L[q],r)(a[i]+=x)%=P;",
            "\t}",
            "}",
            "inline void change2(Re l,Re r,Re x){",
            "\tRe p=pt[l],q=pt[r];spread(p);",
            "\tif(p==q)F(i,l,r)(a[i]*=x)%=P;",
            "\telse{",
            "\t\tspread(q);",
            "\t\tF(i,p+1,q-1)(add[i]*=x)%=P,(mul[i]*=x)%=P;",
            "\t\tF(i,l,R[p])(a[i]*=x)%=P;",
            "\t\tF(i,L[q],r)(a[i]*=x)%=P;",
            "\t}",
            "}",
            "inline int ask(Re x){return (a[x]*mul[pt[x]]%P+add[pt[x]])%P;}",
            "int main(){",
            "\tin(n),t=sqrt(Q=n);",
            "\tF(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t,mul[i]=1;",
            "\tif(R[t]<n)R[++t]=n,L[t]=R[t-1]+1,mul[t]=1;",
            "\tF(i,1,n)in(a[i]);",
            "\tF(i,1,t)F(j,L[i],R[i])pt[j]=i;",
            "\twhile(Q--){",
            "\t\tin(n),in(l),in(r),in(x);",
            "\t\tif(n>1)printf(\"%d\\n\",ask(r));",
            "\t\telse n?change2(l,r,x%P):change(l,r,x%P);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 7.区修,单查"
    },
    "8.区修,区查(c的个数)": {
        "prefix": "acm-2.9推平",
        "body": [
            "#pragma GCC diagnostic error \"-std=c++11\"",
            "#pragma GCC target(\"avx\")",
            "#pragma GCC optimize(2)",
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(\"Ofast\")",
            "#pragma GCC optimize(\"inline\")",
            "#pragma GCC optimize(\"-fgcse\")",
            "#pragma GCC optimize(\"-fgcse-lm\")",
            "#pragma GCC optimize(\"-fipa-sra\")",
            "#pragma GCC optimize(\"-ftree-pre\")",
            "#pragma GCC optimize(\"-ftree-vrp\")",
            "#pragma GCC optimize(\"-fpeephole2\")",
            "#pragma GCC optimize(\"-ffast-math\")",
            "#pragma GCC optimize(\"-fsched-spec\")",
            "#pragma GCC optimize(\"unroll-loops\")",
            "#pragma GCC optimize(\"-falign-jumps\")",
            "#pragma GCC optimize(\"-falign-loops\")",
            "#pragma GCC optimize(\"-falign-labels\")",
            "#pragma GCC optimize(\"-fdevirtualize\")",
            "#pragma GCC optimize(\"-fcaller-saves\")",
            "#pragma GCC optimize(\"-fcrossjumping\")",
            "#pragma GCC optimize(\"-fthread-jumps\")",
            "#pragma GCC optimize(\"-funroll-loops\")",
            "#pragma GCC optimize(\"-fwhole-program\")",
            "#pragma GCC optimize(\"-freorder-blocks\")",
            "#pragma GCC optimize(\"-fschedule-insns\")",
            "#pragma GCC optimize(\"inline-functions\")",
            "#pragma GCC optimize(\"-ftree-tail-merge\")",
            "#pragma GCC optimize(\"-fschedule-insns2\")",
            "#pragma GCC optimize(\"-fstrict-aliasing\")",
            "#pragma GCC optimize(\"-fstrict-overflow\")",
            "#pragma GCC optimize(\"-falign-functions\")",
            "#pragma GCC optimize(\"-fcse-skip-blocks\")",
            "#pragma GCC optimize(\"-fcse-follow-jumps\")",
            "#pragma GCC optimize(\"-fsched-interblock\")",
            "#pragma GCC optimize(\"-fpartial-inlining\")",
            "#pragma GCC optimize(\"no-stack-protector\")",
            "#pragma GCC optimize(\"-freorder-functions\")",
            "#pragma GCC optimize(\"-findirect-inlining\")",
            "#pragma GCC optimize(\"-fhoist-adjacent-loads\")",
            "#pragma GCC optimize(\"-frerun-cse-after-loop\")",
            "#pragma GCC optimize(\"inline-small-functions\")",
            "#pragma GCC optimize(\"-finline-small-functions\")",
            "#pragma GCC optimize(\"-ftree-switch-conversion\")",
            "#pragma GCC optimize(\"-foptimize-sibling-calls\")",
            "#pragma GCC optimize(\"-fexpensive-optimizations\")",
            "#pragma GCC optimize(\"-funsafe-loop-optimizations\")",
            "#pragma GCC optimize(\"inline-functions-called-once\")",
            "#pragma GCC optimize(\"-fdelete-null-pointer-checks\")",
            "#include<cstdio>",
            "#include<cmath>",
            "#define Re register int",
            "#define F(x,a,b) for(Re x=a;x<=b;++x)",
            "const int N=1e5+3,T=330;",
            "int n,t,x,l,r,Q,fu,pt[N],L[T],R[T],a[N],tag[T];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline int sak(Re l,Re r,Re p,Re x){",
            "    Re tmp=0;",
            "    if(tag[p]!=-1){F(i,L[p],R[p])a[i]=tag[p];tmp+=(r-l+1)*(tag[p]==x);}",
            "    else F(i,l,r)tmp+=a[i]==x;",
            "    tag[p]=-1;F(i,l,r)a[i]=x;",
            "    return tmp;",
            "}",
            "inline int fuck(Re p,Re x){",
            "    Re tmp=0;",
            "    if(tag[p]!=-1){F(j,L[p],R[p])a[j]=tag[p];tmp+=(R[p]-L[p]+1)*(tag[p]==x);}",
            "    else F(j,L[p],R[p])tmp+=a[j]==x;",
            "    tag[p]=x;",
            "    return tmp;",
            "}",
            "inline int sovle(Re l,Re r,Re x){",
            "    Re p=pt[l],q=pt[r],ans=0;",
            "    if(p==q)return l==r?fuck(p,x):sak(l,r,p,x);",
            "    else{",
            "        F(i,p+1,q-1)ans+=fuck(i,x);",
            "        ans+=sak(l,R[p],p,x)+sak(L[q],r,q,x);",
            "    }",
            "    return ans;",
            "}",
            "int main(){",
            "    in(n),t=sqrt(Q=n);",
            "    F(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;",
            "    if(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;",
            "    F(i,1,n)in(x),a[i]=x;",
            "    F(i,1,t){tag[i]=-1;F(j,L[i],R[i])pt[j]=i;}",
            "    while(Q--){",
            "        in(l),in(r),in(x);",
            "        printf(\"%d\\n\",sovle(l,r,x));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 8.区修,区查(c的个数)"
    },
    "左偏树": {
        "prefix": "acm-2.11可并堆",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+5;",
            "int n,x,y,T,op,A[N];",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "struct Leftist_Tree{",
            "\tint fa[N],pl[N],pr[N],dis[N];",
            "\tinline int merge(Re x,Re y){",
            "\t\tif(!x||!y)return x+y;",
            "\t\tif(A[x]>A[y]||(A[x]==A[y]&&x>y))swap(x,y);",
            "\t\tpr[x]=merge(pr[x],y);",
            "\t\tif(dis[pl[x]]<dis[pr[x]])swap(pl[x],pr[x]);",
            "\t\tdis[x]=dis[pr[x]]+1;",
            "\t\tif(pl[x])fa[pl[x]]=x;",
            "\t\tif(pr[x])fa[pr[x]]=x;",
            "\t\treturn x;",
            "\t}",
            "\tinline int top(Re x){return fa[x]==x?x:fa[x]=top(fa[x]);}",
            "\tinline void pop(Re x){",
            "\t\tA[x]=-1,fa[pl[x]]=pl[x],fa[pr[x]]=pr[x];",
            "\t\tfa[x]=merge(pl[x],pr[x]),pl[x]=pr[x]=0;",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T);",
            "\tfor(Re i=1;i<=n;++i)in(A[i]),T1.fa[i]=i;",
            "\twhile(T--){",
            "\t\tin(op),in(x);",
            "\t\tif(op&1){",
            "\t\t\tin(y);",
            "\t\t\tif(A[x]!=-1&&A[y]!=-1){",
            "\t\t\t\tx=T1.top(x),y=T1.top(y);",
            "\t\t\t\tif(x!=y)T1.merge(x,y);",
            "\t\t\t}",
            "\t\t}",
            "\t\telse if(A[x]==-1)puts(\"-1\");",
            "\t\telse printf(\"%d\\n\",A[T1.top(x)]),T1.pop(T1.top(x));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 左偏树"
    },
    "Splay (无注释)(文艺平衡树)": {
        "prefix": "acm-2.7区间翻转",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstdio>",
            "#define Re register int",
            "#define pl tr[p].ps[0]",
            "#define pr tr[p].ps[1]",
            "#define pf tr[p].fa",
            "#define pv tr[p].v",
            "using namespace std;",
            "const int N=1e5+5,inf=2e9;",
            "int T,x,y,n,o,root,a[N];",
            "struct Splay{int v,fa,ps[2],tag,cnt,size;}tr[N];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void pushup(Re p){if(!p)return;tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}",
            "inline void connect(Re p,Re f,Re o){tr[tr[p].fa=f].ps[o]=p;}",
            "inline int which(Re p){return tr[pf].ps[1]==p;}",
            "inline void pushdown(Re p){",
            "\tif(tr[p].tag)tr[p].tag=0,swap(pl,pr),tr[pl].tag^=1,tr[pr].tag^=1;",
            "} ",
            "inline void rotate(Re p){",
            "\tRe y=pf,ys=which(p);",
            "\tRe R=tr[y].fa,Rs=which(y);",
            "\tRe B=tr[p].ps[ys^1];",
            "\tconnect(B,y,ys),connect(y,p,ys^1),connect(p,R,Rs);",
            "\tpushup(y),pushup(p);",
            "}",
            "inline void Splay(Re p,Re to){",
            "\tfor(Re fa;(fa=pf)!=to;rotate(p))",
            "\t\tif(tr[fa].fa!=to)rotate(which(p)==which(fa)?fa:p);",
            "\tif(!to)root=p;",
            "}",
            "inline void New(Re x,Re fa){",
            "\ttr[++o].v=x,tr[o].fa=fa,tr[o].cnt=tr[o].size=1;",
            "\tif(fa)tr[fa].ps[tr[fa].v<x]=o;",
            "}",
            "inline int ask_w(Re p,Re x){",
            "\tpushdown(p);",
            "\tif(x<=tr[pl].size)return ask_w(pl,x);",
            "\telse{",
            "\t\tRe tmp=tr[pl].size+tr[p].cnt;",
            "\t\treturn x<=tmp?p:ask_w(pr,x-tmp);",
            "\t}",
            "}",
            "inline void build(Re &p,Re L,Re R,Re fa){",
            "\tif(L>R)return;",
            "\tRe mid=L+R>>1;p=++o;",
            "\tpf=fa,pv=a[mid];",
            "\ttr[p].cnt=tr[p].size=1;",
            "\tbuild(pl,L,mid-1,p),build(pr,mid+1,R,p);",
            "\tpushup(p);",
            "}",
            "inline void reverse(Re l,Re r){",
            "\tl=ask_w(root,l-1),r=ask_w(root,r+1);",
            "\tSplay(l,0),Splay(r,l);",
            "\ttr[tr[r].ps[0]].tag^=1;",
            "}",
            "inline void print(Re p){",
            "\tpushdown(p);",
            "\tif(pl)print(pl);",
            "\tif(pv!=inf&&pv!=-inf)printf(\"%d \",pv);",
            "\tif(pr)print(pr);",
            "}",
            "int main(){",
            "\tin(n),in(T);",
            "\ta[1]=-inf,a[n+2]=inf;",
            "\tfor(Re i=2;i<=n+1;++i)a[i]=i-1;",
            "\tbuild(root,1,n+2,0);",
            "\twhile(T--)in(x),in(y),reverse(x+1,y+1);",
            "\tprint(root);",
            "}",
            ""
        ],
        "description": "插入 Splay (无注释)(文艺平衡树)"
    },
    "Splay (有注释)(文艺平衡树)": {
        "prefix": "acm-2.7区间翻转",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstdio>",
            "#define Re register int",
            "#define pl tr[p].ps[0]",
            "#define pr tr[p].ps[1]",
            "#define pf tr[p].fa",
            "#define pv tr[p].v",
            "using namespace std;",
            "const int N=1e5+5,inf=2e9;",
            "int T,x,y,n,o,root,a[N];",
            "struct Splay{int v,fa,ps[2],tag,cnt,size;}tr[N];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void pushup(Re p){if(!p)return;tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}",
            "inline void connect(Re p,Re f,Re o){tr[tr[p].fa=f].ps[o]=p;}",
            "inline int which(Re p){return tr[pf].ps[1]==p;}",
            "inline void pushdown(Re p){",
            "    if(tr[p].tag)tr[p].tag=0,swap(pl,pr),tr[pl].tag^=1,tr[pr].tag^=1;",
            "} ",
            "inline void rotate(Re p){",
            "    Re y=pf,ys=which(p);",
            "    Re R=tr[y].fa,Rs=which(y);",
            "    Re B=tr[p].ps[ys^1];",
            "    connect(B,y,ys),connect(y,p,ys^1),connect(p,R,Rs);",
            "    pushup(y),pushup(p);",
            "}",
            "inline void Splay(Re p,Re to){",
            "    for(Re fa;(fa=pf)!=to;rotate(p))",
            "        if(tr[fa].fa!=to)rotate(which(p)==which(fa)?fa:p);",
            "    if(!to)root=p;",
            "}",
            "inline void New(Re x,Re fa){",
            "    tr[++o].v=x,tr[o].fa=fa,tr[o].cnt=tr[o].size=1;",
            "    if(fa)tr[fa].ps[tr[fa].v<x]=o;",
            "}",
            "inline int ask_w(Re p,Re x){",
            "    pushdown(p);",
            "    if(x<=tr[pl].size)return ask_w(pl,x);",
            "    else{",
            "        Re tmp=tr[pl].size+tr[p].cnt;",
            "        return x<=tmp?p:ask_w(pr,x-tmp);",
            "    }",
            "}",
            "inline void build(Re &p,Re L,Re R,Re fa){",
            "    if(L>R)return;",
            "    Re mid=L+R>>1;p=++o;",
            "    pf=fa,pv=a[mid];",
            "    tr[p].cnt=tr[p].size=1;",
            "    build(pl,L,mid-1,p),build(pr,mid+1,R,p);",
            "    pushup(p);",
            "}",
            "inline void reverse(Re l,Re r){",
            "    l=ask_w(root,l-1),r=ask_w(root,r+1);",
            "    Splay(l,0),Splay(r,l);",
            "    tr[tr[r].ps[0]].tag^=1;",
            "}",
            "inline void print(Re p){",
            "    pushdown(p);",
            "    if(pl)print(pl);",
            "    if(pv!=inf&&pv!=-inf)printf(\"%d \",pv);",
            "    if(pr)print(pr);",
            "}",
            "int main(){",
            "    in(n),in(T);",
            "    a[1]=-inf,a[n+2]=inf;",
            "    for(Re i=2;i<=n+1;++i)a[i]=i-1;",
            "    build(root,1,n+2,0);",
            "    while(T--)in(x),in(y),reverse(x+1,y+1);",
            "    print(root);",
            "}",
            ""
        ],
        "description": "插入 Splay (有注释)(文艺平衡树)"
    },
    "Splay": {
        "prefix": "acm-2.7数列P2710",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=2e5+3,inf=1e9;",
            "int n,x,y,z,T,A[N];char op[20];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Splay{",
            "\t#define pl (tr[p].ps[0])",
            "\t#define pr (tr[p].ps[1])",
            "\t#define pf (tr[p].fa)",
            "\t#define pv (tr[p].v)",
            "\tint O,root,Q[N];queue<int>D;",
            "\tstruct QAQ{int v,S,fa,max,lmax,rmax,size,ps[2];bool tag,turn;}tr[N];",
            "\tinline void pushup(Re p){",
            "\t\ttr[p].S=tr[pl].S+tr[pr].S+pv;",
            "\t\ttr[p].size=tr[pl].size+tr[pr].size+1;",
            "\t\ttr[p].lmax=max(tr[pl].lmax,tr[pl].S+pv+tr[pr].lmax);",
            "\t\ttr[p].rmax=max(tr[pr].rmax,tr[pr].S+pv+tr[pl].rmax);",
            "\t\ttr[p].max=max(tr[pl].rmax+pv+tr[pr].lmax,max(tr[pl].max,tr[pr].max));",
            "\t}",
            "\tinline void updata(Re p){tr[p].turn^=1,swap(pl,pr),swap(tr[p].lmax,tr[p].rmax);}",
            "\tinline void updata(Re p,Re v){",
            "\t\ttr[p].tag=1,tr[p].S=(pv=v)*tr[p].size;",
            "\t\tif(v>0)tr[p].lmax=tr[p].rmax=tr[p].max=tr[p].S;",
            "\t\telse tr[p].lmax=tr[p].rmax=0,tr[p].max=v;",
            "\t}",
            "\tinline void pushdown(Re p){",
            "\t\tif(tr[p].tag){",
            "\t\t\tif(pl)updata(pl,pv);",
            "\t\t\tif(pr)updata(pr,pv);",
            "\t\t\ttr[p].tag=tr[p].turn=0;",
            "\t\t}",
            "\t\tif(tr[p].turn){",
            "\t\t\tif(pl)updata(pl);",
            "\t\t\tif(pr)updata(pr);",
            "\t\t\ttr[p].turn=0;",
            "\t\t}",
            "\t}",
            "\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\tinline void rotate(Re p){",
            "\t\tRe fa=pf,fas=which(p);",
            "\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\tRe x=tr[p].ps[fas^1];",
            "\t\tconnect(x,fa,fas),connect(fa,p,fas^1),connect(p,pa,pas);",
            "\t\tpushup(fa),pushup(p);",
            "\t}",
            "\tinline void splay(Re p,Re to){",
            "\t\tRe x=p,t=0;Q[++t]=x;",
            "\t\twhile(tr[x].fa)Q[++t]=x=tr[x].fa;",
            "\t\twhile(t)pushdown(Q[t--]);",
            "\t\tfor(Re fa;pf!=to;rotate(p))",
            "\t\t\tif(tr[fa=pf].fa!=to)rotate(which(p)==which(fa)?fa:p);",
            "\t\tif(!to)root=p;",
            "\t}",
            "\tinline void CL(Re p){",
            "\t\ttr[p].size=tr[p].turn=tr[p].tag=tr[p].lmax=tr[p].rmax=tr[p].S=pv=pf=pl=pr=0,tr[p].max=-inf;",
            "\t}",
            "\tinline int New(){",
            "\t\tRe p;",
            "\t\tif(D.empty())p=++O;",
            "\t\telse p=D.front(),D.pop();",
            "\t\tCL(p),tr[p].size=1;return p;",
            "\t}",
            "\tinline void build(Re &p,Re L,Re R,Re fa){",
            "\t\tif(L>R)return;Re mid=(L+R)>>1;p=New(),pv=A[mid],pf=fa;",
            "\t\tbuild(pl,L,mid-1,p),build(pr,mid+1,R,p);",
            "\t\tpushup(p);",
            "\t}",
            "\tinline void recycle(Re p){",
            "\t\tif(pl)recycle(pl);",
            "\t\tif(pr)recycle(pr);",
            "\t\tD.push(p),CL(p);",
            "\t}",
            "\tinline int find(Re p,Re K){",
            "\t\tpushdown(p);",
            "\t\tif(K<=tr[pl].size)return find(pl,K);",
            "\t\treturn K<=tr[pl].size+1?p:find(pr,K-tr[pl].size-1);",
            "\t}",
            "\tinline int split(Re L,Re R){",
            "\t\tRe p=find(root,L-1),q=find(root,R+1);",
            "\t\tsplay(p,0),splay(q,p);return tr[q].ps[0];",
            "\t}",
            "\tinline void insert(Re st,Re m){",
            "\t\tfor(Re i=1;i<=m;++i)in(A[i]);",
            "\t\tRe rt=0;build(rt,1,m,0);",
            "\t\tRe p=find(root,st),q=find(root,st+1);",
            "\t\tsplay(p,0),splay(q,p);",
            "\t\tconnect(rt,q,0),pushup(q),pushup(p);",
            "\t}",
            "\tinline void erase(Re L,Re R){",
            "\t\tRe p=split(L,R),fa=pf;",
            "\t\ttr[fa].ps[0]=pf=0,recycle(p);",
            "\t\tpushup(fa),pushup(tr[fa].fa);",
            "\t}",
            "\tinline int ask(Re L,Re R){return tr[split(L,R)].S;}",
            "\tinline int ask_max(Re L,Re R){return tr[split(L,R)].max;}",
            "\tinline void change(Re L,Re R,Re v){",
            "\t\tRe p=split(L,R);updata(p,v),pushup(pf),pushup(tr[pf].fa);",
            "\t}",
            "\tinline void reverse(Re L,Re R){",
            "\t\tRe p=split(L,R);",
            "\t\tif(!tr[p].tag)updata(p),pushup(pf),pushup(tr[pf].fa);",
            "\t}",
            "}TR;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),TR.tr[0].max=A[1]=A[n+2]=-inf;",
            "\tfor(Re i=2;i<=n+1;++i)in(A[i]);",
            "\tTR.build(TR.root,1,n+2,0);",
            "\twhile(T--){",
            "\t\tscanf(\"%s\",op);",
            "        if(op[0]=='M'&&op[2]=='X')in(x),in(y),++x,printf(\"%d\\n\",TR.ask_max(x,x+y-1));",
            "\t\telse if(op[0]=='G'&&(int)strlen(op)==3)in(x),++x,printf(\"%d\\n\",TR.ask(x,x));",
            "\t\telse{",
            "\t\t\tin(x),in(y),++x;",
            "\t        if(op[0]=='I')TR.insert(x,y);",
            "\t        if(op[0]=='D')TR.erase(x,x+y-1);",
            "\t        if(op[0]=='M')in(z),TR.change(x,x+y-1,z);",
            "\t        if(op[0]=='R')TR.reverse(x,x+y-1);",
            "\t        if(op[0]=='G')printf(\"%d\\n\",TR.ask(x,x+y-1));",
            "\t\t}",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 Splay"
    },
    "Splay  (无注释)": {
        "prefix": "acm-2.7普通平衡树",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "#define LL long long",
            "using namespace std;",
            "const int N=1e5+5;",
            "int x,T,op;",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Splay{",
            "\t#define pl tr[p].ps[0]",
            "\t#define pr tr[p].ps[1]",
            "\t#define pf tr[p].fa",
            "\t#define pv tr[p].v",
            "\tint O,root;",
            "\tstruct QAQ{int v,fa,cnt,size,ps[2];}tr[N];",
            "\tinline void pushup(Re p){",
            "\t\tif(p)tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;",
            "\t}",
            "\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\tinline void rotate(Re p){",
            "\t\tRe fa=pf,fas=which(p);",
            "\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\tRe x=tr[p].ps[fas^1];",
            "\t\tconnect(x,fa,fas),connect(fa,p,fas^1),connect(p,pa,pas);",
            "\t\tpushup(fa),pushup(p);",
            "\t}",
            "\tinline void splay(Re p){",
            "\t\tfor(Re fa;fa=pf;rotate(p))",
            "\t\t\tif(tr[fa].fa)rotate(which(p)==which(fa)?fa:p);",
            "\t\troot=p;",
            "\t}",
            "\tinline int ask_level(Re p,Re x){",
            "\t\tif(x==pv){Re ans=tr[pl].size+1;splay(p);return ans;}",
            "\t\treturn x<pv?ask_level(pl,x):tr[pl].size+tr[p].cnt+ask_level(pr,x);",
            "\t}",
            "\tinline int ask_v(Re p,Re k){",
            "\t\tif(!p)return 0;",
            "\t\tif(k<=tr[pl].size)return ask_v(pl,k);",
            "\t\tRe tmp=tr[pl].size+tr[p].cnt;",
            "\t\treturn k<=tmp?pv:ask_v(pr,k-tmp);",
            "\t}",
            "\tinline int pre(Re p){p=pl;while(pr)p=pr;return p;}",
            "\tinline int nex(Re p){p=pr;while(pl)p=pl;return p;}",
            "\tinline void insert(Re x){",
            "\t\tRe p=root,fa=0;",
            "\t\twhile(p&&pv!=x)fa=p,p=tr[p].ps[x>pv];",
            "\t\tif(p)++tr[p].cnt,pushup(p);",
            "\t\telse{",
            "\t\t\ttr[p=++O]=(QAQ){x,fa,1,1};",
            "\t\t\tif(fa)tr[fa].ps[x>tr[fa].v]=p;",
            "\t\t}",
            "\t\tsplay(p);",
            "\t}",
            "\tinline void del(Re x){",
            "\t\task_level(root,x);Re p=root;",
            "\t\tif(tr[p].cnt>1){--tr[p].cnt,pushup(p);return;}",
            "\t\tif(!pl&&!pr){root=0;return;}",
            "\t\tif(!pl||!pr){tr[root=pl+pr].fa=0;return;}",
            "\t\tsplay(pre(p));",
            "\t\ttr[root].ps[1]=pr,tr[pr].fa=root;",
            "\t\tpushup(root);",
            "\t}",
            "\tinline int ask_pre(Re x){insert(x);Re ans=tr[pre(root)].v;del(x);return ans;}",
            "\tinline int ask_nex(Re x){insert(x);Re ans=tr[nex(root)].v;del(x);return ans;}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(T);",
            "\twhile(T--){",
            "\t\tin(op),in(x);",
            "\t\tif(op==1)T1.insert(x);",
            "\t\tif(op==2)T1.del(x);",
            "\t\tif(op==3)printf(\"%d\\n\",T1.ask_level(T1.root,x));",
            "\t\tif(op==4)printf(\"%d\\n\",T1.ask_v(T1.root,x));",
            "\t\tif(op==5)printf(\"%d\\n\",T1.ask_pre(x));",
            "\t\tif(op==6)printf(\"%d\\n\",T1.ask_nex(x));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 Splay  (无注释)"
    },
    "Splay  (有注释)": {
        "prefix": "acm-2.7普通平衡树",
        "body": [
            "//#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "//#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstdio>",
            "#define Re register int",
            "#define pl tr[p].ps[0]",
            "#define pr tr[p].ps[1]",
            "#define pf tr[p].fa ",
            "#define pv tr[p].v",
            "using namespace std;",
            "const int N=1e5+5,inf=2e9;",
            "int T,a,b,n,o,root;",
            "struct Splay{int v,fa,ps[2],cnt,size;}tr[N];",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void pushup(Re p){if(!p)return;/*�������Ҫ���ж�return����������*/tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}",
            "inline void connect(Re p,Re f,Re o){tr[tr[p].fa=f].ps[o]=p;}",
            "inline int which(Re p){return tr[pf].ps[1]==p;}",
            "inline void rotate(Re p){",
            "\tRe y=pf,ys=which(p);",
            "\tRe R=tr[y].fa,Rs=which(y);",
            "\tRe B=tr[p].ps[ys^1];",
            "\tconnect(B,y,ys),connect(y,p,ys^1),connect(p,R,Rs);",
            "\tpushup(y),pushup(p);",
            "}",
            "inline void Splay(Re p){",
            "\tfor(Re fa;fa=pf;rotate(p))",
            "\t\tif(tr[fa].fa)rotate(which(p)==which(fa)?fa:p);",
            "\troot=p;",
            "}",
            "inline void New(Re x,Re fa){",
            "\ttr[++o].v=x,tr[o].fa=fa,tr[o].cnt=tr[o].size=1;",
            "\tif(fa)tr[fa].ps[tr[fa].v<x]=o;",
            "}",
            "inline void insert(Re x){",
            "\tif(!root){New(x,0);root=o;return;}",
            "\tint p=root,fa=0;",
            "\twhile(1){",
            "\t\tif(x==pv){++tr[p].cnt,pushup(p),pushup(fa),Splay(p);break;}",
            "\t\tfa=p,p=tr[p].ps[pv<x];",
            "\t\tif(!p){New(x,fa),pushup(fa),Splay(o);break;}",
            "\t}",
            "}",
            "inline int ask_level(Re p,Re x){",
            "//printf(\"p: %d\\n\",p);exit(0);",
            "\tif(x==pv){Re ans=tr[pl].size+1;Splay(p);return ans;}",
            "\telse return x<pv?ask_level(pl,x):tr[p].cnt+tr[pl].size+ask_level(pr,x);",
            "}",
            "inline int ask_v(Re p,Re x){",
            "\tif(x<=tr[pl].size)return ask_v(pl,x);",
            "\telse{",
            "\t\tRe tmp=tr[pl].size+tr[p].cnt;",
            "\t\treturn x<=tmp?pv:ask_v(pr,x-tmp);",
            "\t}",
            "}",
            "inline int ask_nex_p(Re p){p=pr;while(pl)p=pl;return p;}",
            "inline int ask_pri_p(Re p){p=pl;while(pr)p=pr;return p;}",
            "inline void del(Re x){",
            "\task_level(root,x);Re p=root;",
            "\tif(tr[p].cnt>1){--tr[p].cnt,--tr[p].size;return;}",
            "\tif(!pl&&!pr){root=0;return;}",
            "\tif(!pl||!pr){tr[root=pl+pr].fa=0;return;}",
            "\tSplay(ask_pri_p(root));",
            "\ttr[root].ps[1]=pr,tr[pr].fa=root;",
            "\tpushup(root);",
            "}",
            "int main(){",
            "\tin(T);",
            "\twhile(T--){",
            "\t\tin(a),in(b);",
            "\t\tif(a==1)insert(b);",
            "\t\tif(a==2)del(b);",
            "\t\tif(a==3)printf(\"%d\\n\",ask_level(root,b));",
            "\t\tif(a==4)printf(\"%d\\n\",ask_v(root,b));",
            "\t\tif(a==5)insert(b),printf(\"%d\\n\",tr[ask_pri_p(root)].v),del(b);",
            "\t\tif(a==6)insert(b),printf(\"%d\\n\",tr[ask_nex_p(root)].v),del(b);",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 Splay  (有注释)"
    },
    "Treap  (无注释)": {
        "prefix": "acm-2.7普通平衡树",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm> ",
            "#include<cstdlib> ",
            "#include<cstdio>",
            "#include<ctime>",
            "#define Re register int",
            "#define pl tr[p].lp",
            "#define pr tr[p].rp",
            "#define pv tr[p].v",
            "using namespace std;",
            "const int N=1e5+5,inf=2e9;",
            "int a,b,o,T,root;",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Treap{int v,rd,lp,rp,cnt,size;}tr[N];",
            "inline void pushup(Re p){tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}",
            "inline void lturn(Re &p){",
            "\tRe q=pr;pr=tr[q].lp,tr[q].lp=p;",
            "\tpushup(p),pushup(p=q);",
            "}",
            "inline void rturn(Re &p){",
            "\tRe q=pl;pl=tr[q].rp,tr[q].rp=p;",
            "\tpushup(p),pushup(p=q);",
            "}",
            "inline void insert(Re &p,Re x){",
            "\tif(!p){tr[p=++o].v=x,tr[p].cnt=tr[p].size=1,tr[p].rd=rand();return;}",
            "\t++tr[p].size;",
            "\tif(x==pv)++tr[p].cnt;",
            "\telse if(x<pv){",
            "\t\tinsert(pl,x);",
            "\t\tif(tr[pl].rd<tr[p].rd)rturn(p);",
            "\t}",
            "\telse{",
            "\t\tinsert(pr,x);",
            "\t\tif(tr[pr].rd<tr[p].rd)lturn(p);",
            "\t}",
            "}",
            "inline void del(Re &p,Re x){",
            "\tif(!p)return;",
            "    if(x<pv)--tr[p].size,del(pl,x);",
            "\telse if(x>pv)--tr[p].size,del(pr,x);",
            "\telse{",
            "\t\tif(tr[p].cnt>1)--tr[p].cnt,--tr[p].size;",
            "\t\telse{",
            "\t\t\tif(pl*pr==0)p=pl+pr;",
            "\t\t\telse if(tr[pl].rd<tr[pr].rd)rturn(p),del(p,x);",
            "\t\t\telse lturn(p),del(p,x);",
            "\t\t}",
            "\t}",
            "}",
            "inline int ask_level(Re p,Re x){ ",
            "\tif(x==pv)return tr[pl].size+1;",
            "\telse return x<pv?ask_level(pl,x):tr[p].cnt+tr[pl].size+ask_level(pr,x);",
            "}",
            "inline int ask_v(Re p,Re x){",
            "\tif(x<=tr[pl].size)return ask_v(pl,x);",
            "\telse{",
            "\t\tRe tmp=tr[pl].size+tr[p].cnt;",
            "\t\treturn x<=tmp?pv:ask_v(pr,x-tmp);",
            "\t}",
            "}",
            "inline int ask_pri(Re p,Re x){",
            "\tif(!p)return -inf;",
            "\tif(x<=pv)return ask_pri(pl,x);",
            "\telse return max(pv,ask_pri(pr,x));",
            "}",
            "inline int ask_nex(Re p,Re x){",
            "\tif(!p)return inf;",
            "\tif(x>=pv)return ask_nex(pr,x);",
            "\telse return min(pv,ask_nex(pl,x));",
            "}",
            "inline void write(int x){",
            "\tif(x<0) putchar('-'),x=-x;",
            "\tif(x>9) write(x/10);",
            "\tputchar(x%10+'0');",
            "\treturn ;",
            "}",
            "int main(){",
            "\tsrand((int)time(NULL));",
            "\tin(T);",
            "\twhile(T--){",
            "\t\tin(a),in(b);",
            "\t\tif(a==1)insert(root,b);",
            "\t\tif(a==2)del(root,b);",
            "\t\tif(a==3)write(ask_level(root,b)),puts(\"\");",
            "\t\tif(a==4)write(ask_v(root,b)),puts(\"\");",
            "\t\tif(a==5)write(ask_pri(root,b)),puts(\"\"); ",
            "\t\tif(a==6)write(ask_nex(root,b)),puts(\"\");",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 Treap  (无注释)"
    },
    "Treap  (有注释)": {
        "prefix": "acm-2.7普通平衡树",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm> ",
            "#include<cstdlib> ",
            "#include<cstdio>",
            "#include<ctime>",
            "#define Re register int",
            "#define pl tr[p].lp",
            "#define pr tr[p].rp",
            "#define pv tr[p].v",
            "using namespace std;",
            "const int N=1e5+5,inf=2e9;",
            "int a,b,o,T,root;",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Treap{int v,rd,lp,rp,cnt,size;}tr[N];",
            "inline void pushup(Re p){tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}",
            "inline void lturn(Re &p){",
            "\tRe q=pr;pr=tr[q].lp,tr[q].lp=p;",
            "\tpushup(p),pushup(p=q);",
            "}",
            "inline void rturn(Re &p){",
            "\tRe q=pl;pl=tr[q].rp,tr[q].rp=p;",
            "\tpushup(p),pushup(p=q);",
            "}",
            "inline void insert(Re &p,Re x){",
            "\tif(!p){tr[p=++o].v=x,tr[p].cnt=tr[p].size=1,tr[p].rd=rand();return;}",
            "\t++tr[p].size;",
            "\tif(x==pv)++tr[p].cnt;",
            "\telse if(x<pv){",
            "\t\tinsert(pl,x);",
            "\t\tif(tr[pl].rd<tr[p].rd)rturn(p);",
            "\t}",
            "\telse{",
            "\t\tinsert(pr,x);",
            "\t\tif(tr[pr].rd<tr[p].rd)lturn(p);",
            "\t}",
            "}",
            "inline void del(Re &p,Re x){",
            "\tif(!p)return;",
            "    if(x<pv)--tr[p].size,del(pl,x);",
            "\telse if(x>pv)--tr[p].size,del(pr,x);",
            "\telse{",
            "\t\tif(tr[p].cnt>1)--tr[p].cnt,--tr[p].size;",
            "\t\telse{",
            "\t\t\tif(pl*pr==0)p=pl+pr;",
            "\t\t\telse if(tr[pl].rd<tr[pr].rd)rturn(p),del(p,x);",
            "\t\t\telse lturn(p),del(p,x);",
            "\t\t}",
            "\t}",
            "}",
            "inline int ask_level(Re p,Re x){",
            "\tif(x==pv)return tr[pl].size+1;",
            "\telse return x<pv?ask_level(pl,x):tr[p].cnt+tr[pl].size+ask_level(pr,x);",
            "}",
            "inline int ask_v(Re p,Re x){",
            "\tif(x<=tr[pl].size)return ask_v(pl,x);",
            "\telse{",
            "\t\tRe tmp=tr[pl].size+tr[p].cnt;",
            "\t\treturn x<=tmp?pv:ask_v(pr,x-tmp);",
            "\t}",
            "}",
            "inline int ask_pri(Re p,Re x){",
            "\tif(!p)return -inf;",
            "\tif(x<=pv)return ask_pri(pl,x);",
            "\telse return max(pv,ask_pri(pr,x));",
            "}",
            "inline int ask_nex(Re p,Re x){",
            "\tif(!p)return inf;",
            "\tif(x>=pv)return ask_nex(pr,x);",
            "\telse return min(pv,ask_nex(pl,x));",
            "}",
            "int main(){",
            "\tsrand((int)time(NULL));",
            "\tin(T);",
            "\twhile(T--){",
            "\t\tin(a),in(b);",
            "\t\tif(a==1)insert(root,b);",
            "\t\tif(a==2)del(root,b);",
            "\t\tif(a==3)printf(\"%d\\n\",ask_level(root,b));",
            "\t\tif(a==4)printf(\"%d\\n\",ask_v(root,b));",
            "\t\tif(a==5)printf(\"%d\\n\",ask_pri(root,b)); ",
            "\t\tif(a==6)printf(\"%d\\n\",ask_nex(root,b));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 Treap  (有注释)"
    },
    "二逼平衡树 (无注释)": {
        "prefix": "acm-2.6树套树",
        "body": [
            "#pragma GCC optimize(2)",
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define mid (L+R>>1)",
            "#define Re register int",
            "#define pl tree[p].lp",
            "#define pr tree[p].rp",
            "#define F(i,a,b) for(Re i=a;i<=b;++i)",
            "#define lo(o) lower_bound(b+1,b+m+1,o)-b",
            "using namespace std;",
            "const int N=1e5+3,inf=2147483647;",
            "int x,y,z,n,m,T,t,fu,cnt,tl,tr,a[N],b[N],pt[N],C[N],opt[N],ptl[20],ptr[20]; ",
            "struct QAQ{int g,lp,rp;}tree[N*250];",
            "struct O_O{int l,r,k;}Q[N];",
            "struct T_T{int i,x;}c[N];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline int ask_kth(Re L,Re R,Re k){",
            "    if(L==R)return b[R];",
            "    Re tmp=0;",
            "    F(i,1,tl)tmp-=tree[tree[ptl[i]].lp].g;",
            "    F(i,1,tr)tmp+=tree[tree[ptr[i]].lp].g;",
            "    if(tmp>=k){",
            "    \tF(i,1,tl)ptl[i]=tree[ptl[i]].lp;",
            "    \tF(i,1,tr)ptr[i]=tree[ptr[i]].lp;",
            "    \treturn ask_kth(L,mid,k);",
            "    }",
            "    else{",
            "    \tF(i,1,tl)ptl[i]=tree[ptl[i]].rp;",
            "    \tF(i,1,tr)ptr[i]=tree[ptr[i]].rp;",
            "    \treturn ask_kth(mid+1,R,k-tmp);",
            "    }",
            "}",
            "inline int ask_kth_pre(Re L,Re R,Re k){",
            "    tl=tr=0;",
            "    for(Re i=L-1;i;i-=i&-i)ptl[++tl]=pt[i];",
            "    for(Re i=R;i;i-=i&-i)ptr[++tr]=pt[i];",
            "    return ask_kth(1,m,k);",
            "}",
            "inline void add(Re &p,Re L,Re R,Re w,Re v){",
            "    if(!p)p=++cnt;tree[p].g+=v;",
            "    if(L==R)return;",
            "    if(w<=mid)add(pl,L,mid,w,v);",
            "    else add(pr,mid+1,R,w,v);",
            "}",
            "inline void add_pre(Re x,Re v){",
            "    Re w=lo(a[x]); ",
            "    for(Re i=x;i<=n;i+=i&-i)add(pt[i],1,m,w,v);",
            "}",
            "inline int ask_level(Re p,Re L,Re R,Re x){",
            "\tif(L==R)return tree[p].g; ",
            "\tif(x<=mid)return ask_level(pl,L,mid,x);",
            "\telse return tree[pl].g+ask_level(pr,mid+1,R,x);",
            "}",
            "inline int ask_level_pre(Re L,Re R,Re w){",
            "\tRe ans=0;",
            "    for(Re i=R;i;i-=i&-i)ans+=ask_level(pt[i],1,m,w);",
            "    for(Re i=L-1;i;i-=i&-i)ans-=ask_level(pt[i],1,m,w);",
            "    return ans;",
            "}",
            "int main(){",
            "\tin(n),in(T),m=n;",
            "    F(i,1,n)in(a[i]),b[i]=a[i];",
            "    F(i,1,T){",
            "    \tin(opt[i]);",
            "    \tif(opt[i]==3)in(c[i].i),in(c[i].x),b[++m]=c[i].x;",
            "    \telse{",
            "    \t\tin(Q[i].l),in(Q[i].r),in(Q[i].k);",
            "    \t\tif(opt[i]!=2)b[++m]=Q[i].k;",
            "\t\t}",
            "    }",
            "    sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;",
            "    F(i,1,n)add_pre(i,1);",
            "    F(i,1,T){",
            "    \tif(opt[i]==1)Q[i].k=lo(Q[i].k),printf(\"%d\\n\",ask_level_pre(Q[i].l,Q[i].r,Q[i].k-1)+1);",
            "    \tif(opt[i]==2)printf(\"%d\\n\",ask_kth_pre(Q[i].l,Q[i].r,Q[i].k));",
            "\t\tif(opt[i]==3)add_pre(c[i].i,-1),a[c[i].i]=c[i].x,add_pre(c[i].i,1);",
            "\t\tif(opt[i]==4){",
            "\t\t\tRe level=ask_level_pre(Q[i].l,Q[i].r,lo(Q[i].k)-1);",
            "\t\t\tif(!level)printf(\"%d\\n\",-inf);",
            "\t\t\telse printf(\"%d\\n\",ask_kth_pre(Q[i].l,Q[i].r,level));",
            "\t\t}",
            "\t\tif(opt[i]==5){",
            "\t\t\tRe level=ask_level_pre(Q[i].l,Q[i].r,lo(Q[i].k));",
            "\t\t\tif(level==Q[i].r-Q[i].l+1)printf(\"%d\\n\",inf);",
            "\t\t\telse printf(\"%d\\n\",ask_kth_pre(Q[i].l,Q[i].r,level+1));",
            "\t\t}",
            "    }",
            "}",
            ""
        ],
        "description": "插入 二逼平衡树 (无注释)"
    },
    "二逼平衡树 (有注释)": {
        "prefix": "acm-2.7树套树",
        "body": [
            "#pragma GCC optimize(2)",
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define mid (L+R>>1)",
            "#define Re register int",
            "#define pl tree[p].lp",
            "#define pr tree[p].rp",
            "#define F(i,a,b) for(Re i=a;i<=b;++i)",
            "#define lo(o) lower_bound(b+1,b+m+1,o)-b",
            "using namespace std;",
            "const int N=1e5+3,inf=2147483647;",
            "int x,y,z,n,m,T,t,fu,cnt,tl,tr,a[N],b[N],pt[N],C[N],opt[N],ptl[20],ptr[20]; ",
            "struct QAQ{int g,lp,rp;}tree[N*250];",
            "struct O_O{int l,r,k;}Q[N];",
            "struct T_T{int i,x;}c[N];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline int ask_kth(Re L,Re R,Re k){",
            "    if(L==R)return b[R];",
            "    Re tmp=0;",
            "    F(i,1,tl)tmp-=tree[tree[ptl[i]].lp].g;",
            "    F(i,1,tr)tmp+=tree[tree[ptr[i]].lp].g;",
            "    if(tmp>=k){",
            "    \tF(i,1,tl)ptl[i]=tree[ptl[i]].lp;",
            "    \tF(i,1,tr)ptr[i]=tree[ptr[i]].lp;",
            "    \treturn ask_kth(L,mid,k);",
            "    }",
            "    else{",
            "    \tF(i,1,tl)ptl[i]=tree[ptl[i]].rp;",
            "    \tF(i,1,tr)ptr[i]=tree[ptr[i]].rp;",
            "    \treturn ask_kth(mid+1,R,k-tmp);",
            "    }",
            "}",
            "inline int ask_kth_pre(Re L,Re R,Re k){",
            "    tl=tr=0;",
            "    for(Re i=L-1;i;i-=i&-i)ptl[++tl]=pt[i];",
            "    for(Re i=R;i;i-=i&-i)ptr[++tr]=pt[i];",
            "    return ask_kth(1,m,k);",
            "}",
            "inline void add(Re &p,Re L,Re R,Re w,Re v){",
            "    if(!p)p=++cnt;tree[p].g+=v;",
            "    if(L==R)return;",
            "    if(w<=mid)add(pl,L,mid,w,v);",
            "    else add(pr,mid+1,R,w,v);",
            "}",
            "inline void add_pre(Re x,Re v){",
            "    Re w=lo(a[x]);",
            "    for(Re i=x;i<=n;i+=i&-i)add(pt[i],1,m,w,v);",
            "}",
            "inline int ask_level(Re p,Re L,Re R,Re x){",
            "\tif(L==R)return tree[p].g; ",
            "\tif(x<=mid)return ask_level(pl,L,mid,x);",
            "\telse return tree[pl].g+ask_level(pr,mid+1,R,x);",
            "}",
            "inline int ask_level_pre(Re L,Re R,Re w){",
            "\tRe ans=0;",
            "    for(Re i=R;i;i-=i&-i)ans+=ask_level(pt[i],1,m,w);",
            "    for(Re i=L-1;i;i-=i&-i)ans-=ask_level(pt[i],1,m,w);",
            "    return ans;",
            "}",
            "int main(){",
            "//\tprintf(\"%lf\\n\",(sizeof(tree))/1024.0/1024.0);",
            "//\tprintf(\"%lf\\n\",(sizeof(tree)+sizeof(Q)+sizeof(c)+sizeof(a)+sizeof(b)+sizeof(pt)+sizeof(C))/1024.0/1024.0);",
            "\tin(n),in(T),m=n;",
            "    F(i,1,n)in(a[i]),b[i]=a[i];",
            "    F(i,1,T){",
            "    \tin(opt[i]);",
            "    \tif(opt[i]==3)in(c[i].i),in(c[i].x),b[++m]=c[i].x;",
            "    \telse{",
            "    \t\tin(Q[i].l),in(Q[i].r),in(Q[i].k);",
            "    \t\tif(opt[i]!=2)b[++m]=Q[i].k;",
            "\t\t}",
            "    }",
            "    sort(b+1,b+m+1);",
            "    m=unique(b+1,b+m+1)-b-1;",
            "    F(i,1,n)add_pre(i,1);",
            "    F(i,1,T){",
            "    \tif(opt[i]==1)",
            "    \t\tQ[i].k=lo(Q[i].k),",
            "\t\t\tprintf(\"%d\\n\",ask_level_pre(Q[i].l,Q[i].r,Q[i].k-1)+1);",
            "",
            "    \tif(opt[i]==2)",
            "    \t\tprintf(\"%d\\n\",ask_kth_pre(Q[i].l,Q[i].r,Q[i].k));",
            "",
            "\t\tif(opt[i]==3)",
            "\t\t\tadd_pre(c[i].i,-1),a[c[i].i]=c[i].x,add_pre(c[i].i,1);",
            "",
            "\t\tif(opt[i]==4){",
            "\t\t}",
            "",
            "\t\tif(opt[i]==5){",
            "\t\t}",
            "    }",
            "}",
            ""
        ],
        "description": "插入 二逼平衡树 (有注释)"
    },
    "普通平衡树": {
        "prefix": "acm-2.6线段树",
        "body": [
            "#pragma GCC optimize(2)",
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define mid (L+R>>1)",
            "#define Re register int",
            "#define pl tree[p].lp",
            "#define pr tree[p].rp",
            "#define F(i,a,b) for(Re i=a;i<=b;++i)",
            "#define lo(o) lower_bound(b+1,b+m+1,o)-b",
            "using namespace std;",
            "const int N=1e5+3,inf=2147483647;",
            "int m,T,t,fu,cnt,root,a[N],b[N],Q[N],opt[N]; ",
            "struct QAQ{int g,lp,rp;}tree[N<<1];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline int ask_kth(Re p,Re L,Re R,Re k){",
            "\tif(L==R)return b[R];",
            "    Re tmp=tree[pl].g;",
            "    if(tmp>=k)return ask_kth(pl,L,mid,k);",
            "    else return ask_kth(pr,mid+1,R,k-tmp);",
            "}",
            "inline void add(Re &p,Re L,Re R,Re w,Re v){",
            "    if(!p)p=++cnt;tree[p].g+=v;",
            "    if(L==R)return;",
            "    if(w<=mid)add(pl,L,mid,w,v);",
            "    else add(pr,mid+1,R,w,v);",
            "}",
            "inline int ask_level(Re p,Re L,Re R,Re x){",
            "\tif(!x)return 0;",
            "\tif(L==R)return tree[p].g;",
            "\tif(x<=mid)return ask_level(pl,L,mid,x);",
            "\telse return tree[pl].g+ask_level(pr,mid+1,R,x);",
            "}",
            "int main(){",
            "\tin(T); ",
            "    F(i,1,T){",
            "    \tin(opt[i]),in(Q[i]);",
            "    \tif(opt[i]!=4)b[++m]=Q[i];",
            "    }",
            "    sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;",
            "    F(i,1,T){",
            "    \tif(opt[i]==1)add(root,1,m,lo(Q[i]),1);",
            "    \tif(opt[i]==2)add(root,1,m,lo(Q[i]),-1);",
            "\t\tif(opt[i]==3)printf(\"%d\\n\",ask_level(root,1,m,lo(Q[i])-1)+1);",
            "\t\tif(opt[i]==4)printf(\"%d\\n\",ask_kth(root,1,m,Q[i]));",
            "\t\tif(opt[i]==5){",
            "\t\t\tRe level=ask_level(root,1,m,lo(Q[i])-1);",
            "\t\t\tprintf(\"%d\\n\",ask_kth(root,1,m,level));",
            "\t\t}",
            "\t\tif(opt[i]==6){",
            "\t\t\tRe level=ask_level(root,1,m,lo(Q[i]));",
            "\t\t\tprintf(\"%d\\n\",ask_kth(root,1,m,level+1));",
            "\t\t}",
            "    }",
            "}",
            ""
        ],
        "description": "插入 普通平衡树"
    },
    "营业额统计": {
        "prefix": "acm-2.7Treap",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm> ",
            "#include<cstdlib> ",
            "#include<cstdio>",
            "#include<ctime>",
            "#define Re register int",
            "#define pl tr[p].lp",
            "#define pr tr[p].rp",
            "#define pv tr[p].v",
            "using namespace std;",
            "const int N=32780,inf=2e9;",
            "int a,o,T,ans,root;",
            "inline void in(Re &x){",
            "    int fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct Treap{int v,rd,lp,rp,cnt,size;}tr[N];",
            "inline void pushup(Re p){tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}",
            "inline void lturn(Re &p){",
            "\tRe q=pr;pr=tr[q].lp,tr[q].lp=p;",
            "\tpushup(p),pushup(p=q);",
            "}",
            "inline void rturn(Re &p){",
            "\tRe q=pl;pl=tr[q].rp,tr[q].rp=p;",
            "\tpushup(p),pushup(p=q);",
            "}",
            "inline void insert(Re &p,Re x){",
            "\tif(!p){tr[p=++o].v=x,tr[p].cnt=tr[p].size=1,tr[p].rd=rand();return;}",
            "\t++tr[p].size;",
            "\tif(x==pv)++tr[p].cnt;",
            "\telse if(x<pv){",
            "\t\tinsert(pl,x);",
            "\t\tif(tr[pl].rd<tr[p].rd)rturn(p);",
            "\t}",
            "\telse{",
            "\t\tinsert(pr,x);",
            "\t\tif(tr[pr].rd<tr[p].rd)lturn(p);",
            "\t}",
            "}",
            "inline int ask_pri(Re p,Re x){",
            "\tif(!p)return -inf;",
            "\tif(x==pv)return x;",
            "\telse if(x<pv)return ask_pri(pl,x);",
            "\telse return max(pv,ask_pri(pr,x));",
            "}",
            "inline int ask_nex(Re p,Re x){",
            "\tif(!p)return inf;",
            "\tif(x==pv)return x;",
            "\telse if(x>pv)return ask_nex(pr,x);",
            "\telse return min(pv,ask_nex(pl,x));",
            "}",
            "int main(){",
            "\tsrand((int)time(NULL));",
            "\tin(T);--T;in(a);ans=a;insert(root,a);",
            "\twhile(T--){",
            "\t\tin(a);",
            "\t\tans+=min(abs(a-ask_pri(root,a)),abs(a-ask_nex(root,a)));",
            "\t\tinsert(root,a);",
            "\t}",
            "\tprintf(\"%d\",ans);",
            "}",
            ""
        ],
        "description": "插入 营业额统计"
    },
    "信息传递": {
        "prefix": "acm-2.4并查集实战",
        "body": [
            "#include<cstdio>",
            "#include<iostream> ",
            "using namespace std;// 找图的最小环 ",
            "int minn=0x7fffff,n,f[200005],d[200005];",
            "inline int min(int a,int b){if(a>b) return b;else return a;}",
            "",
            "inline int find(int x){",
            "\tif(f[x]!=x){",
            "\t\tint l=f[x];",
            "\t\tf[x]=find(f[x]);",
            "\t\td[x]+=d[l];",
            "\t}",
            "\treturn f[x];",
            "}",
            "",
            "inline void sakura(int a,int b){",
            "\tint aa=find(a);int bb=find(b);",
            "\tif(aa!=bb){",
            "\t\tf[aa]=bb;",
            "\t\td[a]=d[b]+1;",
            "\t}",
            "\telse",
            "\t\tminn=min(minn,d[a]+d[b]+1);",
            "}",
            "",
            "int main(){",
            "\tscanf(\"%d\",&n);",
            "\tfor(int i=1;i<=n;i++) f[i]=i;",
            "\tfor(int i=1;i<=n;i++){",
            "\t\tint x;",
            "\t\tscanf(\"%d\",&x);",
            "\t\tsakura(i,x);",
            "\t}",
            "\tprintf(\"%d\",minn);",
            "\treturn 0;",
            "}",
            "",
            ""
        ],
        "description": "插入 信息传递"
    },
    "打击罪犯": {
        "prefix": "acm-2.4并查集实战",
        "body": [
            "#include<cstdio>",
            "#include<cstring>",
            "#include<iostream>",
            "using namespace std;",
            "int fa[1001],n,k;",
            "struct sakura{int u,v,next;}sak[4001];",
            "int st[1001],tot=0;",
            "int p[1001],pp[1001];",
            "",
            "void add(int x,int y){",
            "    tot++;",
            "    sak[tot].u=x;",
            "    sak[tot].v=y;",
            "    sak[tot].next=st[x];",
            "    st[x]=tot;",
            "}",
            "",
            "int find(int x){",
            "    if (fa[x]!=x)",
            "       fa[x]=find(fa[x]);",
            "    return fa[x];",
            "}",
            "",
            "void unionn(int r1,int r2){",
            "    fa[r1]=r2;",
            "}",
            "",
            "void doit(){",
            "    int i,j;",
            "    for (i=n-1;i>=1;i--){",
            "    \tpp[i]=1;",
            "        for (j=st[i];j;j=sak[j].next){",
            "            if (pp[sak[j].v]){",
            "               \tint r1=find(sak[j].u);",
            "               \tint r2=find(sak[j].v);",
            "               \tif (r1!=r2){",
            "                  \tunionn(r1,r2);",
            "                  \tp[r1]+=p[r2]; ",
            "                  \tp[r2]=p[r1];",
            "            \t}",
            "            }",
            "        }",
            "        if (p[find(i)]>(n+1)/2){",
            "            printf(\"%d\",i);",
            "        }",
            "    }",
            "}",
            "",
            "int main(){",
            "    scanf(\"%d\",&n);",
            "    pp[n]=1;",
            "    for (int i=1;i<=n;i++){",
            "        scanf(\"%d\",&k);",
            "        fa[i]=i;",
            "        p[i]=1; ",
            "        for (int j=1;j<=k;j++){",
            "            int x;",
            "            scanf(\"%d\",&x);",
            "            add(i,x);",
            "        }",
            "    }",
            "    doit();",
            "    return 0;",
            "}",
            ""
        ],
        "description": "插入 打击罪犯"
    },
    "格子游戏": {
        "prefix": "acm-2.4二维并查集",
        "body": [
            "#include<bits/stdc++.h>",
            "using namespace std;",
            "struct T{int x,y;}f[210][210];",
            "int x,y,n,m;char c;T a1,a2;",
            "T s(int x,int y){",
            "    while((x==f[x][y].x)&&(y==f[x][y].y))return f[x][y];",
            "    return s(f[x][y].x,f[x][y].y);",
            "}",
            "int main(){",
            "    scanf(\"%d%d\",&n,&m);",
            "    for(int i=1;i<=n;i++)",
            "        for(int j=1;j<=n;j++)",
            "            f[i][j].x=i,f[i][j].y=j;",
            "    for(int i=1;i<=m;i++)",
            "    {",
            "        cin>>x>>y>>c;",
            "        if(c=='D')a1=s(x,y),a2=s(x+1,y);",
            "        else a1=s(x,y),a2=s(x,y+1);",
            "        if(a1.x==a2.x&&a1.y==a2.y){",
            "            printf(\"%d\\n\",i);return 0;",
            "        }",
            "        else f[a2.x][a2.y]=a1;",
            "    }",
            "    printf(\"draw\");",
            "    return 0;",
            "}",
            ""
        ],
        "description": "插入 格子游戏"
    },
    "繁忙的都市": {
        "prefix": "acm-2.4并查集+生成树",
        "body": [
            "/*",
            "            ���� ",
            "           |   | ",
            "           |   | ",
            "           |   | ",
            "      ������     ������ ",
            "    |  ����ACʮ�ּ�   | ",
            "     ������      ������ ",
            "           |   | ",
            "           |   | ",
            "           |   | ",
            "            ���� ",
            "*/",
            "//#include<bits/stdc++.h>",
            "#include<cstdio>",
            "#include<cstdlib>",
            "#include<iostream>",
            "#include<algorithm>",
            "int n,m,k,f[40001],sum;",
            "struct sakura{",
            "\tint p,a,b,val;",
            "}sak[40001];",
            "inline int find(int x){return f[x]==x?x:find(f[x]);}",
            "inline bool cmp(const sakura &a,const sakura &b){return a.val<b.val;}",
            "inline bool unions(int x,int y){",
            "\tint fx=find(x),fy=find(y);",
            "\tif(fx==fy) return 0;",
            "\telse f[fy]=fx;",
            "\treturn 1;",
            "}",
            "int main(){",
            "\tscanf(\"%d%d\",&n,&m);",
            "\tfor(int i=1;i<=n;i++) f[i]=i;",
            "\tfor(int i=1;i<=m;i++)",
            "\t\tscanf(\"%d%d%d\",&sak[i].a,&sak[i].b,&sak[i].val);",
            "\tstd::sort(sak+1,sak+1+m,cmp);",
            "\tfor(int i=1;i<=m;i++){",
            "\t\tif(unions(sak[i].a,sak[i].b)){",
            "\t\t\tk++;",
            "\t\t\tsum=sak[i].val;",
            "\t\t}",
            "\t\tif(k==n-1) break;",
            "\t}",
            "\tprintf(\"%d %d\",n-1,sum);",
            "\treturn 0;",
            "} ",
            ""
        ],
        "description": "插入 繁忙的都市"
    },
    "联络员": {
        "prefix": "acm-2.4sort+并查集",
        "body": [
            "#include<algorithm>",
            "#include<cstdlib>",
            "#include<cstdio>",
            "int g,i,j,n,m,p,x,y,c,ans,k,f[2010];",
            "struct QAQ{int l,r,w;}a[40010];",
            "inline int fi(int x){if(x!=f[x])f[x]=fi(f[x]);return f[x];}",
            "inline int cmp(const QAQ &a,const QAQ &b){return a.w<b.w;}",
            "int main(){",
            "    scanf(\"%d%d\",&n,&m);",
            "    for(i=1;i<=n;i++)f[i]=i;",
            "    for(i=1;i<=m;i++){",
            "        scanf(\"%d%d%d%d\",&p,&x,&y,&c);",
            "        if(p==1){ans+=c,f[fi(y)]=fi(x);}",
            "        else a[++g].l=x,a[g].r=y,a[g].w=c;",
            "    }",
            "    std::sort(a+1,a+g+1,cmp);",
            "    for(i=1;i<=g;i++){",
            "        x=fi(a[i].l),y=fi(a[i].r);",
            "        if(x!=y){",
            "            f[y]=x;k++;",
            "            ans+=a[i].w;",
            "        }",
            "    }",
            "    printf(\"%d\",ans);",
            "    return 0;",
            "}",
            ""
        ],
        "description": "插入 联络员"
    },
    "一维：区间修改，区间查询": {
        "prefix": "acm-2.5add",
        "body": [
            "/*",
            "            n        n",
            "S[x]= (x+1)*��A[i] - ��i*A[i]",
            "           i=1      i=1",
            "*/",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "const int N=1e6+3;",
            "int n,x,y,z,T,op;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct BIT{",
            "    LL C1[N],C2[N];",
            "    inline void add(Re x,Re v){Re i=x;while(i<=n)C1[i]+=v,C2[i]+=(LL)x*v,i+=i&-i;}",
            "    inline void add(Re L,Re R,Re v){add(L,v),add(R+1,-v);}",
            "    inline LL ask(Re x){Re i=x;LL ans=0;while(i)ans+=(x+1)*C1[i]-C2[i],i-=i&-i;return ans;}",
            "    inline LL ask(Re L,Re R){return ask(R)-ask(L-1);}",
            "}TR;",
            "int main(){",
            "    in(n),in(T);",
            "    for(Re i=1;i<=n;++i)in(x),TR.add(i,i,x);",
            "    while(T--){",
            "        in(op),in(x),in(y);",
            "        if(op<2)in(z),TR.add(x,y,z);",
            "        else printf(\"%lld\\n\",TR.ask(x,y));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 一维：区间修改，区间查询"
    },
    "一维：区间修改，单点查询": {
        "prefix": "acm-2.5add",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "const int N=5e5+3;",
            "int n,x,y,z,T,op;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct BIT{",
            "    LL C[N];",
            "    inline void add(Re x,Re v){while(x<=n)C[x]+=v,x+=x&-x;}",
            "    inline void add(Re L,Re R,Re v){add(L,v),add(R+1,-v);}",
            "    inline LL ask(Re x){LL ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}",
            "}TR;",
            "int main(){",
            "    in(n),in(T);",
            "    for(Re i=1;i<=n;++i)in(x),TR.add(i,i,x);",
            "    while(T--){",
            "        in(op),in(x);",
            "        if(op<2)in(y),in(z),TR.add(x,y,z);",
            "        else printf(\"%lld\\n\",TR.ask(x));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 一维：区间修改，单点查询"
    },
    "一维：单点修改，区间查询": {
        "prefix": "acm-2.5add",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "const int N=5e5+3;",
            "int n,x,y,T,op;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct BIT{",
            "    LL C[N];",
            "    inline void add(Re x,Re v){while(x<=n)C[x]+=v,x+=x&-x;}",
            "    inline LL ask(Re x){LL ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}",
            "    inline LL ask(Re L,Re R){return ask(R)-ask(L-1);}",
            "}TR;",
            "int main(){",
            "    in(n),in(T);",
            "    for(Re i=1;i<=n;++i)in(x),TR.add(i,x);",
            "    while(T--){",
            "        in(op),in(x),in(y);",
            "        if(op<2)TR.add(x,y);",
            "        else printf(\"%ld\\n\",TR.ask(x,y));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 一维：单点修改，区间查询"
    },
    "二维：区间修改，区间查询": {
        "prefix": "acm-2.5add",
        "body": [
            "/*",
            "                    n   m                 n   m                   n   m             n   m",
            "s[x][y]=(x+1)*(y+1)*��  ��a[i][j] - (y+1)*��  ��a[i][j]*i - (x+1)*��  ��a[i][j]*j + ��  ��a[i][j]*i*j",
            "                   i=1 j=1               i=1 j=1                 i=1 j=1           i=1 j=1",
            "*/",
            "#include<cstdio>",
            "#define y1 yyyy",
            "#define LL long long",
            "#define Re register int",
            "const int N=2048+3;",
            "int n,m,x,x1,y1,x2,y2,op;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct BIT{",
            "    LL C1[N][N],C2[N][N],C3[N][N],C4[N][N];",
            "    inline void add(Re x,Re y,Re v){",
            "        Re i=x;",
            "        while(i<=n){",
            "            Re j=y;",
            "            while(j<=m)C1[i][j]+=v,C2[i][j]+=(LL)x*v,C3[i][j]+=(LL)y*v,C4[i][j]+=(LL)x*y*v,j+=j&-j;",
            "            i+=i&-i;",
            "        }",
            "    }",
            "    inline void add(Re x1,Re y1,Re x2,Re y2,Re z){",
            "        add(x1,y1,z),add(x1,y2+1,-z),add(x2+1,y1,-z),add(x2+1,y2+1,z);",
            "    }",
            "    inline LL ask(Re x,Re y){",
            "        Re i=x;LL ans=0;",
            "        while(i){",
            "            Re j=y;",
            "            while(j)ans+=(LL)(x+1)*(y+1)*C1[i][j]-(LL)(y+1)*C2[i][j]-(LL)(x+1)*C3[i][j]+C4[i][j],j-=j&-j;",
            "            i-=i&-i;",
            "        }",
            "        return ans;",
            "    }",
            "    inline LL ask(Re x1,Re y1,Re x2,Re y2){",
            "        return ask(x2,y2)-ask(x2,y1-1)-ask(x1-1,y2)+ask(x1-1,y1-1);",
            "    }",
            "}TR;",
            "int main(){",
            "    in(n),in(m);",
            "    while(~scanf(\"%d\",&op)){",
            "        in(x1),in(y1),in(x2),in(y2);",
            "        if(op<2)in(x),TR.add(x1,y1,x2,y2,x);",
            "        else printf(\"%lld\\n\",TR.ask(x1,y1,x2,y2));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 二维：区间修改，区间查询"
    },
    "二维：区间修改，单点查询": {
        "prefix": "acm-2.5add",
        "body": [
            "/*",
            "(样例输入)",
            "输入：",
            "2 3 8",
            "1 1 2 2 3 2",
            "1 1 1 2 2 -3",
            "2 1 1 ",
            "2 1 2 ",
            "2 1 3",
            "2 2 1",
            "2 2 2",
            "2 2 3",
            "",
            "输出",
            "-3",
            "-1",
            "2",
            "-3",
            "-1",
            "2",
            "*/",
            "#include<cstdio>",
            "#define y1 yyyy",
            "#define LL long long",
            "#define Re register int",
            "const int N=4096+3;",
            "int n,m,T,x,x1,y1,x2,y2,op;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct BIT{",
            "    LL C[N][N];",
            "    inline void add(Re x,Re y,Re v){",
            "        while(x<=n){Re j=y;while(j<=m)C[x][j]+=v,j+=j&-j;x+=x&-x;}",
            "    }",
            "    inline void add(Re x1,Re y1,Re x2,Re y2,Re z){",
            "        add(x1,y1,z),add(x1,y2+1,-z),add(x2+1,y1,-z),add(x2+1,y2+1,z);",
            "    }",
            "    inline LL ask(Re x,Re y){",
            "        LL ans=0;",
            "        while(x){Re j=y;while(j)ans+=C[x][j],j-=j&-j;x-=x&-x;}",
            "        return ans;",
            "    }",
            "}TR;",
            "int main(){",
            "    in(n),in(m),in(T);",
            "    while(T--){",
            "        in(op),in(x1),in(y1);",
            "        if(op<2)in(x2),in(y2),in(x),TR.add(x1,y1,x2,y2,x);",
            "        else printf(\"%lld\\n\",TR.ask(x1,y1));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 二维：区间修改，单点查询"
    },
    "二维：单点修改，区间查询": {
        "prefix": "acm-2.5add",
        "body": [
            "#include<cstdio>",
            "#define y1 yyyy",
            "#define LL long long",
            "#define Re register int",
            "const int N=4096+3;",
            "int n,m,x1,y1,x2,y2,op;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct BIT{",
            "    LL C[N][N];",
            "    inline void add(Re x,Re y,Re v){",
            "        while(x<=n){Re j=y;while(j<=m)C[x][j]+=v,j+=j&-j;x+=x&-x;}",
            "    }",
            "    inline LL ask(Re x,Re y){",
            "        LL ans=0;",
            "        while(x){Re j=y;while(j)ans+=C[x][j],j-=j&-j;x-=x&-x;}",
            "        return ans;",
            "    }",
            "    inline LL ask(Re x1,Re y1,Re x2,Re y2){return ask(x2,y2)-ask(x2,y1-1)-ask(x1-1,y2)+ask(x1-1,y1-1);}",
            "}TR;",
            "int main(){",
            "    in(n),in(m);",
            "    while(~scanf(\"%d\",&op)){",
            "        in(x1),in(y1),in(x2);",
            "        if(op<2)TR.add(x1,y1,x2);",
            "        else in(y2),printf(\"%lld\\n\",TR.ask(x1,y1,x2,y2));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 二维：单点修改，区间查询"
    },
    "单点修改 ，区间查询 (Max)": {
        "prefix": "acm-2.5取Max",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "const int N=1e5+3;",
            "int n,x,y,T,A[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char ch=getchar();",
            "    while(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();",
            "    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int max(Re a,Re b){return a>b?a:b;}",
            "struct BIT{",
            "    int C[N];",
            "    inline void add(Re x,Re v){while(x<=n)C[x]=max(C[x],v),x+=x&-x;}",
            "    inline int ask(Re l,Re r){",
            "        Re ans=0;",
            "        while(l<=r){",
            "            while(r-(r&-r)>=l)ans=max(ans,C[r]),r-=r&-r;",
            "            ans=max(ans,A[r--]);",
            "        }",
            "        return ans;",
            "    }",
            "}TR;",
            "int main(){",
            "    in(n),in(T);",
            "    for(Re i=1;i<=n;++i)in(A[i]),TR.add(i,A[i]);",
            "    while(T--)in(x),in(y),printf(\"%d\\n\",TR.ask(x,y));",
            "}",
            ""
        ],
        "description": "插入 单点修改 ，区间查询 (Max)"
    },
    "珂朵莉树": {
        "prefix": "acm-2.10optimize",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<vector>",
            "#include<set>",
            "#define LL long long",
            "#define Re register int",
            "#define IT set<QAQ>::iterator",
            "using namespace std;",
            "const int N=1e5+5;",
            "struct QAQ{",
            "\tint l,r;mutable LL v;",
            "\tQAQ(int L,int R=-1,LL V=0):l(L),r(R),v(V){}",
            "\tbool operator<(QAQ o)const{return l<o.l;}",
            "};",
            "int l,r,x,y,n,m,fu,op,seed,vmax,a[N];set<QAQ>s;",
            "inline int rnd(){",
            "    Re tmp=seed;",
            "    seed=((LL)seed*7+13)%1000000007;",
            "    return tmp;",
            "}",
            "inline LL mi(LL a,LL k,LL P){",
            "\tLL ans=1;a%=P;",
            "\twhile(k){",
            "\t\tif(k&1)(ans*=a)%=P;",
            "\t\t(a*=a)%=P,k>>=1;",
            "\t}",
            "\treturn ans;",
            "}",
            "inline IT split(Re w){",
            "\tIT it=s.lower_bound(QAQ(w));",
            "\tif(it!=s.end()&&it->l==w)return it;",
            "\t--it;",
            "\tRe L=it->l,R=it->r;LL V=it->v;",
            "\ts.erase(it);",
            "\ts.insert(QAQ(L,w-1,V));",
            "\treturn s.insert(QAQ(w,R,V)).first;",
            "}",
            "inline void assign(Re l,Re r,LL v){",
            "\tIT itr=split(r+1),itl=split(l);",
            "\ts.erase(itl,itr),s.insert(QAQ(l,r,v));",
            "}",
            "inline void add(Re l,Re r,LL v){",
            "\tIT itr=split(r+1),itl=split(l);",
            "\twhile(itl!=itr)itl->v+=v,++itl;",
            "}",
            "inline LL mi_sum(Re l,Re r,Re k,Re P){",
            "\tIT itr=split(r+1),itl=split(l);LL ans=0;",
            "\twhile(itl!=itr)(ans+=(LL)(itl->r-itl->l+1)%P*mi(itl->v,(LL)k,(LL)P)%P)%=P,++itl;",
            "\treturn ans;",
            "}",
            "inline LL ask_k(Re l,Re r,Re k){",
            "\tIT itr=split(r+1),itl=split(l);",
            "\tvector<pair<LL,int> >Q;",
            "\tQ.clear();",
            "\twhile(itl!=itr)Q.push_back(pair<LL,int>(itl->v,itl->r-itl->l+1)),++itl;",
            "\tsort(Q.begin(),Q.end());",
            "\tfor(vector<pair<LL,int> >::iterator it=Q.begin();it!=Q.end();++it){",
            "\t\tk-=it->second;",
            "\t\tif(k<=0)return it->first;",
            "\t}",
            "}",
            "int main(){",
            "\tscanf(\"%d%d%d%d\",&n,&m,&seed,&vmax);",
            "\tfor(Re i=1;i<=n;++i)a[i]=(rnd()%vmax)+1,s.insert(QAQ(i,i,a[i]));",
            "\ts.insert(QAQ(n+1,n+1,0));",
            "\twhile(m--){",
            "\t    op=(rnd()%4)+1,l=(rnd()%n)+1,r=(rnd()%n)+1;",
            "\t    if(l>r)swap(l,r);",
            "\t    if(op==3)x=(rnd()%(r-l+1))+1;",
            "\t    else x=(rnd()%vmax)+1;",
            "\t    if(op==4)y=(rnd()%vmax)+1;",
            "\t    ",
            "\t    if(op<2)add(l,r,(LL)x);",
            "\t\telse if(op<3)assign(l,r,(LL)x);",
            "\t\telse if(op<4)printf(\"%lld\\n\",ask_k(l,r,x));",
            "\t\telse printf(\"%lld\\n\",mi_sum(l,r,x,y));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 珂朵莉树"
    },
    "序列操作": {
        "prefix": "acm-2.10P2572",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<vector>",
            "#include<set>",
            "#define Re register int",
            "#define IT set<QAQ>::iterator",
            "using namespace std;",
            "const int N=1e5+5;",
            "struct QAQ{",
            "    int l,r;mutable int v;",
            "    QAQ(Re L,Re R=-1,Re V=0):l(L),r(R),v(V){}",
            "    bool operator<(QAQ o)const{return l<o.l;}",
            "};",
            "int x,y,n,m,fu,op;set<QAQ>s;",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    if(fu)x=-x;",
            "}",
            "inline IT split(Re w){",
            "    IT it=s.lower_bound(QAQ(w));",
            "    if(it!=s.end()&&it->l==w)return it;",
            "    --it;",
            "    Re L=it->l,R=it->r,V=it->v;",
            "    s.erase(it);",
            "    s.insert(QAQ(L,w-1,V));",
            "    return s.insert(QAQ(w,R,V)).first;",
            "}",
            "inline void assign(Re l,Re r,Re v){",
            "    IT itr=split(r+1),itl=split(l);",
            "    s.erase(itl,itr),s.insert(QAQ(l,r,v));",
            "}",
            "inline int count1(Re l,Re r){",
            "\tIT itr=split(r+1),itl=split(l);Re ans=0;",
            "\twhile(itl!=itr)ans+=itl->v*(itl->r-itl->l+1),++itl;",
            "\treturn ans;",
            "}",
            "inline int ask1(Re l,Re r){",
            "\tIT itr=split(r+1),itl=split(l);Re tmp=0,ans=0;",
            "\twhile(itl!=itr){",
            "\t\tif(itl->v)tmp+=itl->r-itl->l+1;",
            "\t\telse ans=max(ans,tmp),tmp=0;",
            "\t\t++itl;",
            "\t}",
            "\treturn max(ans,tmp);",
            "}",
            "inline void inverse(Re l,Re r){",
            "\tIT itr=split(r+1),itl=split(l);",
            "\twhile(itl!=itr)itl->v^=1,++itl;",
            "}",
            "int main(){",
            "    in(n),in(m);",
            "    for(Re i=1;i<=n;++i)in(x),s.insert(QAQ(i,i,x));",
            "    s.insert(QAQ(n+1,n+1,-1));",
            "    while(m--){",
            "        in(op),in(x),in(y);++x,++y;",
            "        if(!op)assign(x,y,0);",
            "        else if(op<2)assign(x,y,1);",
            "        else if(op<3)inverse(x,y);",
            "        else if(op<4)printf(\"%d\\n\",count1(x,y));",
            "        else printf(\"%d\\n\",ask1(x,y));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 序列操作"
    },
    "脑洞治疗仪": {
        "prefix": "acm-2.10optimize",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<vector>",
            "#include<set>",
            "#define Re register int",
            "#define IT set<QAQ>::iterator",
            "using namespace std;",
            "const int N=2e5+5;",
            "struct QAQ{",
            "    int l,r;mutable int v;",
            "    QAQ(Re L,Re R=-1,Re V=0):l(L),r(R),v(V){}",
            "    bool operator<(QAQ o)const{return l<o.l;}",
            "};",
            "int x,y,xx,yy,n,m,fu,op;set<QAQ>s;",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    if(fu)x=-x;",
            "}",
            "inline IT split(Re w){",
            "    IT it=s.lower_bound(QAQ(w));",
            "    if(it!=s.end()&&it->l==w)return it;",
            "    --it;",
            "    Re L=it->l,R=it->r,V=it->v;",
            "    s.erase(it);",
            "    s.insert(QAQ(L,w-1,V));",
            "    return s.insert(QAQ(w,R,V)).first;",
            "}",
            "inline void assign(Re l,Re r,Re v){",
            "    IT itr=split(r+1),itl=split(l);",
            "    s.erase(itl,itr),s.insert(QAQ(l,r,v));",
            "}",
            "inline int ask1(Re l,Re r){",
            "\tIT itr=split(r+1),itl=split(l);Re tmp=0,ans=0;",
            "\twhile(itl!=itr){",
            "\t\tif(!itl->v)tmp+=itl->r-itl->l+1;",
            "\t\telse ans=max(ans,tmp),tmp=0;",
            "\t\t++itl;",
            "\t}",
            "\treturn max(ans,tmp);",
            "}",
            "inline void scure(Re l,Re r,Re a,Re b){",
            "\tIT itr=split(r+1),itl=split(l),it=itl;Re t=0;",
            "\twhile(it!=itr)t+=it->v*(it->r-it->l+1),++it;",
            "\ts.erase(itl,itr),s.insert(QAQ(l,r,0));",
            "\tif(!t)return;",
            "\titr=split(b+1),itl=split(a);",
            "\tif(t>=b-a+1){s.erase(itl,itr),s.insert(QAQ(a,b,1));return;}",
            "\tfor(;itl!=itr;++itl)",
            "\t\tif(!itl->v){",
            "\t\t\tt-=itl->r-itl->l+1;",
            "\t\t\tif(t<0){assign(itl->l,itl->r+t,1);break;}",
            "\t\t\telse itl->v=1;",
            "\t\t}",
            "}",
            "int main(){",
            "    in(n),in(m);",
            "    s.insert(QAQ(1,n,1));",
            "    while(m--){",
            "        in(op),in(x),in(y);",
            "        if(!op)assign(x,y,0);",
            "        else if(op<2)in(xx),in(yy),scure(x,y,xx,yy);",
            "        else printf(\"%d\\n\",ask1(x,y));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 脑洞治疗仪"
    },
    "Escape Through Leaf": {
        "prefix": "acm-2.6超哥线段树+线段树合并",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "int n,m,x,y,o,cnt,k[N],A[N],B[N],pt[N],head[N];LL b[N],dp[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Segment_Tree{",
            "\t#define pl tr[p].lp",
            "\t#define pr tr[p].rp",
            "\t#define mid ((L+R)>>1)",
            "\tint O;",
            "\tstruct QAQ{int id,lp,rp;}tr[N*18*2*2];",
            "\tinline LL y(Re id,Re x){return (LL)k[id]*x+b[id];}",
            "\tinline void change(Re &p,Re L,Re R,Re id){",
            "\t\tif(!p){tr[p=++O].id=id;return;}",
            "\t\tif(L==R){if(y(id,L)<y(tr[p].id,L))tr[p].id=id;return;}",
            "\t\tif(k[id]>k[tr[p].id]){",
            "\t\t\tif(y(id,mid)<y(tr[p].id,mid))change(pr,mid+1,R,tr[p].id),tr[p].id=id;",
            "\t\t\telse change(pl,L,mid,id);",
            "\t\t}",
            "\t\telse{",
            "\t\t\tif(y(id,mid)<y(tr[p].id,mid))change(pl,L,mid,tr[p].id),tr[p].id=id;",
            "\t\t\telse change(pr,mid+1,R,id);",
            "\t\t}",
            "\t}",
            "\tinline LL ask(Re p,Re L,Re R,Re x){",
            "\t\tif(!p)return 1e18;",
            "\t\tif(L==R)return y(tr[p].id,x);",
            "\t\tLL ans=y(tr[p].id,x);",
            "\t\tif(x<=mid)return min(ans,ask(pl,L,mid,x));",
            "\t\telse return min(ans,ask(pr,mid+1,R,x));",
            "\t}",
            "\tinline int merge(Re p,Re q,Re L,Re R){",
            "\t\tif(!p||!q)return p+q;",
            "\t\tif(L==R){if(y(tr[p].id,L)>y(tr[q].id,L))tr[p].id=tr[q].id;return p;}",
            "\t\tpl=merge(pl,tr[q].lp,L,mid);",
            "\t\tpr=merge(pr,tr[q].rp,mid+1,R);",
            "\t\tchange(p,L,R,tr[q].id);",
            "\t\treturn p;",
            "\t}",
            "}TR;",
            "inline void dfs(Re x,Re fa){",
            "\tRe son=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa)son=1,dfs(to,x),pt[x]=TR.merge(pt[x],pt[to],-N,N);",
            "\tk[++cnt]=B[x],dp[x]=b[cnt]=son?TR.ask(pt[x],-N,N,A[x]):0;",
            "\tTR.change(pt[x],-N,N,cnt);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),m=n-1;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\tfor(Re i=1;i<=n;++i)in(B[i]);",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tdfs(1,0);",
            "\tfor(Re i=1;i<=n;++i)printf(\"%lld\\n\",dp[i]);",
            "}",
            ""
        ],
        "description": "插入 Escape Through Leaf"
    },
    "主席树-区间第k小": {
        "prefix": "acm-2.6mid",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=2e5+3,logN=18;",
            "int n,m,x,y,z,T,b[N],A[N],pt[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct President_Tree{",
            "    #define pl tr[p].lp",
            "    #define pr tr[p].rp",
            "    #define mid (L+R>>1)",
            "    int O;",
            "    struct QAQ{int S,lp,rp;}tr[N*(logN+1)];",
            "    inline void creat(Re &p,Re q,Re L,Re R,Re w){",
            "        p=++O,tr[p]=tr[q],++tr[p].S;",
            "        if(L==R)return;",
            "        if(w<=mid)creat(pl,tr[q].lp,L,mid,w);",
            "        else creat(pr,tr[q].rp,mid+1,R,w);",
            "    }",
            "    inline int ask(Re p,Re q,Re L,Re R,Re k){",
            "        if(L==R)return L;",
            "        Re tmp=tr[pl].S-tr[tr[q].lp].S;",
            "        if(tmp>=k)return ask(pl,tr[q].lp,L,mid,k);",
            "        else return ask(pr,tr[q].rp,mid+1,R,k-tmp);",
            "    }",
            "}T1;",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    in(n),in(T);",
            "    for(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];",
            "    sort(b+1,b+n+1),m=unique(b+1,b+n+1)-b-1;",
            "    for(Re i=1;i<=n;++i)T1.creat(pt[i],pt[i-1],1,m,lower_bound(b+1,b+m+1,A[i])-b);",
            "    while(T--)in(x),in(y),in(z),printf(\"%d\\n\",b[T1.ask(pt[y],pt[x-1],1,m,z)]);",
            "}",
            ""
        ],
        "description": "插入 主席树-区间第k小"
    },
    "区修，区查(gcd) (Interval GCD)": {
        "prefix": "acm-2.6+",
        "body": [
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "const int N=5e5+3;",
            "int n,x,y,T;LL z,A[N];char op;",
            "template<typename T>inline void in(T &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline LL abs(LL a){return a<0?-a:a;}",
            "inline LL gcd(LL a,LL b){return !b?a:gcd(b,a%b);}",
            "struct BIT{",
            "    LL C[N];",
            "    inline void add(Re x,LL v){while(x<=n)C[x]+=v,x+=x&-x;}",
            "    inline void add(Re L,Re R,LL v){add(L,v),add(R+1,-v);}",
            "    inline LL ask(Re x){LL ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}",
            "}TR0;",
            "struct Segment_Tree{",
            "    #define pl (p<<1)",
            "    #define pr (p<<1|1)",
            "    #define mid ((L+R)>>1)",
            "    LL tr[N<<2];",
            "    inline void pushup(Re p){tr[p]=gcd(tr[pl],tr[pr]);}",
            "    inline void build(Re p,Re L,Re R){",
            "        if(L==R){tr[p]=A[L]-A[L-1];return;}",
            "        build(pl,L,mid),build(pr,mid+1,R);",
            "        pushup(p);",
            "    }",
            "    inline void change(Re p,Re L,Re R,Re x,LL v){",
            "        if(L==R){tr[p]+=v;return;}",
            "        if(x<=mid)change(pl,L,mid,x,v);",
            "        else change(pr,mid+1,R,x,v);",
            "        pushup(p);",
            "    }",
            "    inline LL ask(Re p,Re L,Re R,Re l,Re r){",
            "        if(l<=L&&R<=r)return abs(tr[p]);",
            "        if(r<=mid)return ask(pl,L,mid,l,r);",
            "        else if(l>mid)return ask(pr,mid+1,R,l,r);",
            "        else return gcd(ask(pl,L,mid,l,r),ask(pr,mid+1,R,l,r));",
            "    }",
            "}TR;",
            "int main(){",
            "    in(n),in(T);",
            "    for(Re i=1;i<=n;++i)in(A[i]),TR0.add(i,i,A[i]);",
            "    TR.build(1,1,n);",
            "    while(T--){",
            "        scanf(\" %c\",&op),in(x),in(y);",
            "        if(op=='Q')printf(\"%lld\\n\",gcd(TR0.ask(x),TR.ask(1,1,n,x+1,y)));",
            "        else{",
            "            in(z),TR0.add(x,y,z),TR.change(1,1,n,x,z);if(y<n)TR.change(1,1,n,y+1,-z);",
            "        }",
            "    }",
            "}",
            ""
        ],
        "description": "插入 区修，区查(gcd) (Interval GCD)"
    },
    "区修，区查(Sum)": {
        "prefix": "acm-2.6Sqrt",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "int n,x,y,z,T,op;LL A[N];",
            "template<typename T>inline void in(T &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Segment_Tree{",
            "    #define pl (p<<1)",
            "    #define pr (p<<1|1)",
            "    #define mid ((L+R)>>1)",
            "    struct QAQ{LL S,max;}tr[N<<2];",
            "    inline void pushup(Re p){",
            "        tr[p].S=tr[pl].S+tr[pr].S;",
            "        tr[p].max=max(tr[pl].max,tr[pr].max);",
            "    }",
            "    inline void build(Re p,Re L,Re R){",
            "        if(L==R){tr[p].S=tr[p].max=A[L];return;}",
            "        build(pl,L,mid),build(pr,mid+1,R);",
            "        pushup(p);",
            "    }",
            "    inline void change(Re p,Re L,Re R,Re l,Re r){",
            "        if(tr[p].max<=1)return;",
            "        if(L==R){tr[p].max=tr[p].S=sqrt(tr[p].S);return;}",
            "        if(l<=mid)change(pl,L,mid,l,r);",
            "        if(r>mid)change(pr,mid+1,R,l,r);",
            "        pushup(p);",
            "    }",
            "    inline LL ask(Re p,Re L,Re R,Re l,Re r){",
            "        if(l<=L&&R<=r)return tr[p].S;",
            "        LL ans=0;",
            "        if(l<=mid)ans+=ask(pl,L,mid,l,r);",
            "        if(r>mid)ans+=ask(pr,mid+1,R,l,r);",
            "        return ans;",
            "    }",
            "}TR;",
            "int main(){",
            "    in(n);",
            "    for(Re i=1;i<=n;++i)in(A[i]);",
            "    TR.build(1,1,n),in(T);",
            "    while(T--){",
            "        in(op),in(x),in(y);if(x>y)swap(x,y);",
            "        if(op)printf(\"%lld\\n\",TR.ask(1,1,n,x,y));",
            "        else TR.change(1,1,n,x,y);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 区修，区查(Sum)"
    },
    "区修，区查(Sum,min)": {
        "prefix": "acm-2.6+,／",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "#define div(a,b) floor((double)a/b)",
            "using namespace std;",
            "const int N=1e5+3;",
            "int n,x,y,z,T,op,A[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Segment_Tree{",
            "    #define pl (p<<1)",
            "    #define pr (p<<1|1)",
            "    #define mid ((L+R)>>1)",
            "    struct QAQ{LL S,add,min,max;}tr[N<<2];",
            "    inline void pushup(Re p){",
            "        tr[p].S=tr[pl].S+tr[pr].S;",
            "        tr[p].min=min(tr[pl].min,tr[pr].min);",
            "        tr[p].max=max(tr[pl].max,tr[pr].max);",
            "    }",
            "    inline void updata(Re p,Re L,Re R,LL v){tr[p].S+=v*(R-L+1),tr[p].add+=v,tr[p].min+=v,tr[p].max+=v;}",
            "    inline void pushdown(Re p,Re L,Re R){",
            "        if(tr[p].add)updata(pl,L,mid,tr[p].add),updata(pr,mid+1,R,tr[p].add),tr[p].add=0;",
            "    }",
            "    inline void build(Re p,Re L,Re R){",
            "        if(L==R){tr[p].S=tr[p].min=tr[p].max=A[L];return;}",
            "        build(pl,L,mid),build(pr,mid+1,R);",
            "        pushup(p);",
            "    }",
            "    inline void change(Re p,Re L,Re R,Re l,Re r,Re v){",
            "        if(l<=L&&R<=r){updata(p,L,R,v);return;}",
            "        pushdown(p,L,R);",
            "        if(l<=mid)change(pl,L,mid,l,r,v);",
            "        if(r>mid)change(pr,mid+1,R,l,r,v);",
            "        pushup(p);",
            "    }",
            "    inline void change_div(Re p,Re L,Re R,Re l,Re r,Re v){",
            "        if(l<=L&&R<=r&&(div(tr[p].max,v)-tr[p].max==div(tr[p].min,v)-tr[p].min)){",
            "            updata(p,L,R,div(tr[p].max,v)-tr[p].max);return;",
            "        }",
            "        pushdown(p,L,R);",
            "        if(l<=mid)change_div(pl,L,mid,l,r,v);",
            "        if(r>mid)change_div(pr,mid+1,R,l,r,v);",
            "        pushup(p);",
            "    }",
            "    inline LL ask_min(Re p,Re L,Re R,Re l,Re r){",
            "        if(l<=L&&R<=r)return tr[p].min;",
            "        LL ans=1e18;pushdown(p,L,R);",
            "        if(l<=mid)ans=min(ans,ask_min(pl,L,mid,l,r));",
            "        if(r>mid)ans=min(ans,ask_min(pr,mid+1,R,l,r));",
            "        return ans;",
            "    }",
            "    inline LL ask_S(Re p,Re L,Re R,Re l,Re r){",
            "        if(l<=L&&R<=r)return tr[p].S;",
            "        LL ans=0;pushdown(p,L,R);",
            "        if(l<=mid)ans+=ask_S(pl,L,mid,l,r);",
            "        if(r>mid)ans+=ask_S(pr,mid+1,R,l,r);",
            "        return ans;",
            "    }",
            "}TR;",
            "int main(){",
            "    in(n),in(T);",
            "    for(Re i=1;i<=n;++i)in(A[i]);",
            "    TR.build(1,1,n);",
            "    while(T--){",
            "        in(op),in(x),in(y),++x,++y;",
            "        if(op<2)in(z),TR.change(1,1,n,x,y,z);",
            "        else if(op<3)in(z),TR.change_div(1,1,n,x,y,z);",
            "        else if(op<4)printf(\"%lld\\n\",TR.ask_min(1,1,n,x,y));",
            "        else printf(\"%lld\\n\",TR.ask_S(1,1,n,x,y));",
            "    }",
            "}",
            ""
        ],
        "description": "插入 区修，区查(Sum,min)"
    },
    "单修，区查(最大子段和)": {
        "prefix": "acm-2.6+",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e4+3;",
            "int n,x,y,T,op,A[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Segment_Tree{",
            "    #define pl (p<<1)",
            "    #define pr (p<<1|1)",
            "    #define mid ((L+R)>>1)",
            "    struct QAQ{LL S,max,lmax,rmax;}tr[N<<2];",
            "    inline void pushup(QAQ &A,const QAQ &L,const QAQ &R){",
            "        A.S=L.S+R.S;",
            "        A.lmax=max(L.lmax,L.S+R.lmax);",
            "        A.rmax=max(R.rmax,R.S+L.rmax);",
            "        A.max=max(max(max(L.max,R.max),max(A.lmax,A.rmax)),L.rmax+R.lmax);",
            "    }",
            "    inline void change(Re p,Re L,Re R,Re x,Re v){",
            "        if(L==R){tr[p].S=tr[p].max=tr[p].lmax=tr[p].rmax=v;return;}",
            "        if(x<=mid)change(pl,L,mid,x,v);",
            "        else change(pr,mid+1,R,x,v);",
            "        pushup(tr[p],tr[pl],tr[pr]);",
            "    }",
            "    inline QAQ ask(Re p,Re L,Re R,Re l,Re r){",
            "        if(l<=L&&R<=r)return tr[p];",
            "        if(r<=mid)return ask(pl,L,mid,l,r);",
            "        else if(l>mid)return ask(pr,mid+1,R,l,r);",
            "        else{QAQ ans;pushup(ans,ask(pl,L,mid,l,r),ask(pr,mid+1,R,l,r));return ans;}",
            "    }",
            "}TR;",
            "int main(){",
            "    in(n);",
            "    for(Re i=1;i<=n;++i)in(A[i]),TR.change(1,1,n,i,A[i]);",
            "    in(T);",
            "    while(T--){",
            "        in(op),in(x),in(y);",
            "        if(op)printf(\"%lld\\n\",TR.ask(1,1,n,x,y).max);",
            "        else TR.change(1,1,n,x,y);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 单修，区查(最大子段和)"
    },
    "扫描线（暴力）": {
        "prefix": "acm-8.3周长",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define y1 ORZ_HYJ_AK_IOI",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e4;",
            "int a,b,c,d,n,m,pan1[N+5<<1],pan2[N+5<<1];LL ans;",
            "struct Line{int x,y1,y2,k;inline bool operator<(Line O)const{return x==O.x?k>O.k:x<O.x;}}A[N+5<<1],B[N+5<<1];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int main(){",
            "    // freopen(\"123.txt\",\"r\",stdin);",
            "    in(n);",
            "    for(Re i=1;i<=n;++i){",
            "        in(a),in(b),in(c),in(d);",
            "        A[++m]=(Line){a,b,d,1},B[m]=(Line){b,a,c,1};",
            "        A[++m]=(Line){c,b,d,0},B[m]=(Line){d,a,c,0};",
            "    }",
            "    sort(A+1,A+m+1);",
            "    sort(B+1,B+m+1);",
            "    for(Re i=1;i<=m;++i){",
            "        if(A[i].k)for(Re j=A[i].y1;j<A[i].y2;++j)ans+=(!pan1[j+N]),++pan1[j+N];",
            "        else for(Re j=A[i].y1;j<A[i].y2;++j)--pan1[j+N],ans+=(!pan1[j+N]);",
            "        if(B[i].k)for(Re j=B[i].y1;j<B[i].y2;++j)ans+=(!pan2[j+N]),++pan2[j+N];",
            "        else for(Re j=B[i].y1;j<B[i].y2;++j)--pan2[j+N],ans+=(!pan2[j+N]);",
            "    }",
            "    printf(\"%lld\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 扫描线（暴力）"
    },
    "扫描线（线段树）": {
        "prefix": "acm-8.3周长",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define y1 yyyy",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e4+3,M=2e4+3;",
            "int n,m,ans,Max=10000,x1[N],y1[N],x2[N],y2[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tstruct QAQ{int S,cnt;}tr[M<<2];",
            "\tinline void pushup(Re p,Re L,Re R){",
            "\t\tif(tr[p].cnt)tr[p].S=R-L+1;",
            "\t\telse tr[p].S=(L==R)?0:tr[pl].S+tr[pr].S;",
            "\t}",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Re v){",
            "\t\tif(l<=L&&R<=r){tr[p].cnt+=v,pushup(p,L,R);return;}",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,v);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,v);",
            "\t\tpushup(p,L,R);",
            "\t}",
            "}TR1,TR2;",
            "struct Line{",
            "\tint x,y1,y2,k;Line(Re X=0,Re Y1=0,Re Y2=0,Re K=0){x=X,y1=Y1,y2=Y2,k=K;}",
            "\tinline bool operator<(const Line &O)const{return x!=O.x?x<O.x:k>O.k;}",
            "}L1[N<<1],L2[N<<1];",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n);",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tin(x1[i]),in(y1[i]),in(x2[i]),in(y2[i]),x1[i]+=Max,y1[i]+=Max,x2[i]+=Max,y2[i]+=Max,",
            "\t\tL1[++m]=Line(x1[i],y1[i],y2[i],1),L2[m]=Line(y1[i],x1[i],x2[i],1),",
            "\t\tL1[++m]=Line(x2[i],y1[i],y2[i],-1),L2[m]=Line(y2[i],x1[i],x2[i],-1);",
            "\tsort(L1+1,L1+m+1),sort(L2+1,L2+m+1);",
            "\tfor(Re i=1,j=0;i<=m;i=j+1){",
            "\t\tRe last=TR1.tr[1].S;",
            "\t\t++j,TR1.change(1,1,Max<<1,L1[j].y1+1,L1[j].y2,L1[j].k);",
            "\t\twhile(j+1<=m&&L1[j].x==L1[j+1].x&&L1[j].k==L1[j+1].k)++j,TR1.change(1,1,Max<<1,L1[j].y1+1,L1[j].y2,L1[j].k);",
            "\t\tans+=abs(last-TR1.tr[1].S);",
            "\t}",
            "\tfor(Re i=1,j=0;i<=m;i=j+1){",
            "\t\tRe last=TR2.tr[1].S;",
            "\t\t++j,TR2.change(1,1,Max<<1,L2[j].y1+1,L2[j].y2,L2[j].k);",
            "\t\twhile(j+1<=m&&L2[j].x==L2[j+1].x&&L2[j].k==L2[j+1].k)++j,TR2.change(1,1,Max<<1,L2[j].y1+1,L2[j].y2,L2[j].k);",
            "\t\tans+=abs(last-TR2.tr[1].S);",
            "\t}",
            "\tprintf(\"%d\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 扫描线（线段树）"
    },
    "扫描线": {
        "prefix": "acm-8.3面积",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define y1 yyyy",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "int n,m,T,x1,y1,x2,y2,b[N<<1];LL ans;",
            "struct Line{int x,y1,y2,k;inline bool operator<(const Line &O)const{return x<O.x;}}A[N<<1];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Segment_Tree{",
            "    #define pl (p<<1)",
            "    #define pr (p<<1|1)",
            "    #define mid ((L+R)>>1)",
            "    struct QAQ{int cnt,len;}tr[N<<3];",
            "    inline void pushup(Re p,Re L,Re R){",
            "        if(tr[p].cnt)tr[p].len=b[R+1]-b[L];",
            "        else tr[p].len=(L==R)?0:tr[pl].len+tr[pr].len;",
            "    }",
            "    inline void change(Re p,Re L,Re R,Re l,Re r,Re v){",
            "        if(l<=L&&R<=r){tr[p].cnt+=v,pushup(p,L,R);return;}",
            "        if(l<=mid)change(pl,L,mid,l,r,v);",
            "        if(r>mid)change(pr,mid+1,R,l,r,v);",
            "        pushup(p,L,R);",
            "    }",
            "}TR;",
            "int main(){",
            "    in(T);",
            "    while(T--){",
            "        in(x1),in(y1),in(x2),in(y2);",
            "        A[++n]=(Line){x1,y1,y2,1},A[++n]=(Line){x2,y1,y2,-1};",
            "        b[++m]=y1,b[++m]=y2;",
            "    }",
            "    sort(A+1,A+n+1),sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;",
            "    for(Re i=1;i<n;++i){",
            "        Re y1=lower_bound(b+1,b+m+1,A[i].y1)-b,y2=lower_bound(b+1,b+m+1,A[i].y2)-b;",
            "        TR.change(1,1,m-1,y1,y2-1,A[i].k);",
            "        ans+=(LL)TR.tr[1].len*(A[i+1].x-A[i].x);",
            "    }",
            "    printf(\"%lld\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 扫描线"
    },
    "整体DP  (Treeland Tour)": {
        "prefix": "acm-2.6树上最长上升子序列",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=6003;",
            "int n,m,x,y,t,o,Ans,b[N],A[N],pt[N],head[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Segment_Tree{",
            "\t#define pl (tr[p].lp)",
            "\t#define pr (tr[p].rp)",
            "\t#define mid ((L+R)>>1)",
            "\tint O;",
            "\tstruct QAQ{int lp,rp,up,down;}tr[N*13*2];",
            "\tinline void pushup(Re p){",
            "\t\ttr[p].up=max(tr[pl].up,tr[pr].up);",
            "\t\ttr[p].down=max(tr[pl].down,tr[pr].down);",
            "\t}",
            "\tinline void change1(Re &p,Re L,Re R,Re x,Re v){",
            "\t\tif(!p)p=++O;",
            "\t\tif(L==R){tr[p].up=max(tr[p].up,v);return;}",
            "\t\tif(x<=mid)change1(pl,L,mid,x,v);",
            "\t\telse change1(pr,mid+1,R,x,v);",
            "\t\tpushup(p);",
            "\t}",
            "\tinline void change2(Re &p,Re L,Re R,Re x,Re v){",
            "\t\tif(!p)p=++O;",
            "\t\tif(L==R){tr[p].down=max(tr[p].down,v);return;}",
            "\t\tif(x<=mid)change2(pl,L,mid,x,v);",
            "\t\telse change2(pr,mid+1,R,x,v);",
            "\t\tpushup(p);",
            "\t}",
            "\tinline int ask1(Re p,Re L,Re R,Re l,Re r){",
            "\t\tif(!p)return 0;",
            "\t\tif(l<=L&&R<=r)return tr[p].up;",
            "\t\tRe ans=0;",
            "\t\tif(l<=mid)ans=max(ans,ask1(pl,L,mid,l,r));",
            "\t\tif(r>mid)ans=max(ans,ask1(pr,mid+1,R,l,r));",
            "\t\treturn ans;",
            "\t}",
            "\tinline int ask2(Re p,Re L,Re R,Re l,Re r){",
            "\t\tif(!p)return 0;",
            "\t\tif(l<=L&&R<=r)return tr[p].down;",
            "\t\tRe ans=0;",
            "\t\tif(l<=mid)ans=max(ans,ask2(pl,L,mid,l,r));",
            "\t\tif(r>mid)ans=max(ans,ask2(pr,mid+1,R,l,r));",
            "\t\treturn ans;",
            "\t}",
            "\tinline int merge(Re p,Re q,Re L,Re R){",
            "\t\tif(!p||!q)return p+q;",
            "\t\tif(L==R){tr[p].up=max(tr[p].up,tr[q].up),tr[p].down=max(tr[p].down,tr[q].down);return p;}",
            "\t\tAns=max(Ans,max(tr[pl].up+tr[tr[q].rp].down,tr[pr].down+tr[tr[q].lp].up));",
            "\t\tpl=merge(pl,tr[q].lp,L,mid);",
            "\t\tpr=merge(pr,tr[q].rp,mid+1,R);",
            "\t\tpushup(p);return p;",
            "\t}",
            "}TR;",
            "inline void dfs(Re x,Re fa){",
            "\tRe up=0,down=0;",
            "\tfor(Re i=head[x],to;i;i=a[i].next)",
            "\t\tif((to=a[i].to)!=fa){",
            "\t\t\tdfs(to,x);",
            "\t\t\tRe tmp1=TR.ask1(pt[to],1,t,1,A[x]-1),tmp2=TR.ask2(pt[to],1,t,A[x]+1,t);",
            "\t\t\tAns=max(Ans,max(up+tmp2+1,down+tmp1+1));",
            "\t\t\tup=max(up,tmp1),down=max(down,tmp2);",
            "\t\t\tpt[x]=TR.merge(pt[x],pt[a[i].to],1,t);",
            "\t\t}",
            "\tTR.change1(pt[x],1,t,A[x],up+1),TR.change2(pt[x],1,t,A[x],down+1);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),m=n-1;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];",
            "\tsort(b+1,b+n+1),t=unique(b+1,b+n+1)-b;",
            "\tfor(Re i=1;i<=n;++i)A[i]=lower_bound(b+1,b+t+1,A[i])-b;",
            "\twhile(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tdfs(1,0),printf(\"%d\\n\",Ans);",
            "}",
            ""
        ],
        "description": "插入 整体DP  (Treeland Tour)"
    },
    "树套树-单修权值，区间权值和+垃圾回收": {
        "prefix": "acm-2.6Intersection of Permutations",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define Re register int",
            "using namespace std;",
            "const int N=2e5+3;char opt[N];",
            "int x,y,z,w,n,T,op,A[N],rk[N];",
            "inline void in(int &x){",
            "    Re fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "int pt[N<<1];",
            "struct Segment_Tree{",
            "\t#define pl tr[p].lp",
            "\t#define pr tr[p].rp",
            "\t#define mid ((L+R)>>1)",
            "\tint O;queue<int>Q;",
            "\tstruct QAQ{int S,lp,rp;}tr[N*200];",
            "\tinline int New(){// 新建节点",
            "\t\tif(Q.empty())return ++O;",
            "\t\tRe tmp=Q.front();Q.pop();",
            "\t\treturn tmp;",
            "\t}",
            "\tinline void del(Re &p){pl=pr=0,Q.push(p),p=0;}// 删除节点(注意取地址，初始化为1)",
            "\tinline void change(Re &p,Re L,Re R,Re w,Re v){",
            "\t    if(!p)p=New();tr[p].S+=v;",
            "\t    if(L==R){if(!tr[p].S)del(p);return;}",
            "\t    if(w<=mid)change(pl,L,mid,w,v);",
            "\t    else change(pr,mid+1,R,w,v);",
            "\t    if(!tr[p].S)del(p);",
            "\t}",
            "\tinline int ask(Re p,Re L,Re R,Re l,Re r){",
            "\t\tif(!p)return 0;",
            "\t\tif(l<=L&&R<=r)return tr[p].S;",
            "\t\tRe ans=0;",
            "\t\tif(l<=mid)ans+=ask(pl,L,mid,l,r);",
            "\t\tif(r>mid)ans+=ask(pr,mid+1,R,l,r);",
            "\t\treturn ans;",
            "\t}",
            "}TR;",
            "inline int ask(Re L,Re R,Re l,Re r){",
            "    Re ans=0;",
            "    for(Re i=R;i;i-=i&-i)ans+=TR.ask(pt[i],1,n,l,r);",
            "    for(Re i=L-1;i;i-=i&-i)ans-=TR.ask(pt[i],1,n,l,r);",
            "    return ans;",
            "}",
            "inline void add(Re x,Re w,Re v){",
            "    for(Re i=x;i<=n;i+=i&-i)TR.change(pt[i],1,n,w,v);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "    in(n),in(T);",
            "\tfor(Re i=1;i<=n;++i)in(x),rk[x]=i;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]),A[i]=rk[A[i]],add(i,A[i],1);",
            "    while(T--){",
            "    \tin(op),in(x),in(y);",
            "    \tif(op>1)add(x,A[x],-1),add(y,A[y],-1),swap(A[x],A[y]),add(x,A[x],1),add(y,A[y],1);",
            "    \telse in(z),in(w),printf(\"%d\\n\",ask(z,w,x,y));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 树套树-单修权值，区间权值和+垃圾回收"
    },
    "树套树-单修权值，区间第k小": {
        "prefix": "acm-2.6pl",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3;",
            "int n,m,T,b[N<<1],A[N];char op[N];",
            "struct QWQ{int x,y,k;}Q[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int t1,t2,pt[N],ptl[20],ptr[20];",
            "struct President_Tree{",
            "    #define pl (tr[p].lp)",
            "    #define pr (tr[p].rp)",
            "    #define mid ((L+R)>>1)",
            "    int O;",
            "    struct QAQ{int S,lp,rp;}tr[(N<<1)*200];",
            "    inline void change(Re &p,Re L,Re R,Re x,Re v){",
            "        if(!p)p=++O;tr[p].S+=v;",
            "        if(L==R)return;",
            "        if(x<=mid)change(pl,L,mid,x,v);",
            "        else change(pr,mid+1,R,x,v);",
            "    }",
            "    inline int ask(Re p,Re L,Re R,Re K){",
            "        if(L==R)return L;",
            "        Re tmp=0;",
            "        for(Re i=1;i<=t1;++i)tmp-=tr[tr[ptl[i]].lp].S;",
            "        for(Re i=1;i<=t2;++i)tmp+=tr[tr[ptr[i]].lp].S;",
            "        if(K<=tmp){",
            "            for(Re i=1;i<=t1;++i)ptl[i]=tr[ptl[i]].lp;",
            "            for(Re i=1;i<=t2;++i)ptr[i]=tr[ptr[i]].lp;",
            "            return ask(pl,L,mid,K);",
            "        }",
            "        else{",
            "            for(Re i=1;i<=t1;++i)ptl[i]=tr[ptl[i]].rp;",
            "            for(Re i=1;i<=t2;++i)ptr[i]=tr[ptr[i]].rp;",
            "            return ask(pr,mid+1,R,K-tmp);",
            "        }",
            "    }",
            "}SG;",
            "struct BIT{",
            "    inline void add(Re x,Re v){",
            "        for(Re i=x;i<=n;i+=i&-i)SG.change(pt[i],1,m,A[x],v);",
            "    }",
            "    inline int ask(Re L,Re R,Re k){",
            "        t1=t2=0;",
            "        for(Re i=L-1;i;i-=i&-i)ptl[++t1]=pt[i];",
            "        for(Re i=R;i;i-=i&-i)ptr[++t2]=pt[i];",
            "        return SG.ask(1,1,m,k);",
            "    }",
            "}TR;",
            "int main(){",
            "    in(n),in(T),m=n;",
            "    for(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];",
            "    for(Re i=1;i<=T;++i){",
            "        scanf(\" %c\",&op[i]),in(Q[i].x),in(Q[i].y);",
            "        if(op[i]=='Q')in(Q[i].k);",
            "        else b[++m]=Q[i].y;",
            "    }",
            "    sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;",
            "    for(Re i=1;i<=n;++i)A[i]=lower_bound(b+1,b+m+1,A[i])-b;",
            "    for(Re i=1;i<=T;++i)if(op[i]=='C')Q[i].y=lower_bound(b+1,b+m+1,Q[i].y)-b;",
            "    for(Re i=1;i<=n;++i)TR.add(i,1);",
            "    for(Re i=1;i<=T;++i){",
            "        if(op[i]=='Q')printf(\"%d\\n\",b[TR.ask(Q[i].x,Q[i].y,Q[i].k)]);",
            "        else TR.add(Q[i].x,-1),A[Q[i].x]=Q[i].y,TR.add(Q[i].x,1);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 树套树-单修权值，区间第k小"
    },
    "线段树分治 (LCT维护MST) (城市建设)": {
        "prefix": "acm-2.6时间分治",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=2e4+3,M=5e4+3;",
            "int n,m,x,y,z,T,op,X[N+M],Y[N+M],last[M];LL v[N+M],Ans[M];",
            "inline void in(int &x){",
            "    Re fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct QWQ{int id,op;QWQ(Re ID=0,Re OP=0){id=ID,op=OP;}};",
            "struct Link_Cut_Tree{",
            "\t#define pl tr[p].ps[0]",
            "\t#define pr tr[p].ps[1]",
            "\t#define pf tr[p].fa",
            "\tint size,Q[N+M];QWQ QQ[M*32];LL MST;",
            "\tstruct QAQ{int mx,fa,tag,ps[2];}tr[N+M];",
            "\tinline void pushup(Re p){",
            "\t\ttr[p].mx=p;",
            "\t\tif(pl&&v[tr[pl].mx]>v[tr[p].mx])tr[p].mx=tr[pl].mx;",
            "\t\tif(pr&&v[tr[pr].mx]>v[tr[p].mx])tr[p].mx=tr[pr].mx;",
            "\t}",
            "\tinline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}",
            "\tinline void pushdown(Re p){",
            "\t\tif(tr[p].tag){",
            "\t\t\tif(pl)updata(pl);",
            "\t\t\tif(pr)updata(pr);",
            "\t\t\ttr[p].tag=0;",
            "\t\t}",
            "\t}",
            "\tinline int which(Re p){return tr[pf].ps[1]==p;}",
            "\tinline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}",
            "\tinline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}",
            "\tinline void rotate(Re p){",
            "\t\tRe fa=pf,fas=which(p);",
            "\t\tRe pa=tr[fa].fa,pas=which(fa);",
            "\t\tRe x=tr[p].ps[fas^1];",
            "\t\tif(nort(fa))tr[pa].ps[pas]=p;pf=pa;",
            "\t\tconnect(x,fa,fas),connect(fa,p,fas^1);",
            "\t\tpushup(fa),pushup(p); ",
            "\t}",
            "\tinline void splay(Re p){",
            "\t\tRe x=p,t=0;Q[++t]=x;",
            "\t\twhile(nort(x))Q[++t]=x=tr[x].fa;",
            "\t\twhile(t)pushdown(Q[t--]);",
            "\t\tfor(Re fa;nort(p);rotate(p))",
            "\t\t\tif(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);",
            "\t}",
            "\tinline void access(Re p){",
            "\t\tfor(Re son=0;p;son=p,p=pf)",
            "\t\t\tsplay(p),pr=son,pushup(p);",
            "\t}",
            "\tinline void makeroot(Re x){access(x),splay(x),updata(x);}",
            "\tinline int findroot(Re p){",
            "\t\taccess(p),splay(p),pushdown(p);",
            "\t\twhile(pl)pushdown(p=pl);",
            "\t\treturn p;",
            "\t}",
            "\tinline void split(Re x,Re y){makeroot(x),access(y),splay(y);}",
            "\tinline void link(Re x,Re y){makeroot(x),tr[x].fa=y;}",
            "\tinline void cut(Re x,Re y){makeroot(x),access(y),splay(y),tr[x].fa=tr[y].ps[0]=0,pushup(y);}",
            "\tinline void cut_(Re id){",
            "\t\tmakeroot(Y[id]),access(X[id]),splay(X[id]),tr[X[id]].ps[0]=tr[Y[id]].fa=tr[id].ps[0]=tr[id].fa=0,pushup(X[id]);",
            "\t}",
            "\tinline void link_(Re id){",
            "\t\tmakeroot(X[id]),makeroot(Y[id]),tr[X[id]].fa=tr[Y[id]].fa=id;",
            "\t}",
            "\tinline void MST_link(Re id){",
            "\t\tRe x=X[id],y=Y[id];makeroot(x);",
            "\t\tif(findroot(y)!=x)link(x,id),link(id,y),QQ[++size]=QWQ(id,0),MST+=v[id];",
            "\t\telse{",
            "\t\t\tRe mx=tr[y].mx;",
            "\t\t\tif(v[id]<v[mx]){",
            "//\t\t\t\tcut(X[mx],mx),cut(mx,Y[mx]),QQ[++size]=QWQ(mx,1);",
            "\t\t\t\tcut_(mx),QQ[++size]=QWQ(mx,1);",
            "\t\t\t\tlink(x,id),link(id,y),QQ[++size]=QWQ(id,0);",
            "//\t\t\t\tlink_(id),QQ[++size]=QWQ(id,0);",
            "\t\t\t\tMST+=v[id]-v[mx];",
            "\t\t\t}",
            "\t\t}",
            "\t}",
            "\tinline void back(Re to){",
            "\t\twhile(size>to){",
            "\t\t\tQWQ a=QQ[size--];Re id=a.id;",
            "\t\t\tif(a.op)link(id,Y[id]),link(X[id],id),MST+=v[id];",
            "//\t\t\telse cut(id,Y[id]),cut(X[id],id),MST-=v[id];",
            "//\t\t\tif(a.op)link_(id),MST+=v[id];",
            "\t\t\telse cut_(id),MST-=v[id];",
            "\t\t}",
            "\t}",
            "\t#undef pl",
            "\t#undef pr",
            "}LCT;",
            "int o,head[M<<2];",
            "struct QAQ{int id,next;LL v;}a[M*32];",
            "inline void add(Re x,Re id,LL v){a[++o].id=id,a[o].v=v,a[o].next=head[x],head[x]=o;}",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Re id,LL v){",
            "\t\tif(l>r)return;",
            "\t\tif(l<=L&&R<=r){add(p,id,v);return;}",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,id,v);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,id,v);",
            "\t}",
            "\tinline void dfs(Re p,Re L,Re R){",
            "\t\tRe tmp=LCT.size;",
            "\t\tfor(Re i=head[p];i;i=a[i].next)v[a[i].id]=a[i].v,LCT.MST_link(a[i].id);",
            "\t\tif(L==R)Ans[L]=LCT.MST;",
            "\t\telse dfs(pl,L,mid),dfs(pr,mid+1,R);",
            "\t\tLCT.back(tmp);",
            "\t}",
            "}T1;",
            "int main(){",
            "// \tfreopen(\"123.txt\",\"r\",stdin);",
            "// \tfreopen(\"my.txt\",\"w\",stdout);",
            "\tin(n),in(m),in(T);",
            "\tfor(Re i=1;i<=m;++i)in(X[i+n]),in(Y[i+n]),in(x),v[i+n]=x,last[i]=1;",
            "\tfor(Re i=1;i<=T;++i){",
            "\t\tin(x),in(y);",
            "\t\tT1.change(1,1,T,last[x],i-1,x+n,v[x+n]);",
            "\t\tlast[x]=i,v[x+n]=y;",
            "\t}",
            "\tfor(Re i=1;i<=m;++i)T1.change(1,1,T,last[i],T,i+n,v[i+n]);",
            "\tT1.dfs(1,1,T);",
            "\tfor(Re i=1;i<=T;++i)printf(\"%lld\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 线段树分治 (LCT维护MST) (城市建设)"
    },
    "线段树分治 (冰茶姬 判断二分图)": {
        "prefix": "acm-2.6时间分治",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<stack>",
            "#include<map>",
            "#define LL long long",
            "#define Re register int",
            "#define mp make_pair",
            "using namespace std;",
            "const int N=1e5+3,M=2e5+3;",
            "int x,y,l,r,n,m,T,Ans[N];char ch[20];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Union{// 冰茶姬（并查集）",
            "\tstruct BK{int x,y,sizex,sizey;BK(Re X=0,Re S1=0,Re Y=0,Re S2=0){x=X,y=Y,sizex=S1,sizey=S2;}};",
            "\tint fa[N<<1],size[N<<1];stack<BK>Q;",
            "\tinline int find(Re x){return fa[x]==x?x:find(fa[x]);}",
            "\tinline void merge(Re x,Re y){// 启发式合并",
            "\t\tx=find(x),y=find(y);",
            "\t\tif(x==y)return;",
            "\t\tif(size[x]>size[y])swap(x,y);",
            "\t\tQ.push(BK(x,size[x],y,size[y]));",
            "\t\tfa[x]=y,size[y]+=size[x];",
            "\t}",
            "\tinline void back(Re to){// 撤销操作",
            "\t\twhile(int(Q.size())>to){",
            "\t\t\tBK a=Q.top();Q.pop();",
            "\t\t\tfa[a.x]=a.x,size[a.x]=a.sizex;",
            "\t\t\tfa[a.y]=a.y,size[a.y]=a.sizey;",
            "\t\t}",
            "\t}",
            "}TF;",
            "int o,head[N<<2];",
            "struct QAQ{int x,y,next;}a[M*20];",
            "inline void add(Re x,Re y1,Re y2){a[++o].x=y1,a[o].y=y2,a[o].next=head[x],head[x]=o;}",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re y){",
            "\t\tif(l>r)return;",
            "\t\tif(l<=L&&R<=r){add(p,x,y);return;}",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,x,y);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,x,y);",
            "\t}",
            "\tinline void dfs(Re p,Re L,Re R){",
            "\t\tRe tmp=TF.Q.size();",
            "\t\tfor(Re i=head[p];i;i=a[i].next){",
            "\t\t\tif(TF.find(a[i].x)==TF.find(a[i].y)){",
            "\t\t\t\tfor(Re j=L;j<=R;++j)Ans[j]=1;",
            "\t\t\t\tTF.back(tmp);return;",
            "\t\t\t}",
            "\t\t\tTF.merge(a[i].x,a[i].y+n),TF.merge(a[i].x+n,a[i].y);",
            "\t\t}",
            "\t\tif(L<R)dfs(pl,L,mid),dfs(pr,mid+1,R);",
            "\t\tTF.back(tmp);",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),in(T);",
            "\tfor(Re i=1;i<=(n<<1);++i)TF.fa[i]=i,TF.size[i]=1;",
            "\tfor(Re i=1;i<=m;++i)in(x),in(y),in(l),in(r),T1.change(1,1,T,l+1,r+1-1,x,y);",
            "\tT1.dfs(1,1,T);",
            "\tfor(Re i=1;i<=T;++i)puts(Ans[i]?\"No\":\"Yes\");",
            "}",
            ""
        ],
        "description": "插入 线段树分治 (冰茶姬 判断二分图)"
    },
    "线段树分治 (冰茶姬 查询图的连通性) (洞穴勘测)": {
        "prefix": "acm-2.6时间分治",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<stack>",
            "#include<map>",
            "#define LL long long",
            "#define Re register int",
            "#define mp(x,y) make_pair(x,y)",
            "using namespace std;",
            "const int N=1e4+3,M=2e5+3;",
            "int x,y,n,T,Ans[M];char ch[20];",
            "map<pair<int,int>,int>last;",
            "struct Query{int x,y,op;}Q[M];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Union{// 冰茶姬（并查集）",
            "\tstruct BK{int x,y,sizex,sizey;BK(Re X=0,Re S1=0,Re Y=0,Re S2=0){x=X,y=Y,sizex=S1,sizey=S2;}};",
            "\tint fa[N],size[N];stack<BK>Q;",
            "\tinline int find(Re x){return fa[x]==x?x:find(fa[x]);}",
            "\tinline void merge(Re x,Re y){// 启发式合并",
            "\t\tx=find(x),y=find(y);",
            "\t\tif(size[x]>size[y])swap(x,y);",
            "\t\tQ.push(BK(x,size[x],y,size[y]));",
            "\t\tfa[x]=y,size[y]+=size[x];",
            "\t}",
            "\tinline void back(Re to){// 撤销操作",
            "\t\twhile(Q.size()>to){",
            "\t\t\tBK a=Q.top();Q.pop();",
            "\t\t\tfa[a.x]=a.x,size[a.x]=a.sizex;",
            "\t\t\tfa[a.y]=a.y,size[a.y]=a.sizey;",
            "\t\t}",
            "\t}",
            "}TF;",
            "int o,head[M<<2];",
            "struct QAQ{int x,y,next;}a[M*20];",
            "inline void add(Re x,Re y1,Re y2){a[++o].x=y1,a[o].y=y2,a[o].next=head[x],head[x]=o;}",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid (L+R>>1)",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re y){",
            "\t\tif(l<=L&&R<=r){add(p,x,y);return;}",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,x,y);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,x,y);",
            "\t}",
            "\tinline void dfs(Re p,Re L,Re R){",
            "\t\tRe tmp=TF.Q.size();",
            "\t\tfor(Re i=head[p];i;i=a[i].next)TF.merge(a[i].x,a[i].y);",
            "\t\tif(L==R){if(Q[L].op)Ans[L]=(TF.find(Q[L].x)==TF.find(Q[L].y));}",
            "\t\telse dfs(pl,L,mid),dfs(pr,mid+1,R);",
            "\t\tTF.back(tmp);",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T);",
            "\tfor(Re i=1;i<=n;++i)TF.fa[i]=i,TF.size[i]=1;",
            "\tfor(Re i=1;i<=T;++i){",
            "\t\tscanf(\"%s\",ch),in(x),in(y);if(x>y)swap(x,y);",
            "\t\tif(ch[0]=='Q')Q[i].op=1,Q[i].x=x,Q[i].y=y;",
            "\t\telse if(ch[0]=='C')last[mp(x,y)]=i;",
            "\t\telse T1.change(1,1,T,last[mp(x,y)],i,x,y),last.erase(mp(x,y));",
            "\t}",
            "\tfor(map<pair<int,int>,int>::iterator it=last.begin();it!=last.end();++it)",
            "\t\tT1.change(1,1,T,it->second,T,it->first.first,it->first.second);",
            "\tT1.dfs(1,1,T);",
            "\tfor(Re i=1;i<=T;++i)if(Q[i].op)puts(Ans[i]?\"Yes\":\"No\");",
            "}",
            ""
        ],
        "description": "插入 线段树分治 (冰茶姬 查询图的连通性) (洞穴勘测)"
    },
    "线段树分治 (线性基) (八纵八横)": {
        "prefix": "acm-2.6时间分治",
        "body": [
            "#include<algorithm>",
            "#include<iostream>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<bitset>",
            "#include<stack>",
            "#define LL long long",
            "#define Re register int",
            "#define Int bitset<M>",
            "using namespace std;",
            "const int N=550+5,M=1000+5;",
            "int n,m,x,y,o,O,T,logN,X[N],Y[N],fa[N],last[N],head[N];Int z,Z[N],dis[N],Ans[M];char op[20];",
            "struct QAQ{int to,next;Int w;}a[N<<1];",
            "inline void add(Re x,Re y,Int z){a[++o].to=y,a[o].w=z,a[o].next=head[x],head[x]=o;}",
            "inline int find(Re x){return x==fa[x]?x:fa[x]=find(fa[x]);}",
            "inline int getlen(Int &x){Re n=1000;while(n>=1&&!x[n])--n;return n;}",
            "inline void print(Int &x){for(Re i=getlen(x);i>=0;--i)putchar(x[i]+'0');puts(\"\");}",
            "inline void in(Int &x){cin>>x,logN=max(logN,getlen(x));}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Line_JI{",
            "\tInt p[M];bool pp[M];stack<int>Q;",
            "\tinline void insert(Int x){",
            "\t\tfor(Re i=logN;i>=0;--i)",
            "\t\t\tif(x[i]){",
            "\t\t\t\tif(!pp[i]){Q.push(i),p[i]=x,pp[i]=1;break;}",
            "\t\t\t\tx^=p[i];",
            "\t\t\t}",
            "\t}",
            "\tinline Int ask(){",
            "\t\tInt ans;ans.reset();",
            "\t\tfor(Re i=logN;i>=0;--i)if(pp[i]&&(!ans[i]))ans^=p[i];",
            "\t\treturn ans;",
            "\t}",
            "\tinline void back(Re to){",
            "\t\twhile(Q.size()>to)x=Q.top(),Q.pop(),p[x].reset(),pp[x]=0;",
            "\t}",
            "}JI;",
            "struct Segment_Tree{",
            "\tint o,head[M<<2];",
            "\tstruct QAQ{int x,y,next;Int w;}a[(N+M)*10];",
            "\tinline void add(Re t,Re x,Re y,Int &z){a[++o].x=x,a[o].y=y,a[o].w=z,a[o].next=head[t],head[t]=o;}",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re y,Int &z){",
            "\t\tif(l<=L&&R<=r){add(p,x,y,z);return;}",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,x,y,z);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,x,y,z);",
            "\t}",
            "\tinline void dfs(Re p,Re L,Re R){",
            "\t\tRe tmp=JI.Q.size();",
            "\t\tfor(Re i=head[p];i;i=a[i].next)JI.insert(dis[a[i].x]^dis[a[i].y]^a[i].w);",
            "\t\tif(L==R)Ans[L]=JI.ask();// 这里还没做back撤销操作,不能return!!!",
            "\t\telse dfs(pl,L,mid),dfs(pr,mid+1,R);",
            "\t\tJI.back(tmp);",
            "\t}",
            "}TR;",
            "inline void dfs(Re x,Re fa,Re w){",
            "\tdis[x]=dis[fa]^a[w].w;",
            "\tfor(Re i=head[x];i;i=a[i].next)",
            "\t\tif(a[i].to!=fa)dfs(a[i].to,x,i);",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),in(T),++T;",
            "\tfor(Re i=1;i<=n;++i)fa[i]=i;",
            "\twhile(m--){",
            "\t\tin(x),in(y),in(z);",
            "\t\tif(find(x)!=find(y))add(x,y,z),add(y,x,z),fa[find(x)]=find(y);",
            "\t\telse TR.change(1,1,T,1,T,x,y,z);",
            "\t}",
            "\tfor(Re i=2;i<=T;++i){",
            "\t\tscanf(\"%s\",op);",
            "\t\tif(op[0]=='A')last[++O]=i,in(X[O]),in(Y[O]),in(Z[O]);",
            "\t\telse if(op[1]=='h'){",
            "\t\t\tin(x),in(z);",
            "\t\t\tTR.change(1,1,T,last[x],i-1,X[x],Y[x],Z[x]);",
            "\t\t\tlast[x]=i,Z[x]=z;",
            "\t\t}",
            "\t\telse in(x),TR.change(1,1,T,last[x],i-1,X[x],Y[x],Z[x]),last[x]=0;",
            "\t}",
            "\tfor(Re i=1;i<=O;++i)if(last[i])TR.change(1,1,T,last[i],T,X[i],Y[i],Z[i]);",
            "\tdfs(1,0,0),TR.dfs(1,1,T);",
            "\tfor(Re i=1;i<=T;++i)print(Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 线段树分治 (线性基) (八纵八横)"
    },
    "线段树分裂-分裂区间前后k个": {
        "prefix": "acm-2.6区间排序 P2824",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<set>",
            "#define LL long long",
            "#define Re register int",
            "#define IT set<QAQ>::iterator",
            "using namespace std;",
            "const int N=1e5+3;",
            "int n,m,l,r,T,op,A[N],tmp[N],cnt[N],Ans[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct QAQ{",
            "\tint l,r;mutable int pt,op; ",
            "\tQAQ(Re L=0,Re R=0,Re OP=0,Re PT=0){l=L,r=R,op=OP,pt=PT;};",
            "\tinline bool operator<(const QAQ &O)const{return l<O.l;}",
            "};",
            "set<QAQ>s;",
            "struct Segment_Tree{",
            "\t#define pl tr[p].lp",
            "\t#define pr tr[p].rp",
            "\t#define mid ((L+R)>>1)",
            "\tint O;",
            "\tstruct QAQ{int S,lp,rp;}tr[N*60];",
            "\tinline void pushup(Re p){tr[p].S=tr[pl].S+tr[pr].S;}",
            "\tinline void change(Re &p,Re L,Re R,Re x){",
            "\t\tp=++O;",
            "\t\tif(L==R){tr[p].S=1;return;}",
            "\t\tif(x<=mid)change(pl,L,mid,x);",
            "\t\telse change(pr,mid+1,R,x);",
            "\t\tpushup(p);",
            "\t}",
            "\tinline int merge(Re p,Re q,Re L,Re R){",
            "\t\tif(!p||!q)return p+q;",
            "\t\tif(L==R){tr[p].S+=tr[q].S;return p;}",
            "\t\tpl=merge(pl,tr[q].lp,L,mid);",
            "\t\tpr=merge(pr,tr[q].rp,mid+1,R);",
            "\t\tpushup(p);return p;",
            "\t}",
            "\tinline void split1(Re &p,Re q,Re L,Re R,Re k){// 取q中的前k个,分到新节点p",
            "\t\ttr[p=++O].S=tr[q].S-k,tr[q].S=k;",
            "\t\tif(L==R)return;",
            "\t\tRe tmp=tr[tr[q].lp].S;",
            "\t\tif(k>tmp)split1(pr,tr[q].rp,mid+1,R,k-tmp);// q左子树全部分给p,只剩右子树",
            "\t\telse pr=tr[q].rp,tr[q].rp=0;// 右子树全部分给p",
            "\t\tif(k<tmp)split1(pl,tr[q].lp,L,mid,k);// q的右子树全部分给p,只剩左子树",
            "\t}",
            "\tinline void split2(Re &p,Re q,Re L,Re R,Re k){// 取q中的后k个,分到新节点p",
            "\t\ttr[p=++O].S=tr[q].S-k,tr[q].S=k;",
            "\t\tif(L==R)return;",
            "\t\tRe tmp=tr[tr[q].rp].S;",
            "\t\tif(k>tmp)split2(pl,tr[q].lp,L,mid,k-tmp);// q的右子树全部分给p,只剩左子树",
            "\t\telse pl=tr[q].lp,tr[q].lp=0;// 左子树全部分给p",
            "\t\tif(k<tmp)split2(pr,tr[q].rp,mid+1,R,k);// q左子树全部分给p,只剩右子树",
            "\t}",
            "\tinline void dfs(Re p,Re L,Re R){",
            "\t\tif(!p)return;",
            "\t\tif(L==R){cnt[tmp[++tmp[0]]=L]=tr[p].S;return;}",
            "\t\tdfs(pl,L,mid),dfs(pr,mid+1,R);",
            "\t}",
            "}T1;",
            "inline IT split(Re w){",
            "\tIT it=s.lower_bound(QAQ(w));",
            "\tif(it!=s.end()&&it->l==w)return it;",
            "\t--it;",
            "\tRe L=it->l,R=it->r,op=it->op,pt=it->pt,ptt=0;",
            "\ts.erase(it);",
            "\tif(op)T1.split1(ptt,pt,1,m,w-1-L+1);",
            "\telse T1.split2(ptt,pt,1,m,w-1-L+1);",
            "\ts.insert(QAQ(L,w-1,op,pt));",
            "\treturn s.insert(QAQ(w,R,op,ptt)).first;",
            "}",
            "inline void assign(Re l,Re r,Re op){",
            "\tif(l==r)return;",
            "\tIT itr=split(r+1),itl=split(l),it=itl;",
            "\tRe pt=0;",
            "\twhile(it!=itr)pt=T1.merge(pt,it->pt,1,m),it->pt=0,++it;",
            "\ts.erase(itl,itr),s.insert(QAQ(l,r,op,pt));",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),m=n;",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\ts.insert(QAQ(n+1,n+1));",
            "\tfor(Re i=1;i<=n;++i){",
            "\t\tQAQ tmp(i,i,0,0);T1.change(tmp.pt,1,m,A[i]),s.insert(tmp);",
            "\t}",
            "\twhile(T--)in(op),in(l),in(r),op^=1,assign(l,r,op);",
            "\tIT itl=s.lower_bound(QAQ(1)),itr=s.lower_bound(QAQ(n+1));",
            "\twhile(itl!=itr){",
            "\t\ttmp[0]=0,T1.dfs(itl->pt,1,m);",
            "\t\tif(itl->op)for(Re i=1;i<=tmp[0];++i)",
            "\t\t\tfor(Re j=1;j<=cnt[tmp[i]];++j)",
            "\t\t\t\tAns[++Ans[0]]=tmp[i];",
            "\t\telse for(Re i=tmp[0];i>=1;--i)",
            "\t\t\tfor(Re j=1;j<=cnt[tmp[i]];++j)",
            "\t\t\t\tAns[++Ans[0]]=tmp[i];",
            "\t\t++itl;",
            "\t}",
            "\tin(op),printf(\"%d\\n\",Ans[op]);",
            "}",
            ""
        ],
        "description": "插入 线段树分裂-分裂区间前后k个"
    },
    "线段树分裂-分裂指定区间": {
        "prefix": "acm-2.6mid",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=2e5+3;",
            "int n,m,x,y,p,T,op,A[N],pt[N];LL K;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Segment_Tree{",
            "\t#define pl tr[p].lp",
            "\t#define pr tr[p].rp",
            "\t#define mid ((L+R)>>1)",
            "\tint O;",
            "\tstruct QAQ{int lp,rp;LL S;}tr[N*20];",
            "\tinline void pushup(Re p){tr[p].S=tr[pl].S+tr[pr].S;}",
            "\tinline void build(Re &p,Re L,Re R){",
            "\t\tp=++O;",
            "\t\tif(L==R){tr[p].S=A[L];return;}",
            "\t\tbuild(pl,L,mid),build(pr,mid+1,R);",
            "\t\tpushup(p);",
            "\t}",
            "\tinline void change(Re &p,Re L,Re R,Re x,Re v){",
            "\t\tif(!p)p=++O;",
            "\t\tif(L==R){tr[p].S+=v;return;}",
            "\t\tif(x<=mid)change(pl,L,mid,x,v);",
            "\t\telse change(pr,mid+1,R,x,v);",
            "\t\tpushup(p);",
            "\t}",
            "\tinline LL ask(Re p,Re L,Re R,Re l,Re r){",
            "\t\tif(!p)return 0;",
            "\t\tif(l<=L&&R<=r)return tr[p].S;",
            "\t\tLL ans=0;",
            "\t\tif(l<=mid)ans+=ask(pl,L,mid,l,r);",
            "\t\tif(r>mid)ans+=ask(pr,mid+1,R,l,r);",
            "\t\treturn ans;",
            "\t}",
            "\tinline int ask(Re p,Re L,Re R,LL k){",
            "\t\tif(!p||k>tr[p].S)return -1;",
            "\t\tif(L==R)return L;",
            "\t\tLL tmp=tr[pl].S;",
            "\t\tif(tmp>=k)return ask(pl,L,mid,k);",
            "\t\telse return ask(pr,mid+1,R,k-tmp);",
            "\t}",
            "\tinline int merge(Re p,Re q,Re L,Re R){",
            "\t\tif(!p||!q)return p+q;",
            "\t\tif(L==R){tr[p].S+=tr[q].S;return p;}",
            "\t\tpl=merge(pl,tr[q].lp,L,mid);",
            "\t\tpr=merge(pr,tr[q].rp,mid+1,R);",
            "\t\tpushup(p);return p;",
            "\t}",
            "\tinline void split(Re &p,Re &q,Re L,Re R,Re l,Re r){",
            "\t\tif(!q)return;",
            "\t\tif(l<=L&&R<=r){p=q,q=0;return;}",
            "\t\tp=++O;",
            "\t\tif(l<=mid)split(pl,tr[q].lp,L,mid,l,r);",
            "\t\tif(r>mid)split(pr,tr[q].rp,mid+1,R,l,r);",
            "\t\tpushup(p),pushup(q);",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(m),in(T);",
            "\tfor(Re i=1;i<=m;++i)in(A[i]);",
            "\tT1.build(pt[n=1],1,m);",
            "\twhile(T--){",
            "\t\tin(op),in(p);",
            "\t\tif(op<1)in(x),in(y),T1.split(pt[++n],pt[p],1,m,x,y);",
            "\t\telse if(op<2)in(x),pt[p]=T1.merge(pt[p],pt[x],1,m),pt[x]=0;",
            "\t\telse if(op<3)in(x),in(y),T1.change(pt[p],1,m,y,x);",
            "\t\telse if(op<4)in(x),in(y),printf(\"%lld\\n\",T1.ask(pt[p],1,m,x,y));",
            "\t\telse scanf(\"%lld\",&K),printf(\"%d\\n\",T1.ask(pt[p],1,m,K));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 线段树分裂-分裂指定区间"
    },
    "线段树合并": {
        "prefix": "acm-2.6晋升者计数",
        "body": [
            "#include<algorithm>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,logN=17;",
            "int n,m,x,o,T,op,b[N],A[N],Ans[N],head[N];",
            "struct QAQ{int to,next;}a[N];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int pt[N];",
            "struct Segment_Tree{",
            "    #define pl (tr[p].lp)",
            "    #define pr (tr[p].rp)",
            "    #define mid ((L+R)>>1)",
            "    int O;",
            "    struct QAQ{int lp,rp,S;}tr[N*(logN+1)];",
            "    inline void pushup(Re p){tr[p].S=tr[pl].S+tr[pr].S;}",
            "    inline void change(Re &p,Re L,Re R,Re x){",
            "        p=++O,++tr[p].S;",
            "        if(L==R)return;",
            "        if(x<=mid)change(pl,L,mid,x);",
            "        else change(pr,mid+1,R,x);",
            "    }",
            "    inline int merge(Re p,Re q,Re L,Re R){",
            "        if(!p||!q)return p+q;",
            "        if(L==R){tr[p].S+=tr[q].S;return p;}",
            "        pl=merge(pl,tr[q].lp,L,mid);",
            "        pr=merge(pr,tr[q].rp,mid+1,R);",
            "        pushup(p);return p;",
            "    }",
            "    inline int ask(Re &p,Re L,Re R,Re l,Re r){",
            "        if(!p)return 0;",
            "        if(l<=L&&R<=r)return tr[p].S;",
            "        Re ans=0;",
            "        if(l<=mid)ans+=ask(pl,L,mid,l,r);",
            "        if(r>mid)ans+=ask(pr,mid+1,R,l,r);",
            "        return ans;",
            "    }",
            "}TR;",
            "inline void dfs(Re x,Re fa){",
            "    TR.change(pt[x],1,m,A[x]);",
            "    for(Re i=head[x],to;i;i=a[i].next)",
            "        dfs(to=a[i].to,x),pt[x]=TR.merge(pt[x],pt[to],1,m);",
            "    if(A[x]<m)Ans[x]=TR.ask(pt[x],1,m,A[x]+1,m);",
            "}",
            "int main(){",
            "    in(n);",
            "    for(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];",
            "    sort(b+1,b+n+1),m=unique(b+1,b+n+1)-b-1;",
            "    for(Re i=1;i<=n;++i)A[i]=lower_bound(b+1,b+m+1,A[i])-b;",
            "    for(Re i=2;i<=n;++i)in(x),add(x,i);",
            "    dfs(1,0);",
            "    for(Re i=1;i<=n;++i)printf(\"%d\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 线段树合并"
    },
    "超哥线段树": {
        "prefix": "acm-2.6Blue Mary开公司",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LD double",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,M=5e4;",
            "int n,x,T;LD b[N],k[N];char s[20];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline LD y(Re id,Re x){return k[id]*x+b[id];}",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tint tr[N<<2];",
            "\tinline void change(Re p,Re L,Re R,Re id){",
            "\t\tif(y(id,L)>y(tr[p],L)&&y(id,R)>y(tr[p],R)){tr[p]=id;return;}",
            "\t\tif(y(id,L)<=y(tr[p],L)&&y(id,R)<=y(tr[p],R))return;",
            "//\t\tif(L==R){if(y(id,L)>y(tr[p],L))tr[p]=id;return;}",
            "\t\tif(k[tr[p]]<k[id]){",
            "\t\t\tif(y(id,mid+1)>y(tr[p],mid+1))change(pl,L,mid,tr[p]),tr[p]=id;",
            "\t\t\telse change(pr,mid+1,R,id);",
            "\t\t}",
            "\t\telse{",
            "\t\t\tif(y(id,mid)>y(tr[p],mid))change(pr,mid+1,R,tr[p]),tr[p]=id;",
            "\t\t\telse change(pl,L,mid,id);",
            "\t\t}",
            "\t}",
            "\tinline LD ask(Re p,Re L,Re R,Re x){",
            "\t\tif(L==R)return y(tr[p],x);",
            "\t\tLD ans=y(tr[p],x);",
            "\t\tif(x<=mid)return max(ans,ask(pl,L,mid,x));",
            "\t\telse return max(ans,ask(pr,mid+1,R,x));",
            "\t}",
            "}TR;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(T);",
            "\twhile(T--){",
            "\t\tscanf(\"%s\",s);",
            "        if(s[0]=='P')++n,scanf(\"%lf%lf\",&b[n],&k[n]),TR.change(1,1,M,n);",
            "        else in(x),printf(\"%d\\n\",(int)(TR.ask(1,1,M,x-1)/100));",
            "\t}",
            "}",
            ""
        ],
        "description": "插入 超哥线段树"
    },
    "二逼平衡树": {
        "prefix": "acm-2.6树套树(有注释",
        "body": [
            "#pragma GCC optimize(2)",
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define mid (L+R>>1)",
            "#define Re register int",
            "#define pl tree[p].lp",
            "#define pr tree[p].rp",
            "#define F(i,a,b) for(Re i=a;i<=b;++i)",
            "#define lo(o) lower_bound(b+1,b+m+1,o)-b",
            "using namespace std;",
            "const int N=1e5+3,inf=2147483647;",
            "int x,y,z,n,m,T,t,fu,cnt,tl,tr,a[N],b[N],pt[N],C[N],opt[N],ptl[20],ptr[20]; ",
            "struct QAQ{int g,lp,rp;}tree[N*250];",
            "struct O_O{int l,r,k;}Q[N];",
            "struct T_T{int i,x;}c[N];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline int ask_kth(Re L,Re R,Re k){",
            "    if(L==R)return b[R];",
            "    Re tmp=0;",
            "    F(i,1,tl)tmp-=tree[tree[ptl[i]].lp].g;",
            "    F(i,1,tr)tmp+=tree[tree[ptr[i]].lp].g;",
            "    if(tmp>=k){",
            "    \tF(i,1,tl)ptl[i]=tree[ptl[i]].lp;",
            "    \tF(i,1,tr)ptr[i]=tree[ptr[i]].lp;",
            "    \treturn ask_kth(L,mid,k);",
            "    }",
            "    else{",
            "    \tF(i,1,tl)ptl[i]=tree[ptl[i]].rp;",
            "    \tF(i,1,tr)ptr[i]=tree[ptr[i]].rp;",
            "    \treturn ask_kth(mid+1,R,k-tmp);",
            "    }",
            "}",
            "inline int ask_kth_pre(Re L,Re R,Re k){",
            "    tl=tr=0;",
            "    for(Re i=L-1;i;i-=i&-i)ptl[++tl]=pt[i];",
            "    for(Re i=R;i;i-=i&-i)ptr[++tr]=pt[i];",
            "    return ask_kth(1,m,k);",
            "}",
            "inline void add(Re &p,Re L,Re R,Re w,Re v){",
            "    if(!p)p=++cnt;tree[p].g+=v;",
            "    if(L==R)return;",
            "    if(w<=mid)add(pl,L,mid,w,v);",
            "    else add(pr,mid+1,R,w,v);",
            "}",
            "inline void add_pre(Re x,Re v){",
            "    Re w=lo(a[x]);",
            "    for(Re i=x;i<=n;i+=i&-i)add(pt[i],1,m,w,v);",
            "}",
            "inline int ask_level(Re p,Re L,Re R,Re x){",
            "\tif(L==R)return tree[p].g; ",
            "\tif(x<=mid)return ask_level(pl,L,mid,x);",
            "\telse return tree[pl].g+ask_level(pr,mid+1,R,x);",
            "}",
            "inline int ask_level_pre(Re L,Re R,Re w){",
            "\tRe ans=0;",
            "    for(Re i=R;i;i-=i&-i)ans+=ask_level(pt[i],1,m,w);",
            "    for(Re i=L-1;i;i-=i&-i)ans-=ask_level(pt[i],1,m,w);",
            "    return ans;",
            "}",
            "int main(){",
            "//\tprintf(\"%lf\\n\",(sizeof(tree))/1024.0/1024.0);",
            "//\tprintf(\"%lf\\n\",(sizeof(tree)+sizeof(Q)+sizeof(c)+sizeof(a)+sizeof(b)+sizeof(pt)+sizeof(C))/1024.0/1024.0);",
            "\tin(n),in(T),m=n;",
            "    F(i,1,n)in(a[i]),b[i]=a[i];",
            "    F(i,1,T){",
            "    \tin(opt[i]);",
            "    \tif(opt[i]==3)in(c[i].i),in(c[i].x),b[++m]=c[i].x;",
            "    \telse{",
            "    \t\tin(Q[i].l),in(Q[i].r),in(Q[i].k);",
            "    \t\tif(opt[i]!=2)b[++m]=Q[i].k;",
            "\t\t}",
            "    }",
            "    sort(b+1,b+m+1);",
            "    m=unique(b+1,b+m+1)-b-1;",
            "    F(i,1,n)add_pre(i,1);",
            "    F(i,1,T){",
            "    \tif(opt[i]==1)",
            "    \t\tQ[i].k=lo(Q[i].k),",
            "\t\t\tprintf(\"%d\\n\",ask_level_pre(Q[i].l,Q[i].r,Q[i].k-1)+1);",
            "",
            "    \tif(opt[i]==2)",
            "    \t\tprintf(\"%d\\n\",ask_kth_pre(Q[i].l,Q[i].r,Q[i].k));",
            "",
            "\t\tif(opt[i]==3)",
            "\t\t\tadd_pre(c[i].i,-1),a[c[i].i]=c[i].x,add_pre(c[i].i,1);",
            "",
            "\t\tif(opt[i]==4){",
            "\t\t}",
            "",
            "\t\tif(opt[i]==5){",
            "\t\t}",
            "    }",
            "}",
            ""
        ],
        "description": "插入 二逼平衡树"
    },
    "整体DP": {
        "prefix": "acm-2.6Minimax",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=3e5+3,P=998244353;",
            "int n,m,x,ans,inv1e4,f[N],b[N],p[N],A[N],fa[N],ch[N][3];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline int mi(Re x,Re k){",
            "\tRe s=1;",
            "\twhile(k){",
            "\t\tif(k&1)s=(LL)s*x%P;",
            "\t\tx=(LL)x*x%P,k>>=1;",
            "\t}",
            "\treturn s;",
            "}",
            "inline int inv(Re x){return mi(x,P-2);}",
            "int pt[N];",
            "struct Segment_Tree{",
            "\t#define pl tr[p].lp",
            "\t#define pr tr[p].rp",
            "\t#define mid ((L+R)>>1)",
            "\tint O;",
            "\tstruct QAQ{int S,lp,rp,mul;}tr[N*19];",
            "\tinline void pushup(Re p){",
            "\t\ttr[p].S=(tr[pl].S+tr[pr].S)%P;",
            "\t}",
            "\tinline void updata(Re p,Re v){",
            "\t\ttr[p].S=(LL)tr[p].S*v%P,tr[p].mul=(LL)tr[p].mul*v%P;",
            "\t}",
            "\tinline void pushdown(Re p){",
            "\t\tif(tr[p].mul!=1)updata(pl,tr[p].mul),updata(pr,tr[p].mul),tr[p].mul=1;",
            "\t}",
            "\tinline void change(Re &p,Re L,Re R,Re x,Re v){",
            "\t\tif(!p)p=++O;tr[p].mul=1;",
            "\t\tif(L==R){tr[p].S=v;return;}",
            "\t\tpushdown(p);",
            "\t\tif(x<=mid)change(pl,L,mid,x,v);",
            "\t\telse change(pr,mid+1,R,x,v);",
            "\t\tpushup(p);",
            "\t}",
            "\tinline int merge(Re p,Re q,Re pv,Re qv,Re v){",
            "//\t\tprintf(\"pv=%d, qv=%d, v=%d\\n\",pv,qv,v);",
            "\t\tif(!p&&!q)return 0;",
            "\t\tif(!p){updata(q,qv);return q;}",
            "\t\tif(!q){updata(p,pv);return p;}",
            "\t\tpushdown(p),pushdown(q);",
            "\t\tRe plS=tr[pl].S,prS=tr[pr].S,qlS=tr[tr[q].lp].S,qrS=tr[tr[q].rp].S;",
            "//\t\tprintf(\"p:%d,%d q:%d,%d\\n\",tr[pl].S,tr[pr].S,tr[tr[q].lp].S,tr[tr[q].rp].S);",
            "\t\tpl=merge(pl,tr[q].lp,(pv+(1-v+P)%P*1ll*qrS%P)%P,(qv+(1-v+P)%P*1ll*prS%P)%P,v);",
            "\t\tpr=merge(pr,tr[q].rp,(pv+(LL)v*qlS%P)%P,(qv+(LL)v*plS%P)%P,v);",
            "\t\tpushup(p);",
            "\t\treturn p;",
            "\t}",
            "\tinline void dfs_(Re p,Re L,Re R){",
            "\t\tif(!p)return;",
            "\t\tif(L==R){f[L]=tr[p].S;return;}",
            "\t\tpushdown(p),dfs_(pl,L,mid),dfs_(pr,mid+1,R);",
            "\t}",
            "\tinline int ask(Re p,Re L,Re R,Re x){",
            "\t\tif(!p)return 0;",
            "\t\tif(L==R)return tr[p].S;",
            "\t\tpushdown(p);",
            "\t\tif(x<=mid)return ask(pl,L,mid,x);",
            "\t\telse return ask(pr,mid+1,R,x);",
            "\t}",
            "}T1;",
            "inline void dfs(Re x){",
            "\tif(!ch[x][0])T1.change(pt[x],1,m,A[x],1);",
            "\telse{",
            "//\t\tprintf(\"x=%d:\\n\",x);",
            "//\t\tfor(Re i=1;i<=m;++i)printf(\"%d \",T1.ask(pt[x],1,m,i));puts(\"\");",
            "\t\tdfs(ch[x][1]);",
            "\t\tif(ch[x][0]<2)pt[x]=pt[ch[x][1]];",
            "\t\telse dfs(ch[x][2]),pt[x]=T1.merge(pt[ch[x][1]],pt[ch[x][2]],0,0,p[x]);",
            "//\t\tprintf(\"x=%d:\\n\",x);",
            "//\t\tfor(Re i=1;i<=m;++i)printf(\"%d \",T1.ask(pt[x],1,m,i));puts(\"\");",
            "\t}",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),inv1e4=inv(10000);",
            "\tfor(Re i=1;i<=n;++i)in(fa[i]),ch[fa[i]][++ch[fa[i]][0]]=i;",
            "\tfor(Re i=1;i<=n;++i)",
            "\t\tif(ch[i][0])in(p[i]),p[i]=(LL)p[i]*inv1e4%P;",
            "\t\telse in(x),b[++m]=A[i]=x;",
            "\tsort(b+1,b+m+1);",
            "\tfor(Re i=1;i<=n;++i)if(!ch[i][0])A[i]=lower_bound(b+1,b+m+1,A[i])-b;",
            "//\tfor(Re i=1;i<=n;++i)if(!ch[i][0])printf(\"%d: %d\\n\",i,A[i]);",
            "\tdfs(1),T1.dfs_(1,1,m);",
            "//\tfor(Re i=1;i<=m;++i)printf(\"%d \",f[i]);puts(\"\");",
            "\tfor(Re i=1;i<=m;++i)(ans+=(LL)i*b[i]%P*f[i]%P*f[i]%P)%=P;",
            "\tprintf(\"%d\\n\",ans);",
            "}",
            ""
        ],
        "description": "插入 整体DP"
    },
    "线段树分治 (冰茶姬+线性基 查询两点最短异或和路径) (Shortest Path Queries)": {
        "prefix": "acm-2.6时间分治",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<stack>",
            "#include<map>",
            "#define LL long long",
            "#define Re register int",
            "#define mp make_pair",
            "using namespace std;",
            "const int N=2e5+3,logN=30;",
            "int x,y,n,m,T,op,X[N],Y[N],OP[N];LL Ans[N];map<pair<int,int>,int>last,z;",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "struct Union{// 冰茶姬（并查集）",
            "\tstruct BK{int x,y,dx,dy,sx,sy;BK(Re X=0,Re d1=0,Re S1=0,Re Y=0,Re d2=0,Re S2=0){x=X,y=Y,sx=S1,sy=S2,dx=d1,dy=d2;}};",
            "\tint fa[N],dis[N],size[N];stack<BK>Q;",
            "\tinline int find(Re x){return fa[x]==x?x:find(fa[x]);}",
            "\tinline int Dis(Re x){return fa[x]==x?0:dis[x]^Dis(fa[x]);}",
            "\tinline void merge(Re x,Re y,Re w){// 启发式合并",
            "\t\tif(size[x]>size[y])swap(x,y);",
            "\t\tQ.push(BK(x,dis[x],size[x],y,dis[y],size[y]));",
            "\t\tfa[x]=y,dis[x]=w,size[y]+=size[x];",
            "\t}",
            "\tinline void back(Re to){// 撤销操作",
            "\t\twhile(int(Q.size())>to){",
            "\t\t\tBK a=Q.top();Re x=a.x,y=a.y;Q.pop();",
            "\t\t\tfa[x]=x,dis[x]=a.dx,size[x]=a.sx;",
            "\t\t\tfa[y]=y,dis[y]=a.dy,size[y]=a.sy;",
            "\t\t}",
            "\t}",
            "}TF;",
            "struct Line_JI{",
            "\tint p[31];stack<int>Q;",
            "\tinline void insert(Re x){",
            "\t\tfor(Re i=logN;i>=0;--i)",
            "\t\t\tif((x>>i)&1){",
            "\t\t\t\tif(!p[i]){p[i]=x,Q.push(i);break;}",
            "\t\t\t\tx^=p[i];",
            "\t\t\t}",
            "\t}",
            "\tinline int ask(Re x){for(Re i=logN;i>=0;--i)if(p[i])x=min(x,x^p[i]);return x;}",
            "\tinline void back(Re to){",
            "\t\twhile(int(Q.size())>to)p[Q.top()]=0,Q.pop();",
            "\t}",
            "}JI;",
            "int o,head[N<<2];",
            "struct QAQ{int x,y,w,next;}a[N*50];",
            "inline void add(Re x,Re y1,Re y2,Re w){a[++o].w=w,a[o].x=y1,a[o].y=y2,a[o].next=head[x],head[x]=o;}",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re y,Re v){",
            "\t\tif(l>r)return;",
            "\t\tif(l<=L&&R<=r){add(p,x,y,v);return;}",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,x,y,v);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,x,y,v);",
            "\t}",
            "\tinline void dfs(Re p,Re L,Re R){",
            "\t\tRe tmp1=TF.Q.size(),tmp2=JI.Q.size();",
            "\t\tfor(Re i=head[p];i;i=a[i].next){",
            "\t\t\tRe x=TF.find(a[i].x),y=TF.find(a[i].y),w=TF.Dis(a[i].x)^TF.Dis(a[i].y)^a[i].w;",
            "\t\t\tif(x!=y)TF.merge(x,y,w);",
            "\t\t\telse JI.insert(w);",
            "\t\t}",
            "\t\tif(L==R){if(OP[L])Ans[L]=JI.ask(TF.Dis(X[L])^TF.Dis(Y[L]));}",
            "\t\telse dfs(pl,L,mid),dfs(pr,mid+1,R);",
            "\t\tTF.back(tmp1),JI.back(tmp2);",
            "\t}",
            "}T1;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m);",
            "\tfor(Re i=1;i<=n;++i)TF.fa[i]=i,TF.size[i]=1;",
            "\tfor(Re i=1;i<=m;++i){",
            "\t\tin(x),in(y);if(x>y)swap(x,y);",
            "\t\tin(z[mp(x,y)]),last[mp(x,y)]=1;",
            "\t}",
            "\tin(T);",
            "\tfor(Re i=1;i<=T;++i){",
            "\t\tin(op),in(x),in(y);if(x>y)swap(x,y);",
            "\t\tif(op<2)in(z[mp(x,y)]),last[mp(x,y)]=i;",
            "\t\telse if(op<3)T1.change(1,1,T,last[mp(x,y)],i-1,x,y,z[mp(x,y)]),last.erase(last.find(mp(x,y)));",
            "\t\telse OP[i]=1,X[i]=x,Y[i]=y;",
            "\t}",
            "\tfor(map<pair<int,int>,int>::iterator it=last.begin();it!=last.end();++it)",
            "\t\tT1.change(1,1,T,it->second,T,it->first.first,it->first.second,z[it->first]);",
            "\tT1.dfs(1,1,T);",
            "\tfor(Re i=1;i<=T;++i)if(OP[i])printf(\"%lld\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 线段树分治 (冰茶姬+线性基 查询两点最短异或和路径) (Shortest Path Queries)"
    },
    "线段树分治 (可持久化Trie+CDQ) (火星商店问题)": {
        "prefix": "acm-2.6时间分治",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<vector>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,logN=18;",
            "int n,x,y,z,w,op,m1,m2,T,A[N],t1[N],t2[N],Ans[N];",
            "struct Change{int i,v,t;inline bool operator<(const Change &O)const{return i<O.i;}}C[N],tmp[N];",
            "struct Query{int x,l,r,id;}Q[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "int pt[N];",
            "struct Trie{",
            "\tint O,cnt[N*(logN+2)],tr[N*(logN+2)][2];",
            "\tinline void insert(Re p,Re q,Re o,Re x){",
            "\t\tif(o<0)return;Re i=(x>>o)&1;",
            "\t\ttr[p][i]=++O,tr[p][i^1]=tr[q][i^1];",
            "\t\tcnt[tr[p][i]]=cnt[tr[q][i]]+1;",
            "\t\tinsert(tr[p][i],tr[q][i],o-1,x);",
            "\t}",
            "\tinline int ask(Re p,Re q,Re o,Re x){",
            "\t\tif(o<0)return 0;Re i=(x>>o)&1;",
            "\t\tif(cnt[tr[q][i^1]]>cnt[tr[p][i^1]])return (1<<o)+ask(tr[p][i^1],tr[q][i^1],o-1,x);",
            "\t\telse return ask(tr[p][i],tr[q][i],o-1,x);",
            "\t}",
            "}T1;",
            "struct Segment_Tree{",
            "\t#define pl (p<<1)",
            "\t#define pr (p<<1|1)",
            "\t#define mid ((L+R)>>1)",
            "\tvector<Query>tr[N<<2];",
            "\tinline void change(Re p,Re L,Re R,Re l,Re r,Query &v){",
            "\t\tif(l>r)return;",
            "\t\tif(l<=L&&R<=r){tr[p].push_back(v);return;}",
            "\t\tif(l<=mid)change(pl,L,mid,l,r,v);",
            "\t\tif(r>mid)change(pr,mid+1,R,l,r,v);",
            "\t}",
            "\tinline int find1(Re l,Re r,Re id){",
            "\t\tif(C[r].i<id)return r+1;",
            "\t\twhile(l<r){",
            "\t\t\tRe Mid=l+r>>1;",
            "\t\t\tif(C[Mid].i>=id)r=Mid;",
            "\t\t\telse l=Mid+1;",
            "\t\t}",
            "\t\treturn r;",
            "\t}",
            "\tinline int find2(Re l,Re r,Re id){",
            "\t\tif(C[r].i<=id)return r+1;",
            "\t\twhile(l<r){",
            "\t\t\tRe Mid=l+r>>1;",
            "\t\t\tif(C[Mid].i>id)r=Mid;",
            "\t\t\telse l=Mid+1;",
            "\t\t}",
            "\t\treturn r;",
            "\t}",
            "\tinline void CDQ(Re p,Re L,Re R,Re l,Re r){",
            "\t\tif(l>r)return;",
            "\t\tT1.O=pt[l-1]=0;",
            "\t\tfor(Re i=l;i<=r;++i)T1.insert(pt[i]=++T1.O,pt[i-1],logN,C[i].v);",
            "\t\tfor(vector<Query>::iterator it=tr[p].begin();it!=tr[p].end();++it){",
            "\t\t\tRe ll=find1(l,r,it->l)-1,rr=find2(l,r,it->r)-1;",
            "\t\t\tif(ll<rr)Ans[it->id]=max(Ans[it->id],T1.ask(pt[ll],pt[rr],logN,it->x));",
            "\t\t}",
            "\t\tif(L==R)return;",
            "\t\tRe p1=l-1;for(Re i=l;i<=r;++i)if(C[i].t<=mid)tmp[++p1]=C[i];",
            "\t\tRe p2=p1;for(Re i=l;i<=r;++i)if(C[i].t>mid)tmp[++p2]=C[i];",
            "\t\tfor(Re i=l;i<=r;++i)C[i]=tmp[i];",
            "\t\tCDQ(pl,L,mid,l,p1),CDQ(pr,mid+1,R,p1+1,r);",
            "\t}",
            "}TR;",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T);",
            "\tfor(Re i=1;i<=n;++i)in(A[i]),T1.insert(pt[i]=++T1.O,pt[i-1],logN,A[i]);",
            "\tfor(Re i=1;i<=T;++i){",
            "\t\tin(op),in(x),in(y);",
            "\t\tif(!op)++m1,C[m1]=(Change){x,y,m1};",
            "\t\telse in(z),in(w),++m2,Q[m2]=(Query){z,x,y,m2},t1[m2]=max(1,m1-w+1),t2[m2]=m1;",
            "\t}",
            "\tfor(Re i=1;i<=m2;++i)Ans[i]=T1.ask(pt[Q[i].l-1],pt[Q[i].r],logN,Q[i].x),TR.change(1,1,m1,t1[i],t2[i],Q[i]);",
            "\tsort(C+1,C+m1+1),TR.CDQ(1,1,m1,1,m1);",
            "\tfor(Re i=1;i<=m2;++i)printf(\"%d\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 线段树分治 (可持久化Trie+CDQ) (火星商店问题)"
    },
    "回滚莫队": {
        "prefix": "acm-2.9歴史の研究",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,M=1e5+3;",
            "int n,m,T,BL,BLN,A[N],b[N],Li[325],Ri[325],cnt[N],cnt_[N],belong[N];LL Ans[M];",
            "struct Query{",
            "\tint l,r,id;",
            "\tinline bool operator<(const Query &O)const{",
            "\t\tRe B1=belong[l],B2=belong[O.l];",
            "\t\treturn B1!=B2?B1<B2:r<O.r;",
            "\t}",
            "}Q[M];",
            "inline void in(Re &x){",
            "    Re fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),BL=sqrt(n)+1,BLN=n/BL+1;",
            "\tfor(Re i=1;i<=BLN;++i){",
            "\t\tLi[i]=(i-1)*BL+1,Ri[i]=min(i*BL,n);",
            "\t\tfor(Re j=Li[i];j<=Ri[i];++j)belong[j]=i;",
            "\t}",
            "\tfor(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];",
            "\tsort(b+1,b+n+1),m=unique(b+1,b+n+1)-b-1;",
            "\tfor(Re i=1;i<=n;++i)A[i]=lower_bound(b+1,b+m+1,A[i])-b;",
            "\tfor(Re i=1;i<=T;++i)in(Q[i].l),in(Q[i].r),Q[i].id=i;",
            "\tsort(Q+1,Q+T+1);Re i=1;",
            "\tfor(Re p=1;p<=BLN;++p){",
            "\t\tRe nowL=Ri[p]+1,nowR=Ri[p];LL ans=0;",
            "\t\tmemset(cnt,0,sizeof(cnt));",
            "\t\twhile(belong[Q[i].l]==p){",
            "\t\t\tRe L=Q[i].l,R=Q[i].r;",
            "\t\t\tif(belong[L]==belong[R]){",
            "\t\t\t\tLL tmp=0;",
            "\t\t\t\tfor(Re j=L;j<=R;++j)cnt_[A[j]]=0;",
            "\t\t\t\tfor(Re j=L;j<=R;++j)++cnt_[A[j]],tmp=max(tmp,(LL)b[A[j]]*cnt_[A[j]]);",
            "\t\t\t\tAns[Q[i].id]=tmp;",
            "\t\t\t}",
            "\t\t\telse{",
            "\t\t\t\twhile(nowR<R)cnt[A[++nowR]]++,ans=max(ans,(LL)b[A[nowR]]*cnt[A[nowR]]);",
            "\t\t\t\tLL tmp=ans;",
            "\t\t\t\twhile(nowL>L)cnt[A[--nowL]]++,tmp=max(tmp,(LL)b[A[nowL]]*cnt[A[nowL]]);",
            "\t\t\t\tAns[Q[i].id]=tmp;",
            "\t\t\t\twhile(nowL<Ri[p]+1)--cnt[A[nowL++]];",
            "\t\t\t}",
            "\t\t\t++i;",
            "\t\t}",
            "\t}",
            "\tfor(Re i=1;i<=T;++i)printf(\"%lld\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 回滚莫队"
    },
    "带修莫队": {
        "prefix": "acm-2.9数颜色／维护队列",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define Re register int",
            "using namespace std;",
            "const int N=2e5+3,M=2e5+3,INF=1e6+3;",
            "int n,x,y,T,TQ,TC,BL,ans,a[N],Ans[M],cnt[INF];char op;",
            "struct Query{",
            "    int l,r,id,time;",
            "    inline bool operator<(const Query &O)const{",
            "        Re B1=l/BL,B2=O.l/BL,B3=r/BL,B4=O.r/BL;",
            "        return B1!=B2?B1<B2:(B3!=B4?B3<B4:time<O.time);",
            "    }",
            "}Q[N];",
            "struct Change{int w,co;}C[N];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x){ans+=!cnt[x]++;}",
            "inline void del(Re x){ans-=!--cnt[x];}",
            "int main(){",
            "//    freopen(\"123.txt\",\"r\",stdin);",
            "    in(n),in(T),BL=pow(n,2.0/3.0);",
            "    for(Re i=1;i<=n;++i)in(a[i]);",
            "    for(Re i=1;i<=T;++i){",
            "    \tscanf(\" %c\",&op);",
            "    \tin(x),in(y);",
            "    \tif(op=='Q')++TQ,Q[TQ]=(Query){x,y,TQ,TC};",
            "    \telse C[++TC]=(Change){x,y};",
            "\t}",
            "    sort(Q+1,Q+TQ+1);",
            "    Re nowL=1,nowR=0,nowT=0;",
            "    for(Re i=1;i<=TQ;++i){",
            "        while(nowL<Q[i].l)del(a[nowL++]);",
            "        while(nowL>Q[i].l)add(a[--nowL]);",
            "        while(nowR>Q[i].r)del(a[nowR--]);",
            "        while(nowR<Q[i].r)add(a[++nowR]);",
            "        while(nowT<Q[i].time){",
            "        \tRe w=C[++nowT].w;",
            "        \tif(nowL<=w&&w<=nowR)del(a[w]),add(C[nowT].co);",
            "        \tswap(a[w],C[nowT].co);",
            "\t\t}",
            "\t\twhile(nowT>Q[i].time){",
            "\t\t\tRe w=C[nowT].w;",
            "        \tif(nowL<=w&&w<=nowR)del(a[w]),add(C[nowT].co);",
            "        \tswap(a[w],C[nowT--].co);",
            "\t\t}",
            "        Ans[Q[i].id]=ans;",
            "    }",
            "    for(Re i=1;i<=TQ;++i)printf(\"%d\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 带修莫队"
    },
    "树上带修莫队": {
        "prefix": "acm-2.9糖果公园",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=1e5+3,M=1e5+3,logN=17;",
            "int n,m,x,y,o,T,op,id_O,A[N],V[N],W[N],B[N],head[N],last[N],first[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    Re fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct LCA{",
            "\tint deep[N],ant[N][20];",
            "\tinline void dfs(Re x,Re fa){",
            "\t\tfirst[B[++B[0]]=x]=++id_O;",
            "\t\tdeep[x]=deep[ant[x][0]=fa]+1;",
            "\t\tfor(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];",
            "\t\tfor(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);",
            "\t\tlast[B[++B[0]]=x]=++id_O;",
            "\t}",
            "\tinline int lca(Re x,Re y){",
            "\t\tif(deep[x]<deep[y])swap(x,y);",
            "\t\tfor(Re i=logN;i>=0;--i)if(deep[ant[x][i]]>=deep[y])x=ant[x][i];",
            "\t\tif(x==y)return x;",
            "\t\tfor(Re i=logN;i>=0;--i)if(ant[x][i]!=ant[y][i])x=ant[x][i],y=ant[y][i];",
            "\t\treturn ant[x][0];",
            "\t}",
            "}T1;",
            "int BL,TQ,TC,vis[N],cnt[N];LL ans,Ans[M];",
            "struct Query{",
            "\tint l,r,id,lca,time;",
            "\tinline bool operator<(const Query &O)const{",
            "\t\tRe B1=l/BL,B2=O.l/BL,B3=r/BL,B4=O.r/BL;",
            "\t\treturn B1!=B2?B1<B2:(B3!=B4?B3<B4:time<O.time);",
            "\t}",
            "}Q[M];",
            "struct Change{int w,co;}C[M];",
            "inline void change(Re x){",
            "\tvis[x]?ans-=(LL)V[A[x]]*W[cnt[A[x]]--]:ans+=(LL)V[A[x]]*W[++cnt[A[x]]],vis[x]^=1;",
            "}",
            "int main(){",
            "\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(m),in(T),BL=pow(n<<1,2.0/3.0);",
            "\tfor(Re i=1;i<=m;++i)in(V[i]);",
            "\tfor(Re i=1;i<=n;++i)in(W[i]);",
            "\tfor(Re i=1;i<n;++i)in(x),in(y),add(x,y),add(y,x);",
            "\tfor(Re i=1;i<=n;++i)in(A[i]);",
            "\tT1.dfs(1,0);",
            "\tfor(Re i=1;i<=T;++i){",
            "\t\tin(op),in(x),in(y);",
            "\t\tif(op){",
            "\t\t\tRe lca=T1.lca(x,y);",
            "\t\t\tif(first[x]>first[y])swap(x,y);",
            "\t\t\tif(lca==x)++TQ,Q[TQ]=(Query){first[x],first[y],TQ,0,TC};",
            "\t\t\telse ++TQ,Q[TQ]=(Query){last[x],first[y],TQ,lca,TC};",
            "\t\t}",
            "\t\telse C[++TC]=(Change){x,y};",
            "\t}",
            "\tsort(Q+1,Q+TQ+1);",
            "\tRe nowL=1,nowR=0,nowT=0;",
            "\tfor(Re i=1;i<=TQ;++i){",
            "\t\tRe L=Q[i].l,R=Q[i].r,T=Q[i].time,lca=Q[i].lca;",
            "\t\twhile(nowL<L)change(B[nowL++]);",
            "\t\twhile(nowL>L)change(B[--nowL]);",
            "\t\twhile(nowR>R)change(B[nowR--]);",
            "\t\twhile(nowR<R)change(B[++nowR]);",
            "\t\twhile(nowT<T){",
            "\t\t\tRe w=C[++nowT].w;",
            "\t\t\tif(vis[w])change(w),swap(A[w],C[nowT].co),change(w);",
            "\t\t\telse swap(A[w],C[nowT].co);",
            "\t\t}",
            "\t\twhile(nowT>T){",
            "\t\t\tRe w=C[nowT].w;",
            "\t\t\tif(vis[w])change(w),swap(A[w],C[nowT].co),change(w);",
            "\t\t\telse swap(A[w],C[nowT].co);",
            "\t\t\t--nowT;",
            "\t\t}",
            "\t\tif(lca)change(lca);",
            "\t\tAns[Q[i].id]=ans;",
            "\t\tif(lca)change(lca);",
            "\t}",
            "\tfor(Re i=1;i<=TQ;++i)printf(\"%lld\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 树上带修莫队"
    },
    "树上静态莫队": {
        "prefix": "acm-2.9Count on a tree II",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=4e4+3,M=1e5+3,INF=1e6+3,logN=16;",
            "int n,m,o,x,y,T,BL,id_O,b[N],A[N],B[N<<1],head[N],last[N],first[N];",
            "struct QAQ{int to,next;}a[N<<1];",
            "inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}",
            "inline void in(Re &x){",
            "    Re fu=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "struct LCA{",
            "\tint deep[N],ant[N][20];",
            "\tinline void dfs(Re x,Re fa){",
            "\t\tfirst[B[++B[0]]=x]=++id_O;",
            "\t\tdeep[x]=deep[ant[x][0]=fa]+1;",
            "\t\tfor(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];",
            "\t\tfor(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);",
            "\t\tlast[B[++B[0]]=x]=++id_O;",
            "\t}",
            "\tinline int lca(Re x,Re y){",
            "\t\tif(deep[x]<deep[y])swap(x,y);",
            "\t\tfor(Re i=logN;i>=0;--i)if(deep[ant[x][i]]>=deep[y])x=ant[x][i];",
            "\t\tif(x==y)return x;",
            "\t\tfor(Re i=logN;i>=0;--i)if(ant[x][i]!=ant[y][i])x=ant[x][i],y=ant[y][i];",
            "\t\treturn ant[x][0];",
            "\t}",
            "}T1;",
            "struct Query{",
            "\tint l,r,id,lca;",
            "\tinline bool operator<(const Query &O)const{",
            "\t\tRe B1=l/BL,B2=O.l/BL;",
            "\t\treturn B1!=B2?B1<B2:((B1&1)?r<O.r:r>O.r);",
            "\t}",
            "}Q[M];",
            "int ans,vis[N<<1],Ans[M],cnt[INF];",
            "inline void change(Re x){",
            "\tvis[x]?ans-=!--cnt[A[x]]:ans+=!cnt[A[x]]++,vis[x]^=1;",
            "}",
            "int main(){",
            "//\tfreopen(\"123.txt\",\"r\",stdin);",
            "\tin(n),in(T),BL=sqrt(n<<1);",
            "\tfor(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];",
            "\tsort(b+1,b+n+1),m=unique(b+1,b+n+1)-b-1;",
            "\tfor(Re i=1;i<=n;++i)A[i]=lower_bound(b+1,b+m+1,A[i])-b;",
            "\tm=n-1;while(m--)in(x),in(y),add(x,y),add(y,x);",
            "\tT1.dfs(1,0);",
            "\tfor(Re i=1;i<=T;++i){",
            "\t\tin(x),in(y);Re lca=T1.lca(x,y);",
            "\t\tif(first[x]>first[y])swap(x,y);",
            "\t\tif(lca==x)Q[i]=(Query){first[x],first[y],i,0};",
            "\t\telse Q[i]=(Query){last[x],first[y],i,lca};",
            "\t}",
            "\tsort(Q+1,Q+T+1);",
            "\tRe nowL=1,nowR=0;",
            "\tfor(Re i=1;i<=T;++i){",
            "\t\tRe L=Q[i].l,R=Q[i].r,lca=Q[i].lca;",
            "\t\twhile(nowL<L)change(B[nowL++]);",
            "\t\twhile(nowL>L)change(B[--nowL]);",
            "\t\twhile(nowR>R)change(B[nowR--]);",
            "\t\twhile(nowR<R)change(B[++nowR]);",
            "\t\tif(lca)change(lca);",
            "\t\tAns[Q[i].id]=ans;",
            "\t\tif(lca)change(lca);",
            "\t}",
            "\tfor(Re i=1;i<=T;++i)printf(\"%d\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 树上静态莫队"
    },
    "静态莫队": {
        "prefix": "acm-2.9D-query",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=3e4+3,M=2e5+3;",
            "int n,T,BL,ans,A[N],cnt[1000003],Ans[M];",
            "struct Query{",
            "    int l,r,id;",
            "    inline bool operator<(const Query &O)const{",
            "        Re B1=l/BL,B2=O.l/BL;",
            "        return B1!=B2?B1<B2:((B1&1)?r<O.r:r>O.r);",
            "    }",
            "}Q[M];",
            "inline void in(Re &x){",
            "    int f=0;x=0;char c=getchar();",
            "    while(c<'0'||c>'9')f|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=f?-x:x;",
            "}",
            "inline void add(Re x){ans+=!cnt[x]++;}",
            "inline void del(Re x){ans-=!--cnt[x];}",
            "int main(){",
            "    in(n),BL=sqrt(n)+1;",
            "    for(Re i=1;i<=n;++i)in(A[i]);",
            "    in(T);",
            "    for(Re i=1;i<=T;++i)in(Q[i].l),in(Q[i].r),Q[i].id=i;",
            "    sort(Q+1,Q+T+1);Re nowL=1,nowR=0;",
            "    for(Re i=1;i<=T;++i){",
            "        while(nowR<Q[i].r)add(A[++nowR]);",
            "        while(nowR>Q[i].r)del(A[nowR--]);",
            "        while(nowL>Q[i].l)add(A[--nowL]);",
            "        while(nowL<Q[i].l)del(A[nowL++]);",
            "        Ans[Q[i].id]=ans;",
            "    }",
            "    for(Re i=1;i<=T;++i)printf(\"%d\\n\",Ans[i]);",
            "}",
            ""
        ],
        "description": "插入 静态莫队"
    },
    "小Z的袜子": {
        "prefix": "acm-2.9optimize",
        "body": [
            "#pragma GCC optimize(3,\"Ofast\",\"inline\")",
            "#pragma GCC optimize(2)",
            "#include<algorithm>",
            "#include<cstdio>",
            "#include<cmath>",
            "#define Re register int",
            "#define F(x,a,b) for(Re x=a;x<=b;++x)",
            "#define LL long long",
            "using std::sort;",
            "const int N=5e4+3;",
            "int n,q,t,L,R,ip,fu,len,gs[N],pt[N],co[N];LL ans,gcd,fz[N],fm[N];",
            "struct QAQ{int l,r,id;}Q[N];",
            "inline void in(Re &x){",
            "    x=fu=0;char c=getchar();",
            "    while(c<'0'||c>'9')fu|=c=='-',c=getchar();",
            "    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();",
            "    x=fu?-x:x;",
            "}",
            "inline void sakura(Re p,Re x){ans-=(LL)gs[fu=co[p]]*gs[fu],gs[fu]+=x,ans+=(LL)gs[fu]*gs[fu];} ",
            "inline bool cmp(QAQ a,QAQ b){return pt[a.l]==pt[b.l]?a.r<b.r:a.l<b.l;}",
            "inline LL gcd_(LL a,LL b){while(b^=a^=b^=a%=b);return a;}",
            "int main(){",
            "\tin(n),in(q),t=sqrt(n);",
            "\tF(i,1,n)in(co[i]),pt[i]=i/t+1;",
            "\tF(i,1,q)in(Q[i].l),in(Q[i].r),Q[i].id=i;",
            "\tsort(Q+1,Q+q+1,cmp);",
            "\tL=1,R=0;",
            "\tF(i,1,q){",
            "\t\twhile(L<Q[i].l)sakura(L++,-1);",
            "\t\twhile(L>Q[i].l)sakura(--L,1);",
            "\t\twhile(R<Q[i].r)sakura(++R,1);",
            "\t\twhile(R>Q[i].r)sakura(R--,-1);",
            "\t\tip=Q[i].id;",
            "\t\tif(Q[i].l==Q[i].r){fz[ip]=0,fm[ip]=1;continue;}",
            "\t\tfz[ip]=ans-(len=Q[i].r-Q[i].l+1);",
            "\t\tfm[ip]=(LL)len*(len-1);",
            "\t\tgcd=gcd_(fz[ip],fm[ip]),fz[ip]/=gcd,fm[ip]/=gcd;",
            "\t}",
            "\tF(i,1,q)printf(\"%lld/%lld\\n\",fz[i],fm[i]);",
            "}",
            ""
        ],
        "description": "插入 小Z的袜子"
    },
    "蒲公英参考程序": {
        "prefix": "acm-2.9区间众数",
        "body": [
            "#include<iostream>",
            "#include<cstdio>",
            "#include<cmath>",
            "#include<algorithm>",
            "#include<cstring>",
            "using namespace std;",
            "const int u=40010;",
            "int c[40][40][u],f[40][40],d[40][40],a[u],b[u],fa[u],fb[u],st[40],ed[40];",
            "int n,m,t,l,tot,i,j,k,x,y,ans,L,R,cnt,num;",
            "",
            "void prework()",
            "{",
            "\tt=(int)pow(n*1.0,1.0/3);",
            "\tif(t) l=n/t;",
            "\tfor(i=1;i<=t;i++) st[i]=(i-1)*l+1,ed[i]=i*l;",
            "\tif(ed[t]<n) st[t+1]=ed[t]+1,ed[++t]=n;",
            "\tmemcpy(fa,a,sizeof(a));",
            "\tsort(fa+1,fa+n+1);",
            "\tfor(i=1;i<=n;i++)",
            "\t\tif(i==1||fa[i]!=fa[i-1]) fb[++tot]=fa[i];",
            "\tfor(i=1;i<=n;i++) b[i]=lower_bound(fb+1,fb+tot+1,a[i])-fb;",
            "\tfor(i=1;i<=t;i++)",
            "\t\tfor(j=i;j<=t;j++)",
            "\t\t{",
            "\t\t\tfor(k=st[i];k<=ed[j];k++) c[i][j][b[k]]++;",
            "\t\t\tfor(k=1;k<=tot;k++)",
            "\t\t\t\tif(c[i][j][k]>f[i][j]||c[i][j][k]==f[i][j]&&k<d[i][j])",
            "\t\t\t\t\tf[i][j]=c[i][j][k],d[i][j]=k;",
            "\t\t}",
            "}",
            "",
            "inline void update(int i)",
            "{",
            "\tc[L][R][b[i]]++;",
            "\tif(c[L][R][b[i]]>cnt||c[L][R][b[i]]==cnt&&b[i]<num) cnt=c[L][R][b[i]],num=b[i];",
            "}",
            "",
            "int solve(int x,int y)",
            "{",
            "\tint i,l,r;",
            "\tif(x>y) swap(x,y);",
            "\tfor(i=1;i<=t;i++) if(x<=ed[i]) {l=i; break;}",
            "\tfor(i=t;i;i--) if(y>=st[i]) {r=i; break;}",
            "\tif(l+1<=r-1) L=l+1,R=r-1; else L=R=0;",
            "\tcnt=f[L][R],num=d[L][R];",
            "\tif(l==r)",
            "\t{",
            "\t\tfor(i=x;i<=y;i++) update(i);",
            "\t\tfor(i=x;i<=y;i++) c[L][R][b[i]]--;",
            "\t}",
            "\telse{",
            "\t\tfor(i=x;i<=ed[l];i++) update(i);",
            "\t\tfor(i=st[r];i<=y;i++) update(i);",
            "\t\tfor(i=x;i<=ed[l];i++) c[L][R][b[i]]--;",
            "\t\tfor(i=st[r];i<=y;i++) c[L][R][b[i]]--;",
            "\t}",
            "\treturn fb[num];",
            "}",
            "",
            "int main()",
            "{",
            "\tcin>>n>>m;",
            "\tfor(i=1;i<=n;i++) scanf(\"%d\",&a[i]);",
            "\tprework();",
            "\tfor(i=1;i<=m;i++)",
            "\t{",
            "\t\tscanf(\"%d%d\",&x,&y);",
            "\t\tans=solve((x+ans-1)%n+1,(y+ans-1)%n+1);",
            "\t\tprintf(\"%d\\n\",ans);",
            "\t}",
            "\treturn 0;",
            "}",
            ""
        ],
        "description": "插入 蒲公英参考程序"
    },
    "data": {
        "prefix": "acm-1.4fu",
        "body": [
            "#include<bits/stdc++.h>",
            "#define LL long long",
            "#define Re register LL",
            "using namespace std;",
            "const LL inf=1000,N=20;",
            "LL vis[inf+5];char A[N+5],B[N+5];",
            "inline LL fu(){return rand()%2?-1:1;}",
            "inline LL Rand(LL L,LL R){",
            "\tLL a=R-L+1;",
            "\tLL b=(LL)rand()*rand()%a+1;",
            "\tb=b*rand()%a+1;",
            "\tb=b*rand()%a+1;",
            "\tb=b*rand()%a+1;",
            "\tb=b*rand()%a+1;",
            "\treturn L+b-1;",
            "}",
            "LL lo[N],tp[N];",
            "int main(){",
            "//\tfreopen(\"data.in\",\"w\",stdout);",
            "\tsrand(time(0));",
            "\tRe n=rand()%N+1;",
            "\tprintf(\"%lld 0\\n\",n);",
            "\tfor(Re i=1;i<=n;++i)printf(\"%lld \",Rand(1,inf));",
            "}",
            ""
        ],
        "description": "插入 data"
    },
    "myprogram": {
        "prefix": "acm-1.4sakura",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e5+3;",
            "const LL inf=4e18+5;",
            "int n,opt,A[N],B[N];",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "struct QAQ0{",
            "\tint x;LL g[N],S[N],dp[N];",
            "\tinline void sakura(){",
            "\t\tfor(Re i=1;i<=n;++i)in(x),S[i]=S[i-1]+x,dp[i]=inf;",
            "\t\tdp[0]=0,g[0]=S[0];",
            "\t\tfor(Re i=1,p=0;i<=n;++i){",
            "\t\t\twhile(p+1<i&&2*S[p+1]-g[p+1]<=S[i])++p;",
            "\t\t\tdp[i]=dp[p]+(S[i]-S[p])*(S[i]-S[p]),g[i]=S[p];",
            "//\t\t\tprintf(\"i=%d, p=%d\\n\",i,p);",
            "//\t\t\tfor(Re j=0;j<=p;++j)",
            "//\t\t\t\tif(dp[i]>=(tmp=dp[j]+(S[i]-S[j])*(S[i]-S[j])))",
            "//\t\t\t\t\tdp[i]=tmp,g[i]=S[j];",
            "\t\t}",
            "//\t\tfor(Re i=0;i<=n;++i)printf(\"dp[%d]=%lld\\n\",i,dp[i]);",
            "\t\tprintf(\"%lld\\n\",dp[n]);",
            "\t}",
            "}T0;",
            "int main(){",
            "//\tfreopen(\"456.txt\",\"r\",stdin);",
            "\tin(n),in(opt);",
            "\tif(n<=5000)T0.sakura();",
            "\tfclose(stdin);",
            "\tfclose(stdout);",
            "\treturn 0;",
            "}",
            ""
        ],
        "description": "插入 myprogram"
    },
    "std": {
        "prefix": "acm-1.4sakura",
        "body": [
            "#include<algorithm>",
            "#include<cstring>",
            "#include<cstdio>",
            "#include<queue>",
            "#include<set>",
            "#define LL long long",
            "#define Re register int",
            "using namespace std;",
            "const int N=5e5+3;",
            "const LL inf=4e18+5;",
            "int n,opt,A[N],B[N];",
            "inline void in(Re &x){",
            "\tRe fu=0;x=0;char ch=getchar();",
            "\twhile(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();",
            "\twhile(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();",
            "\tx=fu?-x:x;",
            "}",
            "struct QAQ0{",
            "\tint x,g[N];LL tmp,S[N],dp[N];",
            "\tinline void sakura(){",
            "\t\tfor(Re i=1;i<=n;++i)in(x),S[i]=S[i-1]+x,dp[i]=inf;",
            "\t\tdp[0]=0,g[0]=0;",
            "\t\tfor(Re i=1,p=0;i<=n;/*printf(\"i=%d, p=%d\\n\",i,p),*/++i)",
            "\t\t\tfor(Re j=0;j<i;++j)",
            "\t\t\t\tif(S[i]-S[j]>=S[j]-S[g[j]]&&dp[i]>=(tmp=dp[j]+(S[i]-S[j])*(S[i]-S[j])))",
            "\t\t\t\t\tdp[i]=tmp,g[i]=j,p=j;",
            "//\t\tfor(Re i=0;i<=n;++i)printf(\"dp[%d]=%lld\\n\",i,dp[i]);",
            "\t\tprintf(\"%lld\\n\",dp[n]);",
            "\t}",
            "}T0;",
            "int main(){",
            "//\tfreopen(\"456.txt\",\"r\",stdin);",
            "\tin(n),in(opt);",
            "\tif(n<=5000)T0.sakura();",
            "\tfclose(stdin);",
            "\tfclose(stdout);",
            "\treturn 0;",
            "}",
            ""
        ],
        "description": "插入 std"
    },
    "对拍": {
        "prefix": "acm-1.4system",
        "body": [
            "#include<bits/stdc++.h>",
            "#include<windows.h>",
            "#define Re register int ",
            "using namespace std;",
            "int main(){",
            "\tRe sec=0.1,HYJ=0;// 随机数据生成时间，大约每0.1秒一次 ",
            "\tsec*=1e3;",
            "    while(1){",
            "    \tprintf(\"第 %d 组数据：\\n\",++HYJ);",
            "        system(\"data.exe>data.in\");// 随机数据生成到文件 ",
            "        system(\"std.exe<data.in>std.out\");// 运行标准程序 ",
            "        system(\"myprogram.exe<data.in>my.out\");// 运行自己的程序（可能全WA但能跑通的程序）",
            "        if(system(\"fc std.out my.out\")){// 比较输出文件，fc比较文本文件不同返回1",
            "            system(\"pause\");",
            "\t\t\tprintf(\"[corrupted string]\");",
            "            //break; ",
            "        }",
            "        Sleep(sec);",
            "    }",
            "}",
            ""
        ],
        "description": "插入 对拍"
    },
    "左偏树（可并堆）模板": {
        "prefix": "acm-2.13LeftistTree",
        "body": [
            "// 左偏树（可并堆）模板",
            "struct LeftistTree {",
            "    struct Node {",
            "        int value;   // 节点值",
            "        int left;    // 左子节点",
            "        int right;   // 右子节点",
            "        int dist;    // 距离（npl，空节点为0，叶节点为1）",
            "    };",
            "    ",
            "    vector<Node> heap;  // 堆节点数组，0号节点为空节点",
            "    ",
            "    // 构造函数，初始化空节点",
            "    LeftistTree(int reserveSize = 0) {",
            "        heap.reserve(reserveSize + 1);",
            "        heap.push_back({0, 0, 0, 0});  // 0号节点作为空节点",
            "    }",
            "    ",
            "    // 创建新节点",
            "    int newNode(int value) {",
            "        heap.push_back({value, 0, 0, 1});",
            "        return (int)heap.size() - 1;",
            "    }",
            "    ",
            "    // 比较优先级，返回a是否优先于b",
            "    // 可根据需要重写（此处为示例：值大的优先）",
            "    bool higherPriority(int a, int b) {",
            "        if (b == 0) return true;   // b为空",
            "        if (a == 0) return false;  // a为空",
            "        return heap[a].value > heap[b].value;  // 大根堆",
            "    }",
            "    ",
            "    // 合并两个堆，返回合并后的根节点",
            "    int merge(int a, int b) {",
            "        if (a == 0) return b;",
            "        if (b == 0) return a;",
            "        ",
            "        // 确保a的优先级更高",
            "        if (!higherPriority(a, b)) swap(a, b);",
            "        ",
            "        // 递归合并右子树",
            "        heap[a].right = merge(heap[a].right, b);",
            "        ",
            "        // 维护左偏性质：左子树dist >= 右子树dist",
            "        if (heap[heap[a].left].dist < heap[heap[a].right].dist) {",
            "            swap(heap[a].left, heap[a].right);",
            "        }",
            "        ",
            "        // 更新dist",
            "        heap[a].dist = heap[heap[a].right].dist + 1;",
            "        return a;",
            "    }",
            "    ",
            "    // 弹出堆顶（删除根节点）",
            "    int pop(int root) {",
            "        return merge(heap[root].left, heap[root].right);",
            "    }",
            "    ",
            "    // 获取堆顶值",
            "    int top(int root) {",
            "        return heap[root].value;",
            "    }",
            "    ",
            "    // 判断堆是否为空",
            "    bool empty(int root) {",
            "        return root == 0;",
            "    }",
            "};"
        ],
        "description": "插入 左偏树（可并堆）模板"
    },
    "左偏树-P3377": {
        "prefix": "acm-2.13luogu-p3377",
        "body": [
            "typedef pair<int,int> P;  // 存储键值对，通常用于比较优先级",
            "struct Node {",
            "    int l, r, d;  // l:左孩子, r:右孩子, d:距离（null路径长度）",
            "    P v;          // 存储的值（键值对）",
            "    Node(){}",
            "    Node(int _l,int _r,int _d,P _v){l=_l,r=_r,d=_d,v=_v;}",
            "} T[N];  // 数组存储所有节点",
            "int merge(int a,int b){",
            "    if(!a) return b;",
            "    if(!b) return a;",
            "    if(T[a].v < T[b].v)swap(a,b);",
            "    T[a].r = merge(T[a].r,b);",
            "    if(T[T[a].l].d < T[T[a].r].d)swap(T[a].l,T[a].r);",
            "    T[a].d=T[a].r ? T[T[a].r].d+1:0;",
            "    return a;",
            "}",
            "int pop(int a){",
            "    int l = T[a].l,r=T[a].r;",
            "    T[a].l=T[a].r=T[a].d=0;",
            "    return merge(l,r);",
            "}"
        ],
        "description": "插入 左偏树-P3377"
    }
}