Математици, тук се спрете, моля бързо помогнете и задачата решете!

#include<iostream>
#include<string>
#include<vector>
using namespace std;
struct long_number
{
    string num;
    bool positive = true;
};
long_number extraction(long_number x,long_number y);
int comp(long_number x,long_number y)
{
    //0-equal,1-x is bigger,2-y is bigger
    //cout<<x.num<<" "<<y.num<<endl;
    if(x.num==y.num && x.positive==y.positive)return 0;
    if(x.positive>y.positive)return 1;
    if(y.positive>x.positive)return 2;
    if(x.positive==1)
    {
        if(x.num.size()>y.num.size())return 1;
        if(x.num.size()<y.num.size())return 2;
        for(int i=0;i<x.num.size();i++)
            if(x.num>y.num){return 1;}
            else if(x.num<y.num){return 2;}
    }
    //cout<<x.num<<" "<<y.num<<endl;
    if(x.positive==0)
    {
        if(x.num.size()>y.num.size())return 2;
        if(x.num.size()<y.num.size())return 1;
        for(int i=0;i<x.num.size();i++)if(x.num>y.num)return 2;else if(x.num<y.num)return 1;
        }
}
long_number addition(long_number x,long_number y)
{
    long_number ans;
    if(x.positive==y.positive)
    {
        ans.positive=x.positive;
        if(x.num.size()<y.num.size())while(x.num.size()<y.num.size())x.num="0"+x.num;
        if(y.num.size()<x.num.size())while(y.num.size()<x.num.size())y.num="0"+y.num;
        //cout<<x.num<<" "<<y.num<<endl;
        int pren=0;
        ans.num="";
        for(int i=x.num.size()-1;i>=0;i--)
        {
            char c=x.num-'0'+y.num-'0'+pren;
            pren=c/10;
            c%=10;
            //cout<<(int)c<<" "<<pren<<endl;
            c+='0';
            string t="";
            t+=c;
            ans.num=t+ans.num;
        }
        if(pren==1)ans.num="1"+ans.num;
        return ans;
    }
    if(x.positive!=y.positive)
    {
        long_number ans;
        int xp=x.positive,yp=y.positive;
        x.positive=1;
        y.positive=1;
        if(comp(x,y)==0){ans.num="0";ans.positive=1;return ans;}
        if(comp(x,y)==1)
        {
            ans.positive=xp;
            ans.num=extraction(x,y).num;
        }
        if(comp(x,y)==2)
        {
            ans.positive=yp;
            ans.num=extraction(y,x).num;
        }
        return ans;
    }
}
long_number extraction(long_number x,long_number y)
{
    long_number ans;
    if(comp(x,y)==0)
    {
        ans.num="0";
        ans.positive=1;
        return ans;
    }
    if(x.positive==y.positive && x.positive==1)
    {
        if(comp(x,y)==1)ans.positive=1;
        else
        {
            ans.positive=0;
            swap(x.num,y.num);
        }
        if(x.num.size()<y.num.size())while(x.num.size()<y.num.size())x.num="0"+x.num;
        if(y.num.size()<x.num.size())while(y.num.size()<x.num.size())y.num="0"+y.num;
        cout<<x.num<<" "<<y.num<<endl;
        int pren=0;
        ans.num="";
        for(int i=x.num.size()-1;i>=0;i--)
        {
            char c=x.num-y.num+pren;
            if(c<0)
                {
                    pren=-1;
                    c+=10;
                }
            else
            pren=0;
            //cout<<(int)c<<" "<<pren<<endl;
            c+='0';
            string t="";
            t+=c;
            ans.num=t+ans.num;
        }
        //if(pren==1)ans.num="1"+ans.num;
        while(ans.num[0]=='0')
        {
            ans.num.erase(ans.num.begin()+0);
            if(ans.num.size()==0){ans.num="0";break;}
        }
        return ans;
    }
    if(x.positive==0 && y.positive==0)
    {
        y.positive=1;
        ans=addition(x,y);
        return ans;
    }
    if(x.positive==1 && y.positive==0)
    {
        y.positive=1;
        ans=addition(x,y);
        return ans;
    }
    if(x.positive==0 && y.positive==1)
    {
        y.positive=0;
        ans=addition(x,y);
        return ans;
    }
}
long_number mult(long_number x,long_number y)
{
    long_number ans;
    ans.positive=1;
    ans.num="0";
    for(int i=x.num.size()-1;i>=0;i--)
    {
        long_number work;
        work.positive=1;
        int pren=0;
        work.num="";
        for(int j=0;j<x.num.size()-1-i;j++)
            work.num+="0";
        for(int j=y.num.size()-1;j>=0;j--)
        {
            char c;
            c=(x.num-'0')*(y.num[j]-'0')+pren;
            pren=c/10;
            c%=10;
            string t="";
            t+=c+'0';
            work.num=t+work.num;
        }
        if(pren!=0)
            {
                string t="";
                t+=pren+'0';
                work.num=t+work.num;
            }
        ans=addition(ans,work);
    }
    if(x.positive==y.positive)ans.positive=1;
    else
    ans.positive=0;
    return ans;
}
int main()
{
    long_number a,b,c,d;
    a.num = "1";
    b.num = "71";
    c.num="252";
    d.num="1";
    for(;comp(b,c)==2;b=addition(b,d))
    {
        a=mult(a,b);
    }
    cout<<a.num<<endl;
    string a1;
    for(long long i=a.num.size()-1;a.num == '0' and i>=0;i--)
    {
        a1+= "0";
    }
    cout<<a1.size()<<endl;
}

#include<iostream>
#include<string>
#include<vector>
#include<cstring>
#include<climits>
using namespace std;
typedef unsigned int uint;
struct HugeInt
{
   HugeInt(uint n=0);
   HugeInt(int n);
   HugeInt(const HugeInt& h);
   HugeInt(const char* str);
   ~HugeInt();
   friend HugeInt operator+(HugeInt lhs, const HugeInt& rhs);
   friend HugeInt operator-(HugeInt lhs, const HugeInt& rhs);
   friend HugeInt operator*(HugeInt lhs, const HugeInt& rhs);
   friend HugeInt operator/(HugeInt lhs, const HugeInt& rhs);
   friend HugeInt operator%(HugeInt lhs, const HugeInt& rhs);
   HugeInt operator-() const;
   HugeInt& operator=(const HugeInt& rhs);
   HugeInt& operator+=(const HugeInt& rhs);
   HugeInt& operator-=(const HugeInt& rhs);
   HugeInt& operator*=(const HugeInt& rhs);
   HugeInt& operator*=(int rhs);
   HugeInt& operator*=(uint rhs);
   HugeInt& operator/=(const HugeInt& rhs);
   HugeInt& operator%=(const HugeInt& rhs);
   HugeInt& operator<<=(uint rhs);
   HugeInt& operator>>=(uint rhs);
   HugeInt& operator++();
   HugeInt operator++(int);
   HugeInt& operator--();
   HugeInt operator--(int);
   friend bool operator==(const HugeInt& lhs, const HugeInt& rhs);
   friend bool operator!=(const HugeInt& lhs, const HugeInt& rhs);
   friend bool operator<(const HugeInt& lhs, const HugeInt& rhs);
   friend bool operator>(const HugeInt& lhs, const HugeInt& rhs);
   friend bool operator<=(const HugeInt& lhs, const HugeInt& rhs);
   friend bool operator>=(const HugeInt& lhs, const HugeInt& rhs);
   friend std::ostream& operator<<(std::ostream& ostr, const HugeInt& rhs);
   uint* m_pDig;
   int m_llen;
   int m_flen;
   bool m_neg;

   void incr_len(int newlen);
   int round_up(int n) const; //finds a suitable new block size
   void set_len(uint n);
   void reduce();
   void make_huge(uint n);
   int compare(const HugeInt& h) const;

   // Multiplying two digits: (Hi, Lo) = A * B
   void dd_product(uint a, uint b, uint& hi, uint& lo) const;

   // Divide double word (A, B) by d. Quotient = (qHi, qLo)
   uint dd_quotient(uint a, uint b, uint d) const;

   void substract_mul(uint* pa, uint* pb, int n, uint &q) const;
   bool normalize(HugeInt& denom, HugeInt& num, int& x) const;
   void unnormalize(HugeInt& rem, int x, bool second_done) const;
   void divide(HugeInt denom, HugeInt& quot, HugeInt& rem, bool want_rem) const;

   friend class numstring;

};

inline bool operator==(const HugeInt& lhs, const HugeInt& rhs) {
   return lhs.compare(rhs)==0;
}

inline bool operator!=(const HugeInt& lhs, const HugeInt& rhs) {
   return lhs.compare(rhs)!=0;
}

inline bool operator<(const HugeInt& lhs, const HugeInt& rhs) {
   return lhs.compare(rhs)<0;
}

inline bool operator>(const HugeInt& lhs, const HugeInt& rhs) {
   return lhs.compare(rhs)>0;
}

inline bool operator<=(const HugeInt& lhs, const HugeInt& rhs) {
   return lhs.compare(rhs)<=0;
}

inline bool operator>=(const HugeInt& lhs, const HugeInt& rhs) {
   return lhs.compare(rhs)>=0;
}

inline HugeInt operator+(HugeInt lhs, const HugeInt& rhs) {
   return lhs+=rhs;
}

inline HugeInt operator-(HugeInt lhs, const HugeInt& rhs) {
   return lhs-=rhs;
}

inline HugeInt operator*(HugeInt lhs, const HugeInt& rhs) {
   return lhs*=rhs;
}

inline HugeInt operator/(HugeInt lhs, const HugeInt& rhs) {
   return lhs/=rhs;
}

inline HugeInt operator%(HugeInt lhs, const HugeInt& rhs) {
   return lhs%=rhs;
}

inline HugeInt operator<<(HugeInt lhs, uint rhs) {
   return lhs<<=rhs;
}

inline HugeInt operator>>(HugeInt lhs, uint rhs) {
   return lhs>>=rhs;
}

const int MEM_UNIT = 64; //use words only mutiple to MEM_UNIT
const int WORD_BITS = sizeof(int) * 8;
const int HLEN = WORD_BITS/2;
const uint RMASK = (1<<HLEN) -1;
const uint LMASK = UINT_MAX - RMASK;
const uint LBIT = UINT_MAX - (UINT_MAX>>1);

HugeInt::HugeInt(uint n) : m_neg(false)
{
    make_huge(n);
}

HugeInt::HugeInt(int n)
{
   m_neg = n<0;
   if(m_neg) n=-n;
    make_huge(uint(n));
}

HugeInt::HugeInt(const HugeInt& h) : m_llen(h.m_llen), m_flen(h.m_flen), m_neg(h.m_neg)
{
   m_pDig = new uint[m_flen];

   for(int i=0; i<m_llen; ++i)
      m_pDig = h.m_pDig;
}

HugeInt::HugeInt(const char* str)
{
   //check negative
   if(*str == '-') {
      m_neg = true;
      str++;
   }
   else
      m_neg = false;

    int i, nLen = (int)strlen(str);
   HugeInt h;
   for(i=0; i<nLen; ++i) {
      h*= 10;
      h+= str-'0';
   }

   m_llen = h.m_llen;
   m_flen = round_up(m_llen);
   m_pDig = new uint[m_flen];

   for(i=0; i<m_llen; ++i)
      m_pDig = h.m_pDig;

   reduce();
}

HugeInt::~HugeInt()
{
   delete[] m_pDig;
   m_pDig = NULL;
}

//==========================================

void HugeInt::incr_len(int nNewLen)
{
    int nOldLen = m_llen;
   m_llen = nNewLen; //m_llen must be bigger than nOldLen

   if(m_llen > m_flen) {
      m_flen = round_up(m_llen);
      uint* pOldDig = m_pDig;
      m_pDig = new uint[m_flen];
      for(int i=0; i<nOldLen; ++i)
         m_pDig = pOldDig;
      delete[] pOldDig;
   }

    for(int i=nOldLen; i<m_llen; ++i)
      m_pDig = 0;
}

int HugeInt::round_up(int n) const
{
   return ( (n+n/3)/MEM_UNIT + 1 ) + MEM_UNIT;
}

void HugeInt::set_len(uint n)
{
   m_llen = n;
   if(m_llen>m_flen) {
      m_flen = round_up(m_llen);
      delete[] m_pDig;
      m_pDig = new uint[m_flen];
   }
}

void HugeInt::reduce()
{
   for(int i=m_llen-1; i>=0; --i) {
      if(m_pDig == 0)   --m_llen;
      else break;
   }
    if(m_llen==0)
      m_neg = false;
}

void HugeInt::make_huge(uint n)
{
   m_flen = MEM_UNIT;
   m_pDig = new uint[m_flen];
   *m_pDig = n;
   m_llen = (n!=0)?1:0;
}

HugeInt HugeInt::operator-() const
{
   HugeInt h = *this;
   h.m_neg = !h.m_neg;
   return h;
}

HugeInt& HugeInt::operator=(const HugeInt& rhs)
{
   if(this!=&rhs) { //check forself usurp
        set_len(rhs.m_llen);
      m_neg = rhs.m_neg;
      for(int i=0; i<m_llen; ++i)
         m_pDig = rhs.m_pDig;
   }
   return *this;
}

HugeInt& HugeInt::operator+=(const HugeInt& rhs)
{
   if(m_neg != rhs.m_neg) return *this -= -rhs;


   incr_len(max(rhs.m_llen, m_llen) + 1);

   uint carry = 0;
   for(int i=0; i<m_llen; ++i) {
      if(i >= rhs.m_llen && carry == 0) break;
      uint d = m_pDig + carry;
      carry = d < carry;
      if(i < rhs.m_llen) {
         m_pDig = d + rhs.m_pDig;
         if(m_pDig < d)
            carry = 1;
      }
      else
         m_pDig = d;
   }

   reduce();

   return *this;
}


HugeInt& HugeInt::operator++()
{
   *this += HugeInt(1);
   return *this;
}

HugeInt HugeInt::operator++(int)
{
   HugeInt temp = *this;
   *this += HugeInt(1);
    return temp;
}

HugeInt& HugeInt::operator--()
{
   *this -= HugeInt(1);
   return *this;
}

HugeInt HugeInt::operator--(int)
{
   HugeInt temp = *this;
   *this -= HugeInt(1);
    return temp;
}

HugeInt& HugeInt::operator-=(const HugeInt& rhs)
{
   if(m_neg != rhs.m_neg) return *this += -rhs;

   if(!m_neg && rhs > *this || m_neg && rhs < *this)
      return *this = -(rhs - *this);

   int borrow = 0;
   for(int i=0; i<m_llen; ++i) {
      if(i >= rhs.m_llen && borrow == 0) break;
      uint d = m_pDig - borrow;
      borrow = d > m_pDig;
      if(i < rhs.m_llen) {
         m_pDig = d - rhs.m_pDig;
         if(m_pDig > d)
            borrow = 1;
      }
      else
         m_pDig = d;
   }

   reduce();
   return *this;
}

HugeInt& HugeInt::operator*=(int rhs)
{
   *this *= uint(rhs < 0 ? -rhs : rhs);

   if(rhs < 0) m_neg = !m_neg;

   return *this;
}

HugeInt& HugeInt::operator*=(uint rhs)
{
   uint hi, lo, dig = m_pDig[0], carry = 0;

   incr_len(m_llen + 1);

   int len0 = m_llen;int i;
   for(i=0; i<len0; ++i) {
      dd_product(dig, rhs, hi, lo);
      m_pDig = lo + carry;
      dig = m_pDig[i+1];
      carry = hi + (m_pDig < lo);
   }

   m_pDig = carry;

   reduce();
   return *this;
}

HugeInt& HugeInt::operator*=(const HugeInt& rhs)
{
   if(m_llen == 0 || rhs.m_llen == 0) return *this = 0;

   bool DifSigns = (m_neg != rhs.m_neg);

   if(m_llen + rhs.m_llen == 2) { // m_llen = rhs.m_llen = 1
      uint a = m_pDig[0], b = rhs.m_pDig[0];
      m_pDig[0] = a * b;
      if(m_pDig[0] / a != b) {
         m_llen = 2;
         dd_product(a, b, m_pDig[1], m_pDig[0]);
      }
      m_neg = DifSigns;
      return *this;
   }

   if(m_llen == 1) {  //  && rhs.m_llen > 1
      uint digit = m_pDig[0]; *this = rhs;
      *this *= digit;
   }
   else {
      if(rhs.m_llen == 1)
         *this *= rhs.m_pDig[0];
      else {
         int lenProd = m_llen + rhs.m_llen, i, jA, jB;
         uint sumHi = 0, sumLo, Hi, Lo,
         sumLoOld, sumHiOld, carry=0;
         HugeInt x = *this;
         set_len(lenProd); // Give *this length lenProd
         for(i=0; i<lenProd; ++i) {
            sumLo = sumHi; sumHi = carry; carry = 0;
            for(jA=0; jA<x.m_llen; ++jA) {
               jB = i - jA;
               if(jB >= 0 && jB < rhs.m_llen)   {
                  dd_product(x.m_pDig[jA], rhs.m_pDig[jB], Hi, Lo);
                  sumLoOld = sumLo;
                  sumHiOld = sumHi;
                  sumLo += Lo;
                  if(sumLo < sumLoOld)
                     ++sumHi;
                  sumHi += Hi;
                  carry += (sumHi < sumHiOld);
               } //if
            } //for
            m_pDig = sumLo;
         } //for
      } //else
   } //else

   reduce();
   m_neg = DifSigns;
   return *this;
}

HugeInt& HugeInt::operator/=(const HugeInt& divisor)
{
   HugeInt h;
   divide(divisor, *this, h, false);
   return *this;
}

HugeInt& HugeInt::operator%=(const HugeInt& divisor)
{
   HugeInt h;
   divide(divisor, h, *this, true);
   return *this;
}

HugeInt& HugeInt::operator<<=(uint k)
{
   int q = k / WORD_BITS;

   if(q) { // Increase m_llen by q:
      incr_len(m_llen + q);

      for(int i=m_llen-1; i>=0; i--)
         m_pDig = (i < q ? 0 : m_pDig[i - q]);

      k %= WORD_BITS;
   }

   if(k) { // 0 < k < wLen:
      int k1 = WORD_BITS - k;
      uint mask = (1 << k) - 1;
      incr_len(m_llen + 1);

      for(int i=m_llen-1; i>=0; i--) {
         m_pDig <<= k;

         if(i > 0)
            m_pDig |= (m_pDig[i-1] >> k1) & mask;
      }
   }

   reduce();
   return *this;
}

HugeInt& HugeInt::operator>>=(uint k)
{
   int q = k / WORD_BITS;

   if(q >= m_llen) {
      m_llen = 0;
      return *this;
   }

   if(q) {
      for(int i=q; i<m_llen; ++i)
         m_pDig[i-q] = m_pDig;

      m_llen -= q;
      k %= WORD_BITS;
      if(k == 0) {
         reduce();
         return *this;
      }

   }

   int n = m_llen - 1, k1 = WORD_BITS - k;
   uint mask = (1 << k) - 1;
   for(int i=0; i<=n; ++i) {
      m_pDig >>= k;
      if(i < n)
         m_pDig |= ((m_pDig[i+1] & mask) << k1);
   }

   reduce();
   return *this;
}

int HugeInt::compare(const HugeInt& y) const
{
   if(m_neg != y.m_neg) return int(y.m_neg) - int(m_neg);

   int code = 0;

   if(m_llen == 0 || y.m_llen == 0)
      code = m_llen - y.m_llen;
   else if(m_llen < y.m_llen)
      code = -1;
   else if(m_llen > y.m_llen)
      code = +1;
   else {
      for(int i = m_llen - 1; i >= 0; i--) {
         if(m_pDig > y.m_pDig) {
            code = 1;
            break;
         }
         else if(m_pDig < y.m_pDig) {
            code = -1;
            break;
         }
      }
   }

   return m_neg ? -code : code;
}

void HugeInt::dd_product(uint A, uint B, uint &Hi, uint &Lo) const
{
   uint hiA = A >> HLEN, loA = A & RMASK;
   uint hiB = B >> HLEN, loB = B & RMASK;

   Lo = loA * loB;
   Hi = hiA * hiB;

   uint mid1 = loA * hiB;
   uint mid2 = hiA * loB;

   uint old = Lo;

   Lo += mid1 << HLEN;
   Hi += (Lo < old) + (mid1 >> HLEN);

   old = Lo;

   Lo += mid2 << HLEN;
   Hi += (Lo < old) + (mid2 >> HLEN);
}

uint HugeInt::dd_quotient(uint A, uint B, uint d) const
{
   uint dHi = d >> HLEN, dLo = d & RMASK;

   uint qHi = A/(dHi + 1);

   // This initial guess of qHi may be too small.
   uint middle = qHi * dLo;
   uint left = qHi * dHi;
   uint x = B - (middle << HLEN);
   A -= (middle >> HLEN) + left + (x > B);
   B = x;

   uint dLo1 = dLo << HLEN;

   // Increase qHi ifnecessary:
   while (A > dHi || (A == dHi && B >= dLo1)) {
      x = B - dLo1;
      A -= dHi + (x > B);
      B = x;

      ++qHi;
   }

   uint qLo = ((A << HLEN) | (B >> HLEN))/(dHi + 1);

   // This initial guess of qLo may be too small.
   uint right = qLo * dLo;
   middle = qLo * dHi;

   x = B - right;
   A -= (x > B);
   B = x;

   x = B - (middle << HLEN);
   A -= (middle >> HLEN) + (x > B);
   B = x;

   // Increase qLo if necessary:
   while (A || B >= d) {
      x = B - d;
      A -= (x > B);
      B = x;
      ++qLo;
   }

   uint result = (qHi << HLEN) + qLo;

   return (result == 0 && qHi > 0) ? UINT_MAX : result;
}

void HugeInt::substract_mul(uint *a, uint *b, int n, uint& q) const
// a -= q * b: b in n positions; correct q ifnecessary
{
   uint Hi, Lo, d, carry = 0;
   int i;
   for(i=0; i<n; ++i) {
      dd_product(b, q, Hi, Lo);
      d = a;
      a -= Lo;
      if(a > d)
         ++carry;

      d = a[i + 1];
      a[i+1] -= Hi+carry;
      carry = a[i+1] > d;
   }

   if(carry) { // q was too HugeInt
      q--;
      carry = 0;
      for(i=0; i<n; ++i) {
         d = a + carry;
         carry = d < carry;
         a = d + b;
         if(a < d) carry = 1;
      }
      a[n] = 0;
   }
}

bool HugeInt::normalize(HugeInt &denom, HugeInt &num, int &x) const
{
   int r = denom.m_llen - 1;
   uint y = denom.m_pDig[r];

   x = 0;

   while ((y & LBIT) == 0) {
      y <<= 1;
      ++x;
   }

   denom <<= x;
   num <<= x;

   if(r > 0 && denom.m_pDig[r] < denom.m_pDig[r-1]) {
      denom *= UINT_MAX;
      num *= UINT_MAX;
      return true;
   }

   return false;
}

void HugeInt::unnormalize(HugeInt& rem, int x, bool second_done) const
{
   if(second_done)
      rem /= UINT_MAX;

   if(x > 0)
      rem >>= x;
   else
      rem.reduce();
}

void HugeInt::divide(HugeInt denom, HugeInt& quot, HugeInt& rem, bool want_rem) const
{
   if(denom.m_llen == 0) {
      cerr << "Division by zero!\n";
      terminate();
   }

   bool QuotNeg = (m_neg != denom.m_neg), RemNeg = m_neg;

   int r, n;

   uint q, d;

   HugeInt num = *this;
   num.m_neg = denom.m_neg = 0;

   if(num < denom) {
      quot = 0;
      rem = num;
      rem.m_neg = RemNeg;
      return;
   }


   if(denom.m_llen == 1 && num.m_llen == 1) {
      quot = uint(num.m_pDig[0]/denom.m_pDig[0]);
      rem = uint(num.m_pDig[0]%denom.m_pDig[0]);
      quot.m_neg = QuotNeg;
      rem.m_neg = RemNeg;
      return;
   }
   else if(denom.m_llen == 1 && (denom.m_pDig[0] & LMASK) == 0) {  // Denominator fits into a half word

      uint divisor = denom.m_pDig[0], dHi = 0, q1, r, q2, dividend;

      quot.set_len(m_llen);
      for(int i=m_llen-1; i>=0; --i) {
         dividend = (dHi << HLEN) | (m_pDig >> HLEN);
         q1 = dividend/divisor;
         r = dividend % divisor;
         dividend = (r << HLEN) | (m_pDig & RMASK);
         q2 = dividend/divisor;
         dHi = dividend % divisor;
         quot.m_pDig = (q1 << HLEN) | q2;
      }
      quot.reduce();
      rem = dHi;
      quot.m_neg = QuotNeg;
      rem.m_neg = RemNeg;
      return;
   }

   HugeInt num0 = num, denom0 = denom;
   int x=0;
   bool SecondDone = normalize(denom, num, x);
   r = denom.m_llen - 1;
   n = num.m_llen - 1;
   quot.set_len(n - r);

   for(int i=quot.m_llen-1; i>=0; i--)
      quot.m_pDig = 0;

   rem = num;
   if(rem.m_pDig[n] >= denom.m_pDig[r]) {
      rem.incr_len(rem.m_llen + 1);
      ++n;
      quot.incr_len(quot.m_llen + 1);
   }

   d = denom.m_pDig[r];
   for(int k=n; k>r; k--) {
      q = dd_quotient(rem.m_pDig[k], rem.m_pDig[k-1], d);
      substract_mul(rem.m_pDig + k - r - 1, denom.m_pDig, r + 1, q);
      quot.m_pDig[k - r - 1] = q;
   }

   quot.reduce();
   quot.m_neg = QuotNeg;

   if(want_rem) {
      unnormalize(rem, x, SecondDone);
      rem.m_neg = RemNeg;
   }
}

class numstring {
public:
   numstring(HugeInt v);
   ~numstring() { delete[]pStr; }

   char *pStr;
};

numstring::numstring(HugeInt v)
{
   int len = int(long(v.m_llen) * WORD_BITS / 3) + 2, n = len, i = 0; // 1/3 > ln(2)/ln(10)
   static uint p10 = 1, ip10 = 0;

   pStr = new char[len];
   if(v.m_llen == 0) {
      *pStr = '0';
      i = 1;
   }
   else {
      uint r;
      if(p10 == 1) {
         while(p10 <= UINT_MAX/10) {
            p10 *= 10;
            ++ip10;
         }
      } // p10 is max uint power of 10

      HugeInt R, LP10 = p10;  // LP10 = p10 = pow(10, ip10)

      if(v.m_neg) {
         *pStr = '-';
         i = 1;
      }

      do {
         v.divide(LP10, v, R, true);
         r = (R.m_llen ? R.m_pDig[0] : 0);
         for(uint j=0; j<ip10; ++j) {
            pStr[--n] = char(r % 10 + '0');
            r /= 10;
            if(r + v.m_llen == 0)
               break;
         }
      }  while(v.m_llen);

      while(n < len)
         pStr[i++] = pStr[n++];
   }

   pStr = '\0';
}

ostream& operator<<(ostream& ostr, const HugeInt& rhs)
{
   numstring numstr(rhs);
   int i=0;
   char ch;
   while((ch = numstr.pStr) != '\0') {
      ostr << ch;
      ++i;
   }

   return ostr;
}

int main()
{
    HugeInt P = HugeInt(1);
    HugeInt a = HugeInt(71);
    for(;a<=251;a++)
    {
        HugeInt b = HugeInt(71);
        /*for(;b<=a-1;b++)
        {
            std::cout<<b<<" x ";
        }
        std::cout<<b<<" = "<<P*a<<std::endl;
        */
        //std :: cout << P << " x "<< a << " = "<<P*a<<std::endl;
        //system("pause");
        //system("cls");
        P = P * a;
    }
    vector<HugeInt> digits;
    std::cout<<"Multiplication of numbers is "<<P<<std::endl;
    do
    {
        digits.push_back(P%10);
        P = P/10;
    }while(P != 0);
    int NumberOfZerosAtTheEndIs = 0;
    for(long long i=0;i<digits.size();i++)
    {
        if( digits == HugeInt(0) )
        {
            NumberOfZerosAtTheEndIs++;
        }
        else
        {
            break;
        }
    }
    std::cout<<"Number of zeros at the end is "<<NumberOfZerosAtTheEndIs<<std::endl;
}

75= 5х5х3--------------2 бр
80-------------------------1
85-------------------------1
90-------------------------1
95-------------------------1
100= 5х5х4------------ 2
105------------------------1
110------------------------1
115------------------------1
120------------------------1
125=5х5х5--------------3
130------------------------1
135------------------------1
140------------------------1
145------------------------1
150= 5х5х6-------------2
155------------------------1
160------------------------1
165------------------------1
170------------------------1
175= 5х5х7-------------2
180------------------------1
185------------------------1
190------------------------1
195------------------------1
200=5х5х8--------------2
205------------------------1
210------------------------1
215-------------------------1
220-------------------------1
225=5х5х9---------------2
230------------------------1
235------------------------1
240------------------------1
245------------------------1
250=5х5х5х2------------3
--------------------------------------
    сума                           46