Посоветуйте функции для арифметики больших целых чисел

#include <iostream>
#include <string>
#include <algorithm>
#include <cctype>
 
class BigInt
{
    std::string value = "0";
    bool sign = false;
    bool nan = false;
    static int _IntegerQ(const std::string&);
    static bool _GreaterEqualQ(const BigInt&, const BigInt&);
public:
    
    BigInt(){}
 
    BigInt(const std::string& s)
        : value(s)
    {
        auto s_q = _IntegerQ(s);
        if (s_q == 0)
            nan = true;
        else if (s_q == -1)
        {
            value.erase(0, 1);
            sign = true;
        }
    }
 
    BigInt(const char* s) : BigInt(std::string(s)) {}
 
    BigInt(const BigInt& x)
        : value(x.value)
        , sign(x.sign)
        , nan(x.nan)
    {}
 
    BigInt& operator=(const BigInt& x)
    {
        value = x.value;
        sign = x.sign;
        nan = x.nan;
        return *this;
    }
 
    BigInt& operator=(const char* s)
    {
        value = std::string(s);
        auto s_q = _IntegerQ(value);
        if (s_q == 0)
            nan = true;
        else
            nan = false;
        if (s_q == -1)
        {
            value.erase(0, 1);
            sign = true;
        }
        else
            sign = false;
        return *this;
    }
 
    friend std::ostream& operator<<(std::ostream& out, const BigInt& x)
    {
        if (x.nan)
            return out << "NAN";
        if (x.sign)
            return out << '-' << x.value;
        return out << x.value;
    }
 
    friend BigInt operator+(const BigInt& x, const BigInt& y)
    {
        return Add(x, y);
    }
 
    friend BigInt operator-(const BigInt& x, const BigInt& y)
    {
        return Subtract(x, y);
    }
 
    friend BigInt operator*(const BigInt& x, const BigInt& y)
    {
        return Multiply(x, y);
    }
 
    friend BigInt operator/(const BigInt& x, const BigInt& y)
    {
        return Divide(x, y);
    }
 
    friend BigInt operator%(const BigInt& x, const BigInt& y)
    {
        return Remainder(x, y);
    }
 
    friend BigInt operator^(const BigInt& x, const int y)
    {
        return Pow(x, y);
    }
 
 
    friend BigInt Add(const BigInt&, const BigInt&);
    friend BigInt Subtract(const BigInt&, const BigInt&);
    friend BigInt Abs(const BigInt&);
    friend BigInt Multiply(const BigInt&, const BigInt&);
    friend BigInt Divide(const BigInt&, const BigInt&);
    friend BigInt Remainder(const BigInt&, const BigInt&);
    friend BigInt Pow(const BigInt&, const int);
    friend BigInt Factorial(const int);
    friend BigInt GCD(const BigInt&, const BigInt&);
    friend BigInt LCM(const BigInt&, const BigInt&);
    friend BigInt ISqrt(const BigInt&);
    friend BigInt Fibonacci(const int);
 
};
 
BigInt Add(const BigInt&, const BigInt&);
BigInt Subtract(const BigInt&, const BigInt&);
BigInt Abs(const BigInt&);
BigInt Multiply(const BigInt&, const BigInt&);
BigInt Divide(const BigInt&, const BigInt&);
BigInt Remainder(const BigInt&, const BigInt&);
BigInt Pow(const BigInt&, const int);
BigInt Factorial(const int);
BigInt GCD(const BigInt&, const BigInt&);
BigInt LCM(const BigInt&, const BigInt&);
BigInt ISqrt(const BigInt&);
BigInt Fibonacci(const int);
 
int main()
{
    BigInt a = "10";
    BigInt b = "-3";
    auto c = a + b;
    std::cout << c;
}
 
int BigInt::_IntegerQ(const std::string& s)
{
    //
}
 
bool BigInt::_GreaterEqualQ(const BigInt& x, const BigInt& y)
{
    //
}
 
BigInt Subtract(const BigInt& x, const BigInt& y)
{
    //
}
 
BigInt Add(const BigInt& x, const BigInt& y)
{
    //
}
 
BigInt Multiply(const BigInt& x, const BigInt& y)
{
    //
}
 
BigInt Divide(const BigInt& x, const BigInt& y)
{
    //
}
 
BigInt Remainder(const BigInt& x, const BigInt& y)
{
    //
}
 
BigInt Pow(const BigInt& x, const int p)
{
    //
}
 
BigInt Factorial(const int n)
{
    //
}
 
BigInt GCD(const BigInt& x, const BigInt& y)
{
    //
}
 
BigInt LCM(const BigInt& x, const BigInt& y)
{
    //
}
 
BigInt Abs(const BigInt& x)
{
    //
}
 
BigInt ISqrt(const BigInt& x)
{
    //
}
 
BigInt Fibonacci(const int n)
{
    //
}

template <typename Op, typename A1, typename A2 = A1>
class BinaryOp : Op 
{
public:
    BinaryOp(const A1& a, const A2& b)
        : a(a), b(b)
    {}
    operator auto() const &&
    {
        return Op::operator()(a, b);           
    }
    BinaryOp(BinaryOp const&) = delete;
    BinaryOp& operator=(BinaryOp const&) = delete; 
 
private:
    A1 const& a;
    A2 const& b;
};
 
class BigInt {
public:
    BigInt operator+(const BigInt&) const
    {
        return {};
    }
    BigInt operator-(const BigInt&) const
    {
        return {};
    }
    BigInt pow(int) const
    {
        return {};
    }
 
    using Add = BinaryOp<decltype([](const auto& a, const auto& b) { return a + b; }), BigInt>;
    using Subtract = BinaryOp<decltype([](const auto& a, const auto& b) { return a - b; }), BigInt>;
    using Pow = BinaryOp<decltype([](const auto& x, int p) { return x.pow(p); }), BigInt, int>;
};
 
int main() {
 
    BigInt a;
    BigInt b;
 
    auto x = a + b;
 
    auto r = BigInt::Add(a, b);
}