Language: C++

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using int_t = long long;
constexpr int_t BASE = 100000000LL * 100000000LL, LEN = 16;
class bigint {
private:
    bool negative;
    std::vector<int_t> a;
    bigint& normalize();
public:
    bigint(int_t x = 0);
    bigint(const std::string& s);
    bigint& operator = (const bigint& x);
    bigint& operator = (int_t x);
    bigint& operator = (const std::string& s);
    const bool operator < (const bigint& x) const;
    const bool operator > (const bigint& x) const;
    const bool operator <= (const bigint& x) const;
    const bool operator >= (const bigint& x) const;
    const bool operator != (const bigint& x) const;
    const bool operator == (const bigint& x) const;
    bigint operator -() const;
    bigint& operator += (const bigint& x);
    bigint& operator -= (const bigint& x);
    bigint& operator *= (const bigint& x);
    bigint& operator /= (const bigint& x);
    bigint& operator %= (const bigint& x);
    const bigint operator + (const bigint& x) const;
    const bigint operator - (const bigint& x) const;
    const bigint operator * (const bigint& x) const;
    const bigint operator / (const bigint& x) const;
    const bigint operator % (const bigint& x) const;
    friend std::pair<bigint, bigint> divmod(const bigint& lhs, const bigint& rhs);
    friend std::istream& operator >> (std::ostream& is, bigint& x); //??????????£?
    friend std::ostream& operator << (std::ostream& os, const bigint& x);
    friend const bigint abs(bigint x);
};
inline bigint& bigint::normalize() {
    int i = a.size() - 1;
    while (i >= 0 && a[i] == 0) --i;
    a.resize(i + 1);
    if (a.size() == 0) negative = false;
    return *this;
}
inline bigint::bigint(int_t x) : negative(x < 0) {
    x = abs(x);
    for (; x > 0; x /= BASE) a.push_back(x % BASE);
}
inline bigint::bigint(const std::string& s) : negative(false) {
    int p = 0;
    if (s[p] == '-') { ++p; negative = true; }
    else if (s[p] == '+') { ++p; }
    for (int i = s.size() - 1, v = BASE; i >= p; --i, v *= 10) {
        int x = s[i] - '0';
        if (x < 0 || 9 < x) {
            std::cerr << "error: parse error:" << s << std::endl;
            exit(1);
        }
        if (v == BASE) {
            v = 1;
            a.push_back(x);
        }
        else a.back() += (x)*v;
    }
    normalize();
}
inline bigint& bigint::operator = (const bigint& x) {
    negative = x.negative;
    a = x.a;
    return *this;
}
inline bigint& bigint::operator = (int_t x) { return *this = bigint(x); }
inline bigint& bigint::operator = (const std::string& s) { return *this = bigint(s); }
inline const bool bigint::operator < (const bigint& x) const {
    if (negative != x.negative) return negative > x.negative;
    if (a.size() != x.a.size()) return (a.size() < x.a.size()) ^ negative;
    for (int i = a.size() - 1; i >= 0; --i)
        if (a[i] != x.a[i]) return (a[i] < x.a[i]) ^ negative;
    return false;
}
inline const bool bigint::operator > (const bigint& x) const { return x<(*this); }
inline const bool bigint::operator <= (const bigint& x) const { return !(x<(*this)); }
inline const bool bigint::operator >= (const bigint& x) const { return !((*this)<x); }
inline const bool bigint::operator != (const bigint& x) const { return (*this)<x || x<(*this); }
inline const bool bigint::operator == (const bigint& x) const { return !((*this)<x || x<(*this)); }
inline bigint bigint::operator -() const {
    bigint ret(*this);
    if (a.size()) ret.negative = !ret.negative;
    return ret;
}
inline bigint& bigint::operator += (const bigint& x) {
    if (negative != x.negative) return *this -= -x;
    if (a.size() < x.a.size()) a.resize(x.a.size());
    int_t tmp = 0;
    for (int i = 0; i < a.size(); ++i) {
        a[i] += (i<x.a.size() ? x.a[i] : 0) + tmp;
        tmp = a[i] / BASE;
        a[i] %= BASE;
    }
    if (tmp) a.push_back(1);
    return *this;
}
inline bigint& bigint::operator -= (const bigint& x) {
    if (negative != x.negative) return *this += -x;
    std::vector<int_t> b(x.a);
    if ((*this < x) ^ negative) {
        a.swap(b);
        negative = !negative;
    }
    int_t tmp = 0;
    for (int i = 0; i < a.size(); ++i) {
        a[i] += BASE - (i<b.size() ? b[i] : 0) + tmp;
        tmp = a[i] / BASE - 1;
        a[i] %= BASE;
    }
    return this->normalize();
}
inline bigint& bigint::operator *= (const bigint& x) {
    negative ^= x.negative;
    std::vector<int_t> c(a.size()*x.a.size() + 1);
    for (int i = 0; i < a.size(); ++i) {
        long long tmp = 0;
        for (int j = 0; j < x.a.size(); ++j) {
            long long v = (long long)a[i] * x.a[j] + c[i + j] + tmp;
            tmp = v / BASE;
            c[i + j] = (int_t)(v % BASE);
        }
        if (tmp) c[i + x.a.size()] += (int_t)tmp;
    }
    a.swap(c);
    return this->normalize();
}
inline bigint& bigint::operator /= (const bigint& x) {
    return *this = divmod(*this, x).first;
}
inline bigint& bigint::operator %= (const bigint& x) {
    return *this = divmod(*this, x).second;
}
inline const bigint bigint::operator + (const bigint& x) const {
    bigint res(*this); return res += x;
}
inline const bigint bigint::operator - (const bigint& x) const {
    bigint res(*this); return res -= x;
}
inline const bigint bigint::operator * (const bigint& x) const {
    bigint res(*this); return res *= x;
}
inline const bigint bigint::operator / (const bigint& x) const {
    bigint res(*this); return res /= x;
}
inline const bigint bigint::operator % (const bigint& x) const {
    bigint res(*this); return res %= x;
}
inline std::pair<bigint, bigint> divmod(const bigint& lhs, const bigint& rhs) {
    if (!rhs.a.size()) {
        std::cerr << "error: division by zero" << std::endl;
        exit(1);
    }
    bigint x(abs(rhs)), q, r;
    for (int i = lhs.a.size() - 1; i >= 0; --i) {
        r = r * BASE + lhs.a[i];
        int head = 0, tail = BASE;
        if (r >= x) {
            while (head + 1 < tail) {
                int_t mid = (head + tail) / 2;
                if (x * bigint(mid) > r) tail = mid;
                else head = mid;
            }
            r -= x * head;
        }
        q.a.push_back(head);
    }
    reverse(q.a.begin(), q.a.end());
    bool neg = lhs.negative ^ lhs.negative;
    q.negative = neg; r.negative = neg;
    return std::make_pair(q.normalize(), r.normalize());
}
inline std::istream& operator >> (std::istream& is, bigint& x) {
    std::string tmp; is >> tmp;
    x = bigint(tmp);
    return is;
}
inline std::ostream& operator << (std::ostream& os, const bigint& x) {
    if (x.negative) os << '-';
    if (!x.a.size()) os << 0;
    else os << x.a.back();
    for (int i = x.a.size() - 2; i >= 0; --i) {
        os.width(LEN);
        os.fill('0');
        os << x.a[i];
    }
    return os;
}
inline const bigint abs(bigint x) {
    x.negative = false;
    return x;
}

using namespace std;

int main() 
{
    int n, m, r;
    while (cin >> n >> m >> r) 
    {
        int x = r - n*m + n - 1;
        int y = r - m * n;
        bigint ans;
        if (y < 0 || x < 0) {
            ans = 0;
        }
        else
        {
            ans = 1;
            for (int i = 1; i <= y; i = i + 1) 
            {
                ans = ans * (x - i + 1);
                ans = ans / i;
            }
        }
        cout << ans << endl;
    }
}#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using int_t = long long;
constexpr int_t BASE = 100000000LL * 100000000LL, LEN = 16;
class bigint {
private:
    bool negative;
    std::vector<int_t> a;
    bigint& normalize();
public:
    bigint(int_t x = 0);
    bigint(const std::string& s);
    bigint& operator = (const bigint& x);
    bigint& operator = (int_t x);
    bigint& operator = (const std::string& s);
    const bool operator < (const bigint& x) const;
    const bool operator > (const bigint& x) const;
    const bool operator <= (const bigint& x) const;
    const bool operator >= (const bigint& x) const;
    const bool operator != (const bigint& x) const;
    const bool operator == (const bigint& x) const;
    bigint operator -() const;
    bigint& operator += (const bigint& x);
    bigint& operator -= (const bigint& x);
    bigint& operator *= (const bigint& x);
    bigint& operator /= (const bigint& x);
    bigint& operator %= (const bigint& x);
    const bigint operator + (const bigint& x) const;
    const bigint operator - (const bigint& x) const;
    const bigint operator * (const bigint& x) const;
    const bigint operator / (const bigint& x) const;
    const bigint operator % (const bigint& x) const;
    friend std::pair<bigint, bigint> divmod(const bigint& lhs, const bigint& rhs);
    friend std::istream& operator >> (std::ostream& is, bigint& x); //??????????£?
    friend std::ostream& operator << (std::ostream& os, const bigint& x);
    friend const bigint abs(bigint x);
};
inline bigint& bigint::normalize() {
    int i = a.size() - 1;
    while (i >= 0 && a[i] == 0) --i;
    a.resize(i + 1);
    if (a.size() == 0) negative = false;
    return *this;
}
inline bigint::bigint(int_t x) : negative(x < 0) {
    x = abs(x);
    for (; x > 0; x /= BASE) a.push_back(x % BASE);
}
inline bigint::bigint(const std::string& s) : negative(false) {
    int p = 0;
    if (s[p] == '-') { ++p; negative = true; }
    else if (s[p] == '+') { ++p; }
    for (int i = s.size() - 1, v = BASE; i >= p; --i, v *= 10) {
        int x = s[i] - '0';
        if (x < 0 || 9 < x) {
            std::cerr << "error: parse error:" << s << std::endl;
            exit(1);
        }
        if (v == BASE) {
            v = 1;
            a.push_back(x);
        }
        else a.back() += (x)*v;
    }
    normalize();
}
inline bigint& bigint::operator = (const bigint& x) {
    negative = x.negative;
    a = x.a;
    return *this;
}
inline bigint& bigint::operator = (int_t x) { return *this = bigint(x); }
inline bigint& bigint::operator = (const std::string& s) { return *this = bigint(s); }
inline const bool bigint::operator < (const bigint& x) const {
    if (negative != x.negative) return negative > x.negative;
    if (a.size() != x.a.size()) return (a.size() < x.a.size()) ^ negative;
    for (int i = a.size() - 1; i >= 0; --i)
        if (a[i] != x.a[i]) return (a[i] < x.a[i]) ^ negative;
    return false;
}
inline const bool bigint::operator > (const bigint& x) const { return x<(*this); }
inline const bool bigint::operator <= (const bigint& x) const { return !(x<(*this)); }
inline const bool bigint::operator >= (const bigint& x) const { return !((*this)<x); }
inline const bool bigint::operator != (const bigint& x) const { return (*this)<x || x<(*this); }
inline const bool bigint::operator == (const bigint& x) const { return !((*this)<x || x<(*this)); }
inline bigint bigint::operator -() const {
    bigint ret(*this);
    if (a.size()) ret.negative = !ret.negative;
    return ret;
}
inline bigint& bigint::operator += (const bigint& x) {
    if (negative != x.negative) return *this -= -x;
    if (a.size() < x.a.size()) a.resize(x.a.size());
    int_t tmp = 0;
    for (int i = 0; i < a.size(); ++i) {
        a[i] += (i<x.a.size() ? x.a[i] : 0) + tmp;
        tmp = a[i] / BASE;
        a[i] %= BASE;
    }
    if (tmp) a.push_back(1);
    return *this;
}
inline bigint& bigint::operator -= (const bigint& x) {
    if (negative != x.negative) return *this += -x;
    std::vector<int_t> b(x.a);
    if ((*this < x) ^ negative) {
        a.swap(b);
        negative = !negative;
    }
    int_t tmp = 0;
    for (int i = 0; i < a.size(); ++i) {
        a[i] += BASE - (i<b.size() ? b[i] : 0) + tmp;
        tmp = a[i] / BASE - 1;
        a[i] %= BASE;
    }
    return this->normalize();
}
inline bigint& bigint::operator *= (const bigint& x) {
    negative ^= x.negative;
    std::vector<int_t> c(a.size()*x.a.size() + 1);
    for (int i = 0; i < a.size(); ++i) {
        long long tmp = 0;
        for (int j = 0; j < x.a.size(); ++j) {
            long long v = (long long)a[i] * x.a[j] + c[i + j] + tmp;
            tmp = v / BASE;
            c[i + j] = (int_t)(v % BASE);
        }
        if (tmp) c[i + x.a.size()] += (int_t)tmp;
    }
    a.swap(c);
    return this->normalize();
}
inline bigint& bigint::operator /= (const bigint& x) {
    return *this = divmod(*this, x).first;
}
inline bigint& bigint::operator %= (const bigint& x) {
    return *this = divmod(*this, x).second;
}
inline const bigint bigint::operator + (const bigint& x) const {
    bigint res(*this); return res += x;
}
inline const bigint bigint::operator - (const bigint& x) const {
    bigint res(*this); return res -= x;
}
inline const bigint bigint::operator * (const bigint& x) const {
    bigint res(*this); return res *= x;
}
inline const bigint bigint::operator / (const bigint& x) const {
    bigint res(*this); return res /= x;
}
inline const bigint bigint::operator % (const bigint& x) const {
    bigint res(*this); return res %= x;
}
inline std::pair<bigint, bigint> divmod(const bigint& lhs, const bigint& rhs) {
    if (!rhs.a.size()) {
        std::cerr << "error: division by zero" << std::endl;
        exit(1);
    }
    bigint x(abs(rhs)), q, r;
    for (int i = lhs.a.size() - 1; i >= 0; --i) {
        r = r * BASE + lhs.a[i];
        int head = 0, tail = BASE;
        if (r >= x) {
            while (head + 1 < tail) {
                int_t mid = (head + tail) / 2;
                if (x * bigint(mid) > r) tail = mid;
                else head = mid;
            }
            r -= x * head;
        }
        q.a.push_back(head);
    }
    reverse(q.a.begin(), q.a.end());
    bool neg = lhs.negative ^ lhs.negative;
    q.negative = neg; r.negative = neg;
    return std::make_pair(q.normalize(), r.normalize());
}
inline std::istream& operator >> (std::istream& is, bigint& x) {
    std::string tmp; is >> tmp;
    x = bigint(tmp);
    return is;
}
inline std::ostream& operator << (std::ostream& os, const bigint& x) {
    if (x.negative) os << '-';
    if (!x.a.size()) os << 0;
    else os << x.a.back();
    for (int i = x.a.size() - 2; i >= 0; --i) {
        os.width(LEN);
        os.fill('0');
        os << x.a[i];
    }
    return os;
}
inline const bigint abs(bigint x) {
    x.negative = false;
    return x;
}

using namespace std;

int main() 
{
    int n, m, r;
    while (cin >> n >> m >> r) 
    {
        int x = r - n*m + n - 1;
        int y = r - m * n;
        bigint ans;
        if (y < 0 || x < 0) {
            ans = 0;
        }
        else
        {
            ans = 1;
            for (int i = 1; i <= y; i = i + 1) 
            {
                ans = ans * (x - i + 1);
                ans = ans / i;
            }
        }
        cout << ans << endl;
    }
}

Compiler output:
a.cc:226:2: error: stray '#' in program
  226 | }#include <iostream>
      |  ^
a.cc: In constructor 'bigint::bigint(const std::string&)':
a.cc:56:36: warning: overflow in conversion from 'long long int' to 'int' changes value from '10000000000000000' to '1874919424' [-Woverflow]
   56 |     for (int i = s.size() - 1, v = BASE; i >= p; --i, v *= 10) {
      |                                    ^~~~
a.cc: In function 'std::pair<bigint, bigint> divmod(const bigint&, const bigint&)':
a.cc:165:30: warning: overflow in conversion from 'long long int' to 'int' changes value from '10000000000000000' to '1874919424' [-Woverflow]
  165 |         int head = 0, tail = BASE;
      |                              ^~~~
a.cc: At global scope:
a.cc:226:3: error: 'include' does not name a type
  226 | }#include <iostream>
      |   ^~~~~~~
a.cc:232:17: error: redefinition of 'constexpr const int_t BASE'
  232 | constexpr int_t BASE = 100000000LL * 100000000LL, LEN = 16;
      |                 ^~~~
a.cc:7:17: note: 'constexpr const int_t BASE' previously defined here
    7 | constexpr int_t BASE = 100000000LL * 100000000LL, LEN = 16;
      |                 ^~~~
a.cc:232:51: error: redefinition of 'constexpr const int_t LEN'
  232 | constexpr int_t BASE = 100000000LL * 100000000LL, LEN = 16;
      |                                                   ^~~
a.cc:7:51: note: 'constexpr const int_t LEN' previously defined here
    7 | constexpr int_t BASE = 100000000LL * 100000000LL, LEN = 16;
      |                                                   ^~~
a.cc:233:7: error: redefinition of 'class bigint'
  233 | class bigint {
      |       ^~~~~~
a.cc:8:7: note: previous definition of 'class bigint'
    8 | class bigint {
      |       ^~~~~~
a.cc:266:16: error: redefinition of 'bigint& bigint::normalize()'
  266 | inline bigint& bigint::normalize() {
      |                ^~~~~~
a.cc:41:16: note: 'bigint& bigint::normalize()' previously defined here
   41 | inline bigint& bigint::normalize() {
      |                ^~~~~~
a.cc:273:8: error: redefinition of 'bigint::bigint(int_t)'
  273 | inline bigint::bigint(int_t x) : negative(x < 0) {
      |        ^~~~~~
a.cc:48:8: note: 'bigint::bigint(int_t)' previously defined here
   48 | inline bigint::bigint(int_t x) : negative(x < 0) {
      |        ^~~~~~
a.cc:277:8: error: redefinition of 'bigint::bigint(const std::string&)'
  277 | inline bigint::bigint(const std::string& s) : negative(false) {
      |        ^~~~~~
a.cc:52:8: note: 'bigint::bigint(const std::string&)' previously defined here
   52 | inline bigint::bigint(const std::string& s) : negative(false) {
      |        ^~~~~~
a.cc:295:16: error: redefinition of 'bigint& bigint::operator=(const bigint&)'
  295 | inline bigint& bigint::operator = (const bigint& x) {
      |                ^~~~~~
a.cc:70:16: note: 'bigint& bigint::operator=(const bigint&)' previously defined here
   70 | inline bigint& bigint::operator = (const bigint& x) {
      |                ^~~~~~
a.cc:300:16: error: redefinition of 'bigint& bigint::operator=(int_t)'
  300 | inline bigint& bigint::operator = (int_t x) { return *this = bigint(x); }
      |                ^~~~~~
a.cc:75:16: note: 'bigint& bigint::operator=(int_t)' previously defined here
   75 | inline bigint& bigint::operator = (int_t x) { return *this = bigint(x); }
      |                ^~~~~~
a.cc:301:16: error: redefinition of 'bigint& bigint::operator=(const std::string&)'
  301 | inline bigint& bigint::operator = (const std::string& s) { return *this = bigint(s); }
      |                ^~~~~~
a.cc:76:16: note: 'bigint& bigint::operator=(const std::string&)' previously defined here
   76 | inline bigint& bigint::operator = (const std::string& s) { return *this = bigint(s); }
      |                ^~~~~~
a.cc:302:19: error: redefinition of 'const bool bigint::operator<(const bigint&) const'
  302 | inline const bool bigint::operator < (const bigint& x) const {
      |                   ^~~~~~
a.cc:77:19: note: 'const bool bigint::operator<(const bigint&) const' previously defined here
   77 | inline const bool bigint::operator < (const bigint& x) const {
      |                   ^~~~~~
a.cc:309:19: error: redefinition of 'const bool bigint::operator>(const bigint&) const'
  309 | inline const bool bigint::operator > (const bigint& x) const { return x<(*this); }
      |                   ^~~~~~
a.cc:84:19: note: 'const bool bigint::operator>(const bigint&) const' previously defined here
   84 | inline const bool bigint::operator > (const bigint& x) const { return x<(*this); }
      |                   ^~~~~~
a.cc:310:19: error: redefinition of 'const bool bigint::operator<=(const bigint&) const'
  310 | inline const bool bigint::operator <= (const bigint& x) const { return !(x<(*this)); }
      |                   ^~~~~~
a.cc:85:19: note: 'const bool bigint::operator<=(const bigint&) const' previously defined here
   85 | inline const bool bigint::operator <= (const bigint& x) const { return !(x<(*this)); }
      |                   ^~~~~~
a.cc:311:19: error: redefinition of 'const bool bigint::operator>=(const bigint&) const'
  311 | inline const bool bigint::operator >= (const bigint& x) const { return !((*this)<x); }
      |                   ^~~~~~
a.cc:86:19: note: 'const bool bigint::operator>=(const bigint&) const' previously defined here
   86 | inline const bool bigint::operator >= (const bigint& x) const { return !((*this)<x); }
      |                   ^~~~~~
a.cc:312:19: error: redefinition of 'const bool bigint::operator!=(const bigint&) const'
  312 | inline const bool bigint::operator != (const bigint& x) const { return (*this)<x || x<(*this); }
      |                   ^~~~~~
a.cc:87:19: note: 'const bool bigint::operator!=(const bigint&) const' previously defined here
   87 | inline const bool bigint::operator != (const bigint& x) const { return (*this)<x || x<(*this); }
      |                   ^~~~~~
a.cc:313:19: error: redefinition of 'const bool bigint::operator==(const bigint&) const'
  313 | inline const bool bigint::operator == (const bigint& x) const { return !((*this)<x || x<(*this)); }
      |                   ^~~~~~
a.cc:88:19: note: 'const bool bigint::operator==(const bigint&) const' previously defined here
   88 | inline const bool bigint::operator == (const bigint& x) const { return !((*this)<x || x<(*this)); }
      |                   ^~~~~~
a.cc:314:15: error: redefinition of 'bigint bigint::operator-() const'
  314 | inline bigint bigint::operator -() const {
      |               ^~~~~~
a.cc:89:15: note: 'bigint bigint::operator-() const' previously defined here
   89 | inline bigint bigint::operator -() const {
      |               ^~~~~~
a.cc:319:16: error: redefinition of 'bigint& bigint::operator+=(const bigint&)'
  319 | inline bigint& bigint::operator += (const bigint& x) {
      |                ^~~~~~
a.cc:94:16: note: 'bigint& bigint::operator+=(const bigint&)' previously defined here
   94 | inline bigint& bigint::operator += (const bigint& x) {
      |                ^~~~~~
a.cc:331:16: error: redefinition of 'bigint& bigint::operator-=(const bigint&)'
  331 | inline bigint& bigint::operator -= (const bigint& x) {
      |                ^~~~~~
a.cc:106:16: note: 'bigint& bigint::operator-=(const bigint&)' previously defined here
  106 | inline bigint& bigint::operator -= (const bigint& x) {
      |                ^~~~~~
a.cc:346:16: error: redefinition of 'bigint& bigint::operator*=(const bigint&)'
  346 | inline bigint& bigint::operator *= (const bigint& x) {
      |                ^~~~~~
a.cc:121:16: note: 'bigint& bigint::operator*=(const bigint&)' previously defined here
  121 | inline bigint& bigint::operator *= (const bigint& x) {
      |                ^~~~~~
a.cc:361:16: error: redefinition of 'bigint& bigint::operator/=(const bigint&)'
  361 | inline bigint& bigint::operator /= (const bigint& x) {
      |                ^~~~~~
a.cc:136:16: note: 'bigint& bigint::operator/=(const bigint&)' previously defined here
  136 | inline bigint& bigint::operator /= (const bigint& x) {
      |                ^~~~~~
a.cc:364:16: error: redefinition of 'bigint& bigint::operator%=(const bigint&)'
  364 | inline bigint& bigint::operator %= (const bigint& x) {
      |                ^~~~~~
a.cc:139:16: note: 'bigint& bigint::operator%=(const bigint&)' previously defined here
  139 | inline bigint& bigint::operator %= (const bigint& x) {
      |                ^~~~~~
a.cc:367:21: error: redefinition of 'const bigint bigint::operator+(const bigint&) const'
  367 | inline const bigint bigint::operator + (const bigint& x) const {
      |                     ^~~~~~
a.cc:142:21: note: 'const bigint bigint::operator+(const bigint&) const' previously defined here
  142 | inline const bigint bigint::operator + (const bigint& x) const {
      |                     ^~~~~~
a.cc:370:21: error: redefinition of 'const bigint bigint::operator-(const bigint&) const'
  370 | inline const bigint bigint::operator - (const bigint& x) const {
      |                     ^~~~~~
a.cc:145:21: note: 'const bigint bigint::operator-(const bigint&) const' previously defined here
  145 | inline const bigint bigint::operator - (const bigint& x) const {
      |                     ^~~~~~
a.cc:373:21: error: redefinition of 'const bigint bigint::operator*(const bigint&) const'
  373 | inline const bigint bigint::operator * (const bigint& x) const {
      |                     ^~~~~~
a.cc:148:21: note: 'const bigint bigint::operator*(const bigint&) const' previously defined here
  148 | inline const bigint bigint::operator * (const bigint& x) const {
      |                     ^~~~~~
a.cc:376:21: error: redefinition of 'const bigint bigint::operator/(const bigint&) const'
  376 | inline const bigint bigint::operator / (const bigint& x) const {
      |                     ^~~~~~
a.cc:151:21: note: 'const bigint bigint::operator/(const bigint&) const' previously defined here
  151 | inline const bigint bigint::operator / (const bigint& x) const {
      |                     ^~~~~~
a.cc:379:21: error: redefinition of 'const bigint bigint::operator%(const bigint&) const'
  379 | inline const bigint bigint::o