#include <string>
#include <iostream>
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))

typedef unsigned int bigint_unit;
typedef unsigned long long int bigint_buffer;
const bigint_buffer HALF_MASK = 0x00000000ffffffff;

class bigint_result_buffer
{
protected:
    bigint_unit *arr;
    int size;
    int nint;
    int cut_size;

    void cut() { arr[nint - 1] &= ~(0xffffffff << cut_size); }
};

class bigint : bigint_result_buffer
{
public:
    bigint(int size)
    {
        this->size = size;
        cut_size = size % sizeof(bigint_unit);
        nint = size / sizeof(bigint_unit) + (cut_size ? 1 : 0);
        arr = new bigint_unit[nint];
        *this = 0;
        this->cut();
    }

    int get_size() { return size; }
    int get_nint() { return nint; }
    bigint_unit get_arr(int n) { return (n < nint ? arr[n] : 0); }

    bigint operator= (bigint src)
    {
        memcpy(this->arr, src.arr, min(this->nint, src.nint));
        for (int i = src.nint; i < this->nint; i++)
            this->arr[i] = 0;
        this->cut();
        return *this;
    }

    bigint operator= (long long int src)
    {
        arr[0] = src & HALF_MASK;
        if (nint > 1)
            arr[1] = src >> 32;
        for (int i = 2; i < nint; i++)
            arr[i] = 0;
        this->cut();
        return *this;//*this;
    }


    bigint operator+(bigint a)
    {
        bigint res(max(this->size, a.size));
        bigint_buffer buffer;
        int space = max(this->nint, a.nint);
        int n = min(this->size, a.size);
        int i;

        res.arr[0] = 0;
        for (i = 0; i < n; i++)
        {
            buffer = this->arr[i] + a.arr[i];
            res.arr[i] += buffer & HALF_MASK;
            if (space > i + 1)
                res.arr[i + 1] = buffer >> 32;
        }
        for (i++; i < space; i++)
            res.arr[i] = 0;

        res.cut();
        return res;
    }

    bigint operator+(long long int s)
    {
        bigint res(1);
        res = *this;
        int a = s & HALF_MASK;
        int b = s >> 32;

        s = res.arr[0] + a;
        res.arr[0] = s & HALF_MASK;
        if (nint > 1)
        {
            s = res.arr[1] + b + (s >> 32);
            res.arr[1] = s & HALF_MASK;
        }
        if (nint > 2)
        {
            s = res.arr[2] + s >> 32;
            res.arr[1] = s & HALF_MASK;
        }
        res.cut();
        return res;
    }

    ~bigint() { delete[] arr; }

private:
    static bigint_result_buffer result_buffer;

//  inline void signing( )
};


void print_arr(bigint b)
{
    for (int i = 0; i < b.get_nint(); i++)
        std::cout << b.get_arr(i) << std::endl;
}


using namespace std;
int main()
{
    //bigint b(16);
    //long long a = UINT_MAX;

    //b = b + a;

    //print_arr(b);
    //b = b + a;

    //print_arr(b);

    //cout << sizeof(bigint) << endl << sizeof(bigint_result_buffer) << endl;
    bigint b(16);
    int a = 2;
    b = a;
    print_arr(b);

    getchar();
    return 0;
}