【模板】高精度

（待完善）

#define BIG_NUMBER_SIZE (1000 + 5) 

struct Big_Number
{
    int bit[BIG_NUMBER_SIZE], size;
    bool sign;
    
    Big_Number()
    {
        sign = false;
        size = 1;
        memset(bit, 0, sizeof bit);
    }
    
    Big_Number Abs() // 不改变原来的值 
    {
        Big_Number tmp = *this;
        tmp.sign = false;
        return tmp;
    }
    
    Big_Number Opp() // 不改变原来的值 
    {
        Big_Number tmp = *this;
        tmp.sign = !tmp.sign;
        return tmp;
    }
    
    void Clear()
    {
        sign = false;
        size = 1;
        memset(bit, 0, sizeof bit);
        return;
    }
    
    void Read()
    {
        char s[BIG_NUMBER_SIZE];
        scanf("%s", s);
        size = strlen(s);
        if(s[0] == '-')
        {
            sign = true;
            for(register int i = 1, j = size - 1; i < size; ++i, --j)
            {
                bit[i] = s[j] - '0';
            }
            --size;
        }
        else
        {
            for(register int i = 1, j = size - 1; i <= size; ++i, --j)
            {
                bit[i] = s[j] - '0';
            }
        }
        return;
    }
    
    void Write()
    {
        if(sign) putchar('-');
        for(register int i = size; i; --i)
        {
            printf("%d", bit[i]);
        }
        return;
    }
    
    friend bool operator == (Big_Number x, Big_Number y)
    {
        if(x.size != y.size || x.sign != y.sign) return false;
        for(register int i = x.size; i; --i)
        {
            if(x.bit[i] != y.bit[i]) return false;
        }
        return true;
    }
    
    friend bool operator < (Big_Number x, Big_Number y)
    {
        if(x.size != y.size) return x.size < y.size;
        if(x.sign != y.sign) return x.sign;
        for(register int i = x.size; i; --i)
        {
            if(x.bit[i] != y.bit[i]) return x.bit[i] < y.bit[i];
        }
        return false;
    }
    
    friend bool operator <= (Big_Number x, Big_Number y)
    {
        return x < y || x == y;
    }
    
    friend bool operator > (Big_Number x, Big_Number y)
    {
        return !(x <= y);
    } 
    
    friend bool operator >= (Big_Number x, Big_Number y)
    {
        return !(x < y);
    }
    
    friend Big_Number operator + (Big_Number x, Big_Number y)
    {
        if(x.sign == y.sign)
        {
            if(x.size < y.size) x.size = y.size;
            for(register int i = 1; i <= x.size; ++i)
            {
                x.bit[i] += y.bit[i];    
            }
            for(register int i = 1; i <= x.size; ++i)
            {
                if(x.bit[i] >= 10)
                {
                    if(i == x.size) ++x.size;
                    ++x.bit[i + 1];
                    x.bit[i] -= 10; 
                }
            }
        }
        else 
        {
            if(x.Abs() < y.Abs()) swap(x, y);
            for(register int i = 1; i <= x.size; ++i)
            {
                x.bit[i] -= y.bit[i];
            }
            for(register int i = 1; i <= x.size; ++i)
            {
                if(x.bit[i] < 0)
                {
                    --x.bit[i + 1];
                    x.bit[i] += 10;
                }
            }
            while(x.size > 1 && !x.bit[x.size]) --x.size;
        }
        return x;
    }
    
    friend Big_Number operator += (Big_Number & x, Big_Number y)
    {
        return x = x + y;
    }
    
    friend Big_Number operator - (Big_Number x, Big_Number y)
    {
        return x + y.Opp();
    }
    
    friend Big_Number operator -= (Big_Number & x, Big_Number y)
    {
        return x = x - y;
    }
    
    friend Big_Number operator * (Big_Number x, Big_Number y)
    {
        Big_Number z;
        z.size = x.size + y.size - 1;
        z.sign = x.sign != y.sign;
        for(register int i = 1; i <= x.size; ++i)
        {
            for(register int j = 1; j <= y.size; ++j)
            {
                z.bit[i + j - 1] += x.bit[i] * y.bit[j];
            }
        }
        x = z;
        for(register int i = 1; i <= x.size; ++i)
        {
            if(x.bit[i] >= 10)
            {
                if(i == x.size) ++x.size;
                x.bit[i + 1] += x.bit[i] / 10;
                x.bit[i] %= 10; 
            }
        }
        while(x.size > 1 && !x.bit[x.size]) --x.size;
        return x;
    }
    
    friend Big_Number operator *= (Big_Number & x, Big_Number y)
    {
        return x = x * y; 
    } 
};