#include <cstdio>

 #include <iostream>

 #include <vector>

 #include <iomanip>

 #include <cassert>

 #include <algorithm>

 #include <cstring>

 const int Big_B = ;

 const int Big_L = ;

 inline int intcmp_ (int a, int b) {

     if (a > b) return ;

     return a < b ? - : ;

 }

 struct Int {

 #define rg register

     inline int max (int a, int b) {

         return a > b ? a : b;

     }

     inline int min (int a, int b) {

         return a < b ? a : b;

     }

     std :: vector <int> c;

     Int () {} typedef long long LL;

     Int (int x) {

         for (; x > ; c.push_back (x % Big_B), x /= Big_B);

     }

     Int (LL x) {

         for (; x > ; c.push_back (x % Big_B), x /= Big_B);

     }

     inline void CrZ () {

         for (; !c.empty () && c.back () == ; c.pop_back ());

     }

     inline Int &operator += (const Int &rhs) {

         c.resize (max (c.size (), rhs.c.size ()));

         rg int i, t = , S;

         for (i = , S = rhs.c.size (); i < S; ++ i)

             c[i] += rhs.c[i] + t, t = c[i] >= Big_B, c[i] -= Big_B & (-t);

         for (i = rhs.c.size (), S = c.size (); t && i < S; ++ i)

             c[i] += t, t = c[i] >= Big_B, c[i] -= Big_B & (-t);

         if (t) c.push_back (t);

         return *this;

     }

     inline Int &operator -= (const Int &rhs) {

         c.resize (max (c.size (), rhs.c.size ()));

         rg int i, t = , S;

         for (i = , S = rhs.c.size (); i < S; ++ i)

             c[i] -= rhs.c[i] + t, t = c[i] < , c[i] += Big_B & (-t);

         for (i = rhs.c.size (), S = c.size (); t && i < S; ++ i)

             c[i] -= t, t = c[i] < , c[i] += Big_B & (-t);

         CrZ ();

         return *this;

     }

     inline Int &operator *= (const Int &rhs) {

         rg int na = c.size (), i, j, S, ai;

         c.resize (na + rhs.c.size ());

         LL t;

         for (i = na - ; i >= ; -- i) {

             ai = c[i], t = , c[i] = ;

             for (j = , S = rhs.c.size (); j < S; ++ j) {

                 t += c[i + j] + (LL) ai * rhs.c[j];

                 c[i + j] = t % Big_B, t /= Big_B;

             }

             for (j = rhs.c.size (), S = c.size (); t !=  && i + j < S; ++ j)

                 t += c[i + j], c[i + j] = t % Big_B, t /= Big_B;

             assert (t == );

         }

         CrZ ();

         return *this;

     }

     inline Int &operator /= (const Int &rhs) {

         return *this = div (rhs);

     }

     inline Int &operator %= (const Int &rhs) {

         return div (rhs), *this;

     }

     inline Int &shlb (int l = ) {

         if (c.empty ()) return *this;

         c.resize (c.size () + l);

         rg int i;

         for (i = c.size () - ; i >= l; -- i) c[i] = c[i - l];

         for (i = ; i < l; ++ i) c[i] = ;

         return *this;

     }

     inline Int &shrb (int l = ) {

         for (rg int i = ; i < c.size () - l; ++ i) c[i] = c[i + l];

         c.resize (max (c.size () - l, ));

         return *this;

     }

     inline int Comp (const Int &rhs) const {

         if (c.size () != rhs.c.size ()) return intcmp_ (c.size (), rhs.c.size ());

         for (rg int i = c.size () - ; i >= ; -- i)

             if (c[i] != rhs.c[i]) return intcmp_ (c[i], rhs.c[i]);

         return ;

     }

     inline Int div (const Int &rhs) {

         assert (!rhs.c.empty ());

         Int q, r;

         rg int i;

         if (rhs > *this) return ;

         q.c.resize (c.size () - rhs.c.size () + );

         rg int _l, _r, mid;

         for (i = c.size () - ; i > c.size () - rhs.c.size (); -- i) r.shlb (), r += c[i];

         for (i = c.size () - rhs.c.size (); i >= ; -- i) {

             r.shlb ();

             r += c[i];

             if (r.Comp (rhs) < ) q.c[i] = ;

             else {

                 _l = , _r = Big_B;

                 for (; _l != _r; ) {

                     mid = _l + _r >> ;

                     if ((rhs * mid).Comp (r) <= ) _l = mid + ;

                     else _r = mid;

                 }

                 q.c[i] = _l - , r -= rhs * q.c[i];

             }

         }

         q.CrZ (), *this = r;

         return q;

     }

     friend inline Int operator + (const Int &lhs, const Int &rhs) {

         Int res = lhs;

         return res += rhs;

     }

     friend inline Int operator - (const Int &lhs, const Int &rhs) {

         Int res = lhs;

         return res -= rhs;

     }

     friend inline Int operator * (const Int &lhs, const Int &rhs) {

         Int res = lhs;

         return res *= rhs;

     }

     friend inline Int operator / (const Int &lhs, const Int &rhs) {

         Int res = lhs;

         return res.div (rhs);

     }

     friend inline Int operator % (const Int &lhs, const Int &rhs) {

         Int res = lhs;

         return res.div (rhs), res;

     }

     friend inline std :: ostream &operator << (std :: ostream &out, const Int &rhs) {

         if (rhs.c.size () == ) out << "";

         else {

             out << rhs.c.back ();

             for (rg int i = rhs.c.size () - ; i >= ; -- i)

                 out << std :: setfill ('') << std :: setw (Big_L) << rhs.c[i];

         }

         return out;

     }

     friend inline std :: istream &operator >> (std :: istream &in, Int &rhs) {

         static char s[];

         in >> s + ;

         int Len = strlen (s + );

         int v = ;

         LL r = , p = ;

         for (rg int i = Len; i >= ; -- i) {

             ++ v;

             r = r + (s[i] - '') * p, p *= ;

             if (v == Big_L) rhs.c.push_back (r), r = , v = , p = ;

         }

         if (v != ) rhs.c.push_back (r);

         return in;

     }

     friend inline bool operator < (const Int &lhs, const Int &rhs) {

         return lhs.Comp (rhs) < ;

     }

     friend inline bool operator <= (const Int &lhs, const Int &rhs) {

         return lhs.Comp (rhs) <= ;

     }

     friend inline bool operator > (const Int &lhs, const Int &rhs) {

         return lhs.Comp (rhs) > ;

     }

     friend inline bool operator >= (const Int &lhs, const Int &rhs) {

         return lhs.Comp (rhs) >= ;

     }

     friend inline bool operator == (const Int &lhs, const Int &rhs) {

         return lhs.Comp (rhs) == ;

     }

     friend inline bool operator != (const Int &lhs, const Int &rhs) {

         return lhs.Comp (rhs) != ;

     }

 #undef rg

 };

 Int a;

 int Main () {

     return ;

 }

 int ZlycerQan = Main ();

 int main (int argc, char *argv[]) {

     ;

 }