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

struct integer{
private:
    bool negative;
    std::vector<unsigned int> digit;

    void add(unsigned int pos, unsigned int val){
        if(pos >= digit.size()) digit.insert(digit.end(), pos-digit.size()+1, 0);
        if(digit[pos] > (unsigned int)(0-val)) add(pos+1, 1);
        digit[pos] += val;
    }
    void sub(unsigned int pos, unsigned int val){
        if(digit[pos] < val) sub(pos+1, 1);
        digit[pos] -= val;
        if(digit[pos] == 0 && pos+1 == digit.size() && pos != 0) digit.pop_back();
    }
    bool abs_greater(const integer& i) const{
        if(digit.size() != i.digit.size()) return digit.size() > i.digit.size();

        for(int k = digit.size()-1; k >= 0; k--)
            if(digit[k] != i.digit[k]) return digit[k] > i.digit[k];

        return 0;
    }
    integer& shift(unsigned i){
        digit.insert(digit.begin(), i, 0);
        return *this;
    }
    std::pair<integer, integer> div(const integer& i) const{
        std::pair<integer, integer> p(0, *this);
        p.second.negative ^= i.negative;

        while(!i.abs_greater(p.second)){
            int s = p.second.digit.size() - i.digit.size();
            int k = p.second.digit.back()/(i.digit.back()+1);
            if(k == 0) k = 1;

            p.second -= (i*k).shift(s);
            p.first += integer(k).shift(s);
        }
        return p;
    }

public:
    int to_int() const{
        return digit.size() > 0 ? digit[0] : 0;
    }
    integer(int i){
        digit.clear();
        if(negative = i < 0) digit.push_back(-i);
        else digit.push_back(i);
    }
    integer(){}

    friend std::ostream& operator << (std::ostream&, integer);
    friend std::istream& operator >> (std::istream&, integer&);
    friend bool operator == (const integer&, const integer&);
    friend bool operator != (const integer&, const integer&);
    friend bool operator > (const integer&, const integer&);
    friend bool operator <= (const integer&, const integer&);
    friend bool operator < (const integer&, const integer&);
    friend bool operator >= (const integer&, const integer&);

    integer operator = (const integer& i){
        digit = i.digit;
        negative = i.negative;
        return i;
    }

    integer operator += (const integer& i){
        if(negative == i.negative){
            for(unsigned int k = 0; k < i.digit.size(); k++)
                add(k, i.digit[k]);
        }else{
            if(i.abs_greater(*this)) *this = i - *this;
            else for(unsigned int k = 0; k < i.digit.size(); k++)
                    sub(k, i.digit[k]);
        }
        return *this;
    }
    integer operator + (const integer& i) const{
        integer tmp = *this;
        return tmp += i;
    }

    integer operator -= (const integer& i){
        return *this += -i;
    }
    integer operator - (const integer& i) const{
        integer tmp = *this;
        return tmp -= i;
    }

    integer operator * (const integer& i)const{
        integer r = 0;
        r.negative = negative ^ i.negative;

        for(unsigned int j = 0; j < digit.size(); j++)
            for(unsigned int k = 0; k < i.digit.size(); k++){
                unsigned long long int val = digit[j];
                val *= i.digit[k];
                if(val >> 32 > 0)
                    r.add(j+k+1, val>>32);
                r.add(j+k, (unsigned int)val);
            }
        return r;
    }
    integer operator *= (const integer& i){
        *this = *this * i;
        return *this;
    }

    integer operator / (const integer& i) const{
        return div(i).first;
    }
    integer operator /= (const integer& i){
        *this = *this / i;
        return *this;
    }

    integer operator % (const integer& i) const{
        return div(i).second;
    }
    integer operator %= (const integer& i){
        *this = *this % i;
        return *this;
    }

    integer operator -() const{
        integer i = *this;
        i.negative ^= 1;
        return i;
    }
};

bool operator == (const integer& a, const integer& b){
    if(a.negative != b.negative || a.digit.size() != b.digit.size()) return false;

    for(int i = a.digit.size() -1; i >= 0; i--)
        if(a.digit[i] != b.digit[i]) return false;

    return true;
}
bool operator != (const integer& a, const integer& b){
    return !(a==b);
}
bool operator > (const integer& a, const integer& b){
    if(a.negative ^ b.negative) return !a.negative;
    return a.abs_greater(b) ^ a.negative;
}
bool operator < (const integer& a, const integer& b){
    return !(a>b || a==b);
}
bool operator >= (const integer& a, const integer& b){
    return a>b || a==b;
}
bool operator <= (const integer& a, const integer& b){
    return !(a>b);
}

std::ostream& operator << (std::ostream& out, integer i){
    std::string str;
    if(i == 0) return out << 0;
    while(i > 0){
        str = char((i % 10).to_int()+'0') + str;
        i /= 10;
    }
    return out << str;
}

std::istream& operator >> (std::istream& in, integer& i){
    std::string str;
    in >> str;
    integer p = 1;
    i = 0;
    for(int j = str.length()-1; j >= 0; j--){
        i += integer(str[j]-'0')*p;
        p *= 10;
    }
    return in;
}

int main(){
    integer i, j;
    std::cout << "Enter two numbers.\n";
    std::cout << "a = ";
    std::cin >> i;
    std::cout << "b = ";
    std::cin >> j;

    std::cout << "a/b = " << i/j;

    std::cin.ignore().get();
    return 0;
}