高精度：加减乘，以及「为什么不能用 long long」

// 「那就用 long long 啊」—— 这份代码就是那个想法，它跑得飞快，而且**是错的**
//
// 这一章的「暴力」和全书别的章不一样：别的章的暴力是**对但慢**，
// 这一份是**快但错**。所以第 4 步的实测不是量时间，是量它**从第几位开始给出错误答案**。
//
// ⚠ 为什么用 unsigned long long 而不是 long long：
//   有符号整数溢出在 C++ 里是**未定义行为**（第 10 章那条）——
//   未定义行为的结果随编译器、优化等级、机器而变，**没法写进断言，也没法印在教材里**。
//   而无符号整数溢出是**有定义的**：结果对 2⁶⁴ 取模。
//   ⇒ 换成 unsigned 之后，这份「错」是确定的、可复现的、可以钉成断言的错。
//   ★ 这不是在护着它。恰恰相反：**连最讲道理的那个版本都错得这么早**，才说明问题。
//
// 它错在哪一步，limits.cpp 一档一档量给你看。

#include <bits/stdc++.h>
using namespace std;

/** 逐位读进 unsigned long long。超过 2⁶⁴ 之后自动对 2⁶⁴ 取模（这是标准规定的行为） */
unsigned long long parseUll(const string& s) {
    unsigned long long v = 0;
    for (char c : s) v = v * 10ULL + (unsigned long long)(c - '0');
    return v;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string sa, sb;
    if (!(cin >> sa >> sb)) return 0;

    unsigned long long a = parseUll(sa), b = parseUll(sb);
    unsigned long long s = a + b, d = a - b, p = a * b;

    string ss = to_string(s), sd = to_string(d), sp = to_string(p);
    cout << ss << "\n" << sd << "\n" << sp << "\n";
    cout << ss.size() << " " << sd.size() << " " << sp.size() << "\n";
    return 0;
}

// 量一件事：unsigned long long 到底从第几位开始给出错误答案
//
// 做法：让 a = b = 一串 k 个 9（k 从 1 数上去），拿两条路各算一遍 a+b 和 a×b：
//   · 一条是 ull.cpp 那条（64 位整数，溢出后对 2⁶⁴ 取模）；
//   · 一条是 fast.cpp 那条（高精度，永远对）。
// 第一次对不上的那个 k，就是「64 位整数在这道题上的极限」。
//
// ★ 为什么选「全是 9」：它是同样位数里最大的数，最早顶到上界 —— 量上限就该拿它量。
//   换成随机的 k 位数，崩掉的位置会晚一两位，而且每次不一样，那样的数字没法写进教材。
//
// 用法：./limits [最大位数=25]
// 输出：每行 `k 和是否一致 积是否一致`，最后两行是两个「第一次出错的 k」。

#include <bits/stdc++.h>
using namespace std;

using Big = vector<int>;

Big parse(const string& s) {
    Big v;
    for (int i = (int)s.size() - 1; i >= 0; i--) v.push_back(s[i] - '0');
    return v;
}
string show(const Big& v) {
    string s;
    for (int i = (int)v.size() - 1; i >= 0; i--) s += char('0' + v[i]);
    return s;
}
void trim(Big& v) { while (v.size() > 1 && v.back() == 0) v.pop_back(); }

Big add(const Big& a, const Big& b) {
    Big c;
    int carry = 0;
    for (size_t i = 0; i < a.size() || i < b.size() || carry; i++) {
        int cur = carry;
        if (i < a.size()) cur += a[i];
        if (i < b.size()) cur += b[i];
        c.push_back(cur % 10);
        carry = cur / 10;
    }
    trim(c);
    return c;
}
Big mul(const Big& a, const Big& b) {
    Big c(a.size() + b.size(), 0);
    for (size_t i = 0; i < a.size(); i++)
        for (size_t j = 0; j < b.size(); j++)
            c[i + j] += a[i] * b[j];
    int carry = 0;
    for (size_t i = 0; i < c.size(); i++) { int cur = c[i] + carry; c[i] = cur % 10; carry = cur / 10; }
    trim(c);
    return c;
}

unsigned long long parseUll(const string& s) {
    unsigned long long v = 0;
    for (char c : s) v = v * 10ULL + (unsigned long long)(c - '0');
    return v;
}

int main(int argc, char** argv) {
    int maxK = (argc > 1) ? atoi(argv[1]) : 25;
    if (maxK < 1) maxK = 1;
    if (maxK > 40) maxK = 40;

    int badAdd = 0, badMul = 0;
    printf("位数k  a=b=k个9        和一致  积一致\n");
    for (int k = 1; k <= maxK; k++) {
        string s(k, '9');
        Big a = parse(s);
        string trueAdd = show(add(a, a)), trueMul = show(mul(a, a));

        unsigned long long u = parseUll(s);
        string ullAdd = to_string(u + u), ullMul = to_string(u * u);

        bool okAdd = (ullAdd == trueAdd), okMul = (ullMul == trueMul);
        if (!okAdd && !badAdd) badAdd = k;
        if (!okMul && !badMul) badMul = k;
        printf("%5d                  %s      %s\n", k, okAdd ? "✓" : "✗", okMul ? "✓" : "✗");
    }
    printf("\n和：第一次算错是 %d 位\n", badAdd);
    printf("积：第一次算错是 %d 位\n", badMul);
    return 0;
}

// 换一把尺子：数「一位数运算」做了多少次
//
// 秒表在这一章基本没用 —— 500 位的加减乘在本机都是零点零几秒，读数几乎全是进程启动
// （第 23 章那条「秒表彻底失效」的第二次现场）。而这一章的三种运算，工作量是**能数出来的**：
//
//     加法 / 减法：O(n)     —— 每一位做一次一位数加/减
//     乘法      ：O(nm)    —— a 的每一位都要和 b 的每一位相乘
//
// ⚠ 这里的次数是**真数出来的**（在算法里放计数器），不是套公式印出来的。
//   两者对不上就说明我对自己的代码理解错了 —— 这正是这一节要防的事。
//
// 用法：./count <n> <m> [csv]     n、m 是两个数的位数
//   默认打一张人看的表；带 csv 就只打 `键,值`，给 check:viz 用。

#include <bits/stdc++.h>
using namespace std;

using Big = vector<int>;

static long long cntAdd = 0, cntSub = 0, cntMul = 0, cntCarry = 0;

Big mkNines(int k) { return Big(k, 9); }          // k 个 9：同位数里最大的数

void trim(Big& v) { while (v.size() > 1 && v.back() == 0) v.pop_back(); }

Big add(const Big& a, const Big& b) {
    Big c;
    int carry = 0;
    for (size_t i = 0; i < a.size() || i < b.size() || carry; i++) {
        int cur = carry;
        if (i < a.size()) cur += a[i];
        if (i < b.size()) cur += b[i];
        cntAdd++;                                  // ← 一次一位数加法
        c.push_back(cur % 10);
        carry = cur / 10;
    }
    trim(c);
    return c;
}

Big sub(const Big& a, const Big& b) {
    Big c;
    int borrow = 0;
    for (size_t i = 0; i < a.size(); i++) {
        int cur = a[i] - borrow - (i < b.size() ? b[i] : 0);
        cntSub++;                                  // ← 一次一位数减法
        borrow = 0;
        if (cur < 0) { cur += 10; borrow = 1; }
        c.push_back(cur);
    }
    trim(c);
    return c;
}

Big mul(const Big& a, const Big& b) {
    Big c(a.size() + b.size(), 0);
    for (size_t i = 0; i < a.size(); i++)
        for (size_t j = 0; j < b.size(); j++) {
            c[i + j] += a[i] * b[j];
            cntMul++;                              // ← 一次一位数乘法
        }
    int carry = 0;
    for (size_t i = 0; i < c.size(); i++) {
        int cur = c[i] + carry;
        cntCarry++;                                // ← 统一进位那一遍
        c[i] = cur % 10;
        carry = cur / 10;
    }
    trim(c);
    return c;
}

int main(int argc, char** argv) {
    int n = (argc > 1) ? atoi(argv[1]) : 500;
    int m = (argc > 2) ? atoi(argv[2]) : 500;
    bool csv = (argc > 3) && string(argv[3]) == "csv";
    if (n < 1) n = 1;
    if (m < 1) m = 1;
    if (n > 5000) n = 5000;
    if (m > 5000) m = 5000;
    if (m > n) swap(n, m);                          // 保证 a >= b（都是 9 的话位数多的更大）

    Big a = mkNines(n), b = mkNines(m);
    add(a, b);
    sub(a, b);
    mul(a, b);

    if (csv) {
        printf("n,%d\n", n);
        printf("m,%d\n", m);
        printf("add,%lld\n", cntAdd);
        printf("sub,%lld\n", cntSub);
        printf("mul,%lld\n", cntMul);
        printf("carry,%lld\n", cntCarry);
        return 0;
    }

    printf("两个数：%d 位 和 %d 位（都取全 9，同位数里最大）\n\n", n, m);
    printf("  加法：一位数加法 %lld 次      （≈ n+1，最后那一次是最高位的进位）\n", cntAdd);
    printf("  减法：一位数减法 %lld 次      （= n）\n", cntSub);
    printf("  乘法：一位数乘法 %lld 次   （= n×m），之后统一进位再扫 %lld 次（= n+m）\n", cntMul, cntCarry);
    printf("\n★ 加减是 O(n)，乘是 O(nm) —— %d×%d 的乘法是加法的 %lld 倍。\n",
           n, m, cntMul / max(1LL, cntAdd));
    return 0;
}

// 把竖式一步一步打出来 —— 动画照着这份代码画，check:viz 拿它和动画**逐步**对
//
// 用法：./trace <a> <b> <add|sub>
//
// 输出格式（每一位一行，位号从个位开始数，和数组下标一致）：
//     步 0  位=0  a=7 b=3 借入=0  → 4  写下 4  借出=0
// 最后一行是收尾：答案、以及「一共进位/借位了多少次」。
//
// ★ 为什么要专门有这一份：动画和正解**必须讲同一件事**。
//   只对最终答案的话，「答案对了但中间画的是另一回事」这种事查不出来
//   （第 27、28 章那句「一份走法能自证清白，一个数字不能」）。
//   所以这里把每一位的 (a位, b位, 进位入, 结果, 进位出) 全打出来，动画那边逐帧对。

#include <bits/stdc++.h>
using namespace std;

int main(int argc, char** argv) {
    string sa = (argc > 1) ? argv[1] : "987";
    string sb = (argc > 2) ? argv[2] : "123";
    string op = (argc > 3) ? argv[3] : "add";

    vector<int> a, b;
    for (int i = (int)sa.size() - 1; i >= 0; i--) a.push_back(sa[i] - '0');
    for (int i = (int)sb.size() - 1; i >= 0; i--) b.push_back(sb[i] - '0');

    printf("op=%s a=%s b=%s\n", op.c_str(), sa.c_str(), sb.c_str());

    vector<int> c;
    int cnt = 0;                       // 进位 / 借位发生的次数

    if (op == "add") {
        int carry = 0;
        for (size_t i = 0; i < a.size() || i < b.size() || carry; i++) {
            int ai = (i < a.size()) ? a[i] : 0;
            int bi = (i < b.size()) ? b[i] : 0;
            int cur = ai + bi + carry;
            int in = carry;
            carry = cur / 10;
            if (carry) cnt++;
            printf("步 %zu  位=%zu  a=%d b=%d 进位入=%d  → %d  写下 %d  进位出=%d\n",
                   i, i, ai, bi, in, cur, cur % 10, carry);
            c.push_back(cur % 10);
        }
    } else {
        int borrow = 0;
        for (size_t i = 0; i < a.size(); i++) {
            int ai = a[i];
            int bi = (i < b.size()) ? b[i] : 0;
            int in = borrow;
            int cur = ai - borrow - bi;
            borrow = 0;
            if (cur < 0) { cur += 10; borrow = 1; cnt++; }
            printf("步 %zu  位=%zu  a=%d b=%d 借入=%d  → %d  写下 %d  借出=%d\n",
                   i, i, ai, bi, in, cur, cur, borrow);
            c.push_back(cur);
        }
    }

    // 去前导零（0 要留一个）
    size_t before = c.size();
    while (c.size() > 1 && c.back() == 0) c.pop_back();
    string res;
    for (size_t i = c.size(); i-- > 0;) res += char('0' + c[i]);

    printf("收尾  答案 %s  %s %d 次  去掉前导零 %zu 个\n",
           res.c_str(), op == "add" ? "进位" : "借位", cnt, before - c.size());
    return 0;
}

// 高精度加减乘 —— 正解：低位在前的十进制数组
//
// 这一章的全部内容，就是把小学的竖式翻译成代码。翻译时只有一个决定是关键的：
//
//   ★ **数组下标 0 存个位**（低位在前，也就是把数字倒过来存）。
//
// 为什么不能顺着存（下标 0 存最高位）？因为竖式的三件事全是从个位开始的：
// 加法从个位往上进位、减法从个位往上借位、乘法里 a 的第 i 位乘 b 的第 j 位要落到「第 i+j 位」。
// 顺着存的话，这三句话里的下标全都要写成 `n-1-i` 那种形状 —— 一处写错就全错，
// 而且错得很难看出来。倒过来存之后，下标就是「这一位有多大」，i+j 那一句几乎是抄的。
//
// 表示约定（三个函数共用）：
//   · vector<int>，每个元素是一位十进制数字（0~9），下标 0 是个位；
//   · 允许出现前导零（也就是数组末尾的 0），最后统一由 trim() 去掉；
//   · **0 就是 {0}**，长度 1 —— 这是 trim() 里 `size() > 1` 那个 1 的全部理由。
//
// 复杂度：加、减都是 O(n)；乘是 O(nm) —— 500 位 × 500 位是 25 万次一位数乘法，
// 眨眼就完（count.cpp 把这个数数出来了）。

#include <bits/stdc++.h>
using namespace std;

using Big = vector<int>;

/** "123" → {3,2,1}（下标 0 是个位） */
Big parse(const string& s) {
    Big v;
    for (int i = (int)s.size() - 1; i >= 0; i--) v.push_back(s[i] - '0');
    return v;
}

/** {3,2,1} → "123" */
string show(const Big& v) {
    string s;
    for (int i = (int)v.size() - 1; i >= 0; i--) s += char('0' + v[i]);
    return s;
}

/**
 * 去掉高位多余的 0。
 * ★ 条件是 `v.size() > 1`，不是 `!v.empty()` —— 差一个字，0 就会被删成空数组，
 *   输出变成一个空行。这是这一章最常见的两个错法之一（wrongTrimAll.cpp 就是它）。
 */
void trim(Big& v) {
    while (v.size() > 1 && v.back() == 0) v.pop_back();
}

/**
 * 加法：逐位加，进位往上传。
 * ★ 循环条件里那个 `|| carry` 是「最高位还要再进一位」那种情况（999 + 1 = 1000）——
 *   漏掉它的后果是答案少一位，而且**只在进位一直传到头的时候才现形**。
 */
Big add(const Big& a, const Big& b) {
    Big c;
    int carry = 0;
    for (size_t i = 0; i < a.size() || i < b.size() || carry; i++) {
        int cur = carry;
        if (i < a.size()) cur += a[i];
        if (i < b.size()) cur += b[i];
        c.push_back(cur % 10);
        carry = cur / 10;
    }
    trim(c);
    return c;
}

/**
 * 减法：调用方保证 a >= b。
 * ★ 借位是一条**链**：1000 - 1 要从个位一路借到最高位。所以 borrow 必须是循环里
 *   带着走的变量，而不是「发现不够就跟上一位借一次」那种一次性判断。
 */
Big sub(const Big& a, const Big& b) {
    Big c;
    int borrow = 0;
    for (size_t i = 0; i < a.size(); i++) {
        int cur = a[i] - borrow - (i < b.size() ? b[i] : 0);
        borrow = 0;
        if (cur < 0) { cur += 10; borrow = 1; }
        c.push_back(cur);
    }
    trim(c);                      // ★ 1000 - 999 = 0001 → 1，这一步不能省
    return c;
}

/**
 * 乘法：竖式，但**先把所有部分积按 i+j 累加进去，最后统一进位**。
 *
 * ★ 两句话是这一段的全部：
 *   ① `c[i + j] += a[i] * b[j]`  —— 第 i 位乘第 j 位，结果落在第 i+j 位（倒着存的红利）；
 *   ② 结果数组开 `a.size() + b.size()` 位 —— 上界是「位数之和」，少开一位就会丢最高位。
 *
 * ⚠ 中间的 c[i] 会长到多大？每个 c[i] 最多累加 min(n,m) 个 9×9=81 —— 500 位时是 40500，
 *   int 装得下，所以这里**不需要** long long。（换成压位写法（一格存 8 位十进制）就需要了。）
 */
Big mul(const Big& a, const Big& b) {
    Big c(a.size() + b.size(), 0);
    for (size_t i = 0; i < a.size(); i++)
        for (size_t j = 0; j < b.size(); j++)
            c[i + j] += a[i] * b[j];

    int carry = 0;
    for (size_t i = 0; i < c.size(); i++) {
        int cur = c[i] + carry;
        c[i] = cur % 10;
        carry = cur / 10;
    }
    trim(c);
    return c;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string sa, sb;
    if (!(cin >> sa >> sb)) return 0;
    Big a = parse(sa), b = parse(sb);

    Big s = add(a, b), d = sub(a, b), p = mul(a, b);
    string ss = show(s), sd = show(d), sp = show(p);

    cout << ss << "\n" << sd << "\n" << sp << "\n";
    // ★ 多问一行位数：0 的位数算 1。它专门用来照出「前导零」那一类错
    cout << ss.size() << " " << sd.size() << " " << sp.size() << "\n";
    return 0;
}

// 高精度加减乘 —— 正解：低位在前的十进制数组
//
// 这一章的全部内容，就是把小学的竖式翻译成代码。翻译时只有一个决定是关键的：
//
//   ★ **数组下标 0 存个位**（低位在前，也就是把数字倒过来存）。
//
// 为什么不能顺着存（下标 0 存最高位）？因为竖式的三件事全是从个位开始的：
// 加法从个位往上进位、减法从个位往上借位、乘法里 a 的第 i 位乘 b 的第 j 位要落到「第 i+j 位」。
// 顺着存的话，这三句话里的下标全都要写成 `n-1-i` 那种形状 —— 一处写错就全错，
// 而且错得很难看出来。倒过来存之后，下标就是「这一位有多大」，i+j 那一句几乎是抄的。
//
// 表示约定（三个函数共用）：
//   · vector<int>，每个元素是一位十进制数字（0~9），下标 0 是个位；
//   · 允许出现前导零（也就是数组末尾的 0），最后统一由 trim() 去掉；
//   · **0 就是 {0}**，长度 1 —— 这是 trim() 里 `size() > 1` 那个 1 的全部理由。
//
// 复杂度：加、减都是 O(n)；乘是 O(nm) —— 500 位 × 500 位是 25 万次一位数乘法，
// 眨眼就完（count.cpp 把这个数数出来了）。

#include <bits/stdc++.h>
using namespace std;

using Big = vector<int>;

/** "123" → {3,2,1}（下标 0 是个位） */
Big parse(const string& s) {
    Big v;
    for (int i = (int)s.size() - 1; i >= 0; i--) v.push_back(s[i] - '0');
    return v;
}

/** {3,2,1} → "123" */
string show(const Big& v) {
    string s;
    for (int i = (int)v.size() - 1; i >= 0; i--) s += char('0' + v[i]);
    return s;
}

/**
 * 去掉高位多余的 0。
 * ★ 条件是 `v.size() > 1`，不是 `!v.empty()` —— 差一个字，0 就会被删成空数组，
 *   输出变成一个空行。这是这一章最常见的两个错法之一（wrongTrimAll.cpp 就是它）。
 */
void trim(Big& v) {
    while (v.size() > 1 && v.back() == 0) v.pop_back();
}

/**
 * 加法：逐位加，进位往上传。
 * ★ 循环条件里那个 `|| carry` 是「最高位还要再进一位」那种情况（999 + 1 = 1000）——
 *   漏掉它的后果是答案少一位，而且**只在进位一直传到头的时候才现形**。
 */
Big add(const Big& a, const Big& b) {
    Big c;
    int carry = 0;
    for (size_t i = 0; i < a.size() || i < b.size() || carry; i++) {
        int cur = carry;
        if (i < a.size()) cur += a[i];
        if (i < b.size()) cur += b[i];
        c.push_back(cur % 10);
        carry = cur / 10;
    }
    trim(c);
    return c;
}

/**
 * 减法：调用方保证 a >= b。
 * ★ 借位是一条**链**：1000 - 1 要从个位一路借到最高位。所以 borrow 必须是循环里
 *   带着走的变量，而不是「发现不够就跟上一位借一次」那种一次性判断。
 */
Big sub(const Big& a, const Big& b) {
    Big c;
    int borrow = 0;
    for (size_t i = 0; i < a.size(); i++) {
        int cur = a[i] - borrow - (i < b.size() ? b[i] : 0);
        borrow = 0;
        if (cur < 0) { cur += 10; borrow = 1; }
        c.push_back(cur);
    }
    trim(c);                      // ★ 1000 - 999 = 0001 → 1，这一步不能省
    return c;
}

/**
 * 乘法：竖式，但**先把所有部分积按 i+j 累加进去，最后统一进位**。
 *
 * ★ 两句话是这一段的全部：
 *   ① `c[i + j] += a[i] * b[j]`  —— 第 i 位乘第 j 位，结果落在第 i+j 位（倒着存的红利）；
 *   ② 结果数组开 `a.size() + b.size()` 位 —— 上界是「位数之和」，少开一位就会丢最高位。
 *
 * ⚠ 中间的 c[i] 会长到多大？每个 c[i] 最多累加 min(n,m) 个 9×9=81 —— 500 位时是 40500，
 *   int 装得下，所以这里**不需要** long long。（换成压位写法（一格存 8 位十进制）就需要了。）
 */
Big mul(const Big& a, const Big& b) {
    Big c(a.size() + b.size(), 0);
    for (size_t i = 0; i < a.size(); i++)
        for (size_t j = 0; j < b.size(); j++)
            c[i + j] += a[i] * b[j];

    int carry = 0;
    for (size_t i = 0; i < c.size(); i++) {
        int cur = c[i] + carry;
        c[i] = cur % 10;
        carry = cur / 10;
    }
    trim(c);
    return c;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string sa, sb;
    if (!(cin >> sa >> sb)) return 0;
    Big a = parse(sa), b = parse(sb);

    Big s = add(a, b), d = sub(a, b), p = mul(a, b);
    string ss = show(s), sd = show(d), sp = show(p);

    cout << ss << "\n" << sd << "\n" << sp << "\n";
    // ★ 多问一行位数：0 的位数算 1。它专门用来照出「前导零」那一类错
    cout << ss.size() << " " << sd.size() << " " << sp.size() << "\n";
    return 0;
}

// 第三把尺子：拿硬件算术（__int128）验高精度
//
// ⚠ 对拍（brute.cpp ↔ fast.cpp）有一个说不出口的短板：**两份代码用的是同一套竖式**，
//   只是表示不同（字符串高位在前 vs 数组低位在前）。所以它抓得到「实现写歪了」，
//   抓不到「我对竖式的理解本身就错了」—— 两份会一起错，而且错得一模一样。
//   （第 20 章那句「标准答案最好用完全不同的思路写出来」，在这一章只做到了一半。）
//
// ⇒ 这份程序补上另一半：**不用任何自己写的竖式**，直接用 CPU 的 128 位整数算 a+b、a−b、a×b，
//   再和高精度的结果比。它只能验小数据（两个数各 ≤ 18 位，乘积 ≤ 36 位，__int128 装得下），
//   但它验的是「算得对不对」这件事本身。
//
// ★ 这就是本书反复在做的事：**一把尺子够不着的地方，换一把，而不是把结论说小一点。**
//   （第 36 章的「四个盲区」、第 41 章的「换成数划的次数」都是这个动作。）
//
// 用法：./verify [轮数=20000] [种子=20260825]

#include <bits/stdc++.h>
using namespace std;

using Big = vector<int>;

Big parse(const string& s) {
    Big v;
    for (int i = (int)s.size() - 1; i >= 0; i--) v.push_back(s[i] - '0');
    return v;
}
string show(const Big& v) {
    string s;
    for (int i = (int)v.size() - 1; i >= 0; i--) s += char('0' + v[i]);
    return s;
}
void trim(Big& v) { while (v.size() > 1 && v.back() == 0) v.pop_back(); }

Big add(const Big& a, const Big& b) {
    Big c;
    int carry = 0;
    for (size_t i = 0; i < a.size() || i < b.size() || carry; i++) {
        int cur = carry;
        if (i < a.size()) cur += a[i];
        if (i < b.size()) cur += b[i];
        c.push_back(cur % 10);
        carry = cur / 10;
    }
    trim(c);
    return c;
}
Big sub(const Big& a, const Big& b) {
    Big c;
    int borrow = 0;
    for (size_t i = 0; i < a.size(); i++) {
        int cur = a[i] - borrow - (i < b.size() ? b[i] : 0);
        borrow = 0;
        if (cur < 0) { cur += 10; borrow = 1; }
        c.push_back(cur);
    }
    trim(c);
    return c;
}
Big mul(const Big& a, const Big& b) {
    Big c(a.size() + b.size(), 0);
    for (size_t i = 0; i < a.size(); i++)
        for (size_t j = 0; j < b.size(); j++)
            c[i + j] += a[i] * b[j];
    int carry = 0;
    for (size_t i = 0; i < c.size(); i++) { int cur = c[i] + carry; c[i] = cur % 10; carry = cur / 10; }
    trim(c);
    return c;
}

/** __int128 没有现成的打印，自己转 —— 只处理非负数 */
string i128(__int128 v) {
    if (v == 0) return "0";
    string s;
    while (v > 0) { s += char('0' + (int)(v % 10)); v /= 10; }
    reverse(s.begin(), s.end());
    return s;
}

int main(int argc, char** argv) {
    long long rounds = (argc > 1) ? atoll(argv[1]) : 20000;
    unsigned seed = (argc > 2) ? (unsigned)strtoul(argv[2], nullptr, 10) : 20260825u;
    if (rounds < 1) rounds = 1;

    mt19937_64 rng(seed);
    int maxDigits = 0;
    long long bad = 0;

    for (long long r = 0; r < rounds && bad == 0; r++) {
        // 位数 1~18：__int128 要装得下乘积（36 位），绰绰有余
        int la = 1 + (int)(rng() % 18), lb = 1 + (int)(rng() % 18);
        auto mk = [&](int len) {
            string s;
            for (int i = 0; i < len; i++) {
                int d = (int)(rng() % 10);
                if (i == 0 && d == 0) d = 1 + (int)(rng() % 9);
                s += char('0' + d);
            }
            return s;
        };
        string sa = mk(la), sb = mk(lb);
        // 偶尔造两个相等的数（结果为 0），以及 b = 0
        if (rng() % 20 == 0) sb = sa;
        if (rng() % 50 == 0) sb = "0";

        __int128 A = 0, B = 0;
        for (char c : sa) A = A * 10 + (c - '0');
        for (char c : sb) B = B * 10 + (c - '0');
        if (A < B) { swap(A, B); swap(sa, sb); }

        maxDigits = max(maxDigits, (int)max(sa.size(), sb.size()));

        Big a = parse(sa), b = parse(sb);
        string gotAdd = show(add(a, b)), gotSub = show(sub(a, b)), gotMul = show(mul(a, b));
        string wantAdd = i128(A + B), wantSub = i128(A - B), wantMul = i128(A * B);

        if (gotAdd != wantAdd || gotSub != wantSub || gotMul != wantMul) {
            bad++;
            printf("✗ 第 %lld 轮对不上：a=%s b=%s\n", r + 1, sa.c_str(), sb.c_str());
            printf("   加：高精度 %s ／ __int128 %s\n", gotAdd.c_str(), wantAdd.c_str());
            printf("   减：高精度 %s ／ __int128 %s\n", gotSub.c_str(), wantSub.c_str());
            printf("   乘：高精度 %s ／ __int128 %s\n", gotMul.c_str(), wantMul.c_str());
        }
    }

    if (!bad) printf("✓ 全部通过 %lld 轮（两个数最长 %d 位，乘积最长 %d 位）\n",
                     rounds, maxDigits, maxDigits * 2);
    return bad ? 1 : 0;
}