#include <iostream>

using namespace std;

class Niz
{
    unsigned _duzina;
    unsigned _obezbedjeno;
    int* _elementi;


    void ispis( ostream& ostr ) const
        {
        ostr << '[' << _duzina << ':';
        for( unsigned i=0; i<_duzina; i++ )
            ostr << _elementi[i] << ',';
        ostr << "\b]";
        }


    friend ostream& operator <<(ostream&,const Niz&);


    void povecanjeNiza( unsigned n )
        {
        if( n <= _duzina )
            return;
        if( n > _obezbedjeno )
	    {
            unsigned ob = n;
            int pomocna = _duzina*2;
            if( pomocna > ob )
            	ob = pomocna;
            int* novi = new int[ob];
            for( unsigned i=0; i<_duzina; i++ )
                novi[i] = _elementi[i];
            delete [] _elementi;
            _elementi = novi;
	    _obezbedjeno = ob;
            }

        for( unsigned i=_duzina; i<n; i++ )
            _elementi[i] = 0;
        _duzina = n;
        }

public:

    Niz()
        : _duzina(0),
          _obezbedjeno(0),
          _elementi(0)
        {}


    Niz( const Niz& n)
        : _duzina(n._duzina),
          _obezbedjeno(n._duzina),
          _elementi( n._duzina>0 ?
          new int[n._duzina] : 0 )
        {
        for( unsigned i=0; i<_duzina; i++ )
            _elementi[i] = n._elementi[i];
        }


    ~Niz()
        {
        delete [] _elementi;
        }


    Niz& operator = (const Niz& n)
        {
        if( this != &n ){
            delete [] _elementi;
            _duzina = n._duzina;
            _obezbedjeno = n._duzina;
            _elementi = n._duzina>0 ?
            new int[n._duzina] : 0;
            for( unsigned i=0; i<_duzina; i++ )
                _elementi[i] = n._elementi[i];
            }
        return *this;
        }


    unsigned Duzina() const
        {
        return _duzina;
        }


    int& operator [] (unsigned i)
        {
        if( i >= _duzina )
            povecanjeNiza( i+1 );
        return _elementi[i];
        }
};



ostream& operator << ( ostream& ostr, const Niz& n )

{
    n.ispis(ostr);
    return ostr;
}



class VPB
{

Niz _cifre;

//vraca negativan br. ako je prvi arg. manji od drugog
int Poredjenje( VPB& b)
    {
    int i = BrojCifara() - b.BrojCifara();
    if(i) return i;
         
    for(unsigned j=BrojCifara()-1;j>0;j--)
        {
        i = _cifre[j] - b._cifre[j];
        if(i) return i;
        }
    return _cifre[0] - b._cifre[0];
    }


public:
    
    VPB():_cifre()
    {}

    VPB(unsigned x) 
    {
    for(unsigned i=0;x>0;i++)
        {
        _cifre[i] = x % 10;
        x = x / 10;
        }
    }



    unsigned BrojCifara() const
    {
    return _cifre.Duzina();
    }



    int& operator [] (unsigned i)
    {
    return _cifre[i];
    }


    void Pisi( ostream& ostr )
    {
    unsigned bc = BrojCifara();
    if (bc)
    for(int i=bc-1;i>=0;i--)
        ostr << _cifre[i];
    else ostr << 0;

    }


    void Citaj (istream& istr)
    {
    cin >> ws; //preskace prazna mesta
    unsigned i = 0;
    int c = istr.get();
    while ( istr && c>='0' && c<='9')
        {
        _cifre[i++] = c - '0';
        c = istr.get();
        }
    istr.putback(c);//ucitali smo jedan znak vise (blanko)

    //da budu cifre poredjane u obrnutom redosledu
    for(unsigned j=0;j<i; ) 
        {
        int tmp = _cifre[--i];
        _cifre[i] = _cifre[j];
        _cifre[j++] = tmp;
        }

    }

    
    VPB operator + ( VPB& b)
    {
    VPB r(*this);
    r+=b;
    return r;
    }


    VPB& operator = ( const VPB& b)
    {
    _cifre = b._cifre; //koristimo op.dodele za objekte klase Niz
    return *this;
    }


    VPB& operator += ( VPB& b) 
    {
    unsigned prenos = 0;
    unsigned i;
    unsigned bc = b.BrojCifara();
    for(i=0;i<bc;i++)
        if((_cifre[i]+= b[i]+prenos)>9)
        {
        prenos = _cifre[i]/10;
        _cifre[i]%=10;
        }
        else prenos = 0;

    for( ;prenos>0;i++)
        {
        prenos+= _cifre[i];
        _cifre[i] = prenos % 10;
        prenos = _cifre[i] / 10;
        }

    return *this;
    }

    //operatror-
    //operator *

    bool operator == ( VPB& b)
    {
    return !Poredjenje(b);
    }

    bool operator > (VPB& b)
    {
    return (Poredjenje(b)>0);
    }
    
    //operator <, <=, >=, !=

};


ostream& operator <<( ostream& ostr,VPB& n)
{
    n.Pisi(ostr);
    return ostr;
}


istream& operator >> (istream& istr,VPB& n)
{
n.Citaj(istr);
return istr;
}


/*
VPB fakt(unsigned n)
{ VPB r(1);
for(unsigned i=2;i<=n;i++)
    {
    r = r * i;
    }
    return r;
}
*/

main() 
{

  /*VPB zbir(0);
    for(unsigned i=100;i>=1;i--)
    zbir += fakt(i);
    cout << "Zbir je:" << zbir;*/

    VPB v;
    VPB c;
    cout << "Unesi dva prirodna broja v i c:" << endl;
                                    
    cin >> v >> c;
    if(v==c)cout << "v i c su jednaki brojevi!" << endl;
                                    
    else 
    {
    cout << "v i c su razliciti brojevi!" << endl;
    if(v>c)cout << "Pri tom je v vece od c!" << endl;
    else cout << "Pri tom je v manje od c." << endl;
    }
    return 0;
}