【模板】高精度

namespace BigNumber{
    const int L=5010,Base=10000,Bit=4;
    const LL MaxInt=2147483647;
    const int Pw10[15]={1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};
    const int Pw2[20]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536};
         
    LL DOF[L];
         
    struct BigNum{
        int v[L],le,flag;
        BigNum(){
            memset(v,0,sizeof v); le=flag=1;
        }
        BigNum(int x){
            flag=1; le=1; memset(v,0,sizeof v);
            if (x<0) flag=-1,x=-x;
            v[1]=x;
            while (v[le]>=Base) v[le+1]+=v[le]/Base,v[le]%=Base,++le;
        }
        BigNum(LL x){
            flag=1; le=1; memset(v,0,sizeof v);
            if (x<0) flag=-1,x=-x;
            v[1]=x%Base; v[2]=x/Base%Base;
            v[3]=x/Base/Base%Base; v[4]=x/Base/Base/Base;
            le=4;
            while (v[le]>=Base) v[le+1]+=v[le]/Base,v[le]%=Base,++le;
            while (v[le]==0 && le>1) --le;
        }
        BigNum(int len,int fir){
            memset(v,0,sizeof v);
            le=len; v[le]=fir; flag=1;
        }
        BigNum(const BigNum &a,int x){
            memset(v,0,sizeof v);
            le=a.le+x; flag=a.flag;
            for (int i=1;i<=a.le;++i) v[i+x]=a.v[i];
        }
        int IntoInt(){
            if (le>3) cerr <<"Error: cannot change so big into int!"<<endl;
            LL d=0;
            for (int i=le;i>=1;--i) d=d*Base+v[i];
            if (flag==-1) d=-d;
            if (d>MaxInt || -d<MaxInt+1) cerr <<"Error: cannot change so big into int!"<<endl;
            return d;
        }
             
        void Clear(){
            memset(v,0,sizeof v); le=flag=1;
        }
        void Tidy() {
            if (le == 1 && !v[le]) flag = 1;
            return;
        }
        void operator =(int a){
            *this = BigNum(a);
        }
        void operator =(LL a){
            *this = BigNum(a);
        }
             
             
        //Compare -->
        bool operator ==(const BigNum &a)const{
            if (le!=a.le || flag!=a.flag) return 0;
            for (int i=1;i<=le;++i) if (v[i]!=a.v[i]) return 0;
            return 1;
        }
        bool operator <(const BigNum &a)const{
            if (flag < a.flag) return 1;
            if (flag > a.flag) return 0;
            if (le < a.le) return flag == 1 ? 1 : 0;
            if (le > a.le) return flag == 1 ? 0 : 1;
            for (int i=le;i>=1;--i){
                if (v[i]<a.v[i]) return flag==1? 1:0;
                if (v[i]>a.v[i]) return flag==1? 0:1;
            }return 0;
        }
        bool operator >(const BigNum &a)const{
            if (flag < a.flag) return 0;
            if (flag > a.flag) return 1;
            if (le < a.le) return flag == 1 ? 0 : 1;
            if (le > a.le) return flag == 1 ? 1 : 0;
            for (int i=le;i>=1;--i){
                if (v[i]<a.v[i]) return flag==1? 0:1;
                if (v[i]>a.v[i]) return flag==1? 1:0;
            }return 0;
        }
        bool operator ==(const int &x)const{
            return *this == BigNum(x);
        }
             
             
        //Add and Sub -->
        void operator +=(const BigNum &x){
            BigNum a=*this; BigNum b=x; memset(v,0,sizeof v);
            flag=1;
            if (a.flag==-1 && b.flag==-1){
                flag=-1; a.flag=1; b.flag=1;
            }
            if (a < b) swap(a,b);
            if (b.flag==-1){
                b.flag=1;
                if (a < b) swap(a,b),flag=-1;
                b.flag=-1;
            }
            if (b.flag==1){
                le=a.le;
                for (int i=1;i<=le;++i) v[i]=a.v[i]+b.v[i];
                for (int i=1;i<=le;++i) v[i+1]+=v[i]/Base,v[i]%=Base;
                while (v[le+1]>0) ++le;
            }else{
                le=a.le;
                for (int i=1;i<=le;++i) v[i]=a.v[i]-b.v[i];
                for (int i=1;i<=le;++i) if (v[i]<0) --v[i+1],v[i]+=Base;
                while (v[le]==0 && le>1) --le;
            }
        }
        void operator +=(int x){
            *this += BigNum(x);
        }
        void operator -=(const BigNum &x){
            BigNum a=x; a.flag=-a.flag;
            *this += a;
        }
        void operator -=(int x){
            *this -= BigNum(x);
        }
             
             
        BigNum &operator ++(){
            return *this += 1, *this;
        }
        BigNum &operator --(){
            return *this -= 1, *this;
        }
        BigNum operator ++(int){
            BigNum c(*this);
            ++ *this; return c;
        }
        BigNum operator --(int){
            BigNum c(*this);
            -- *this; return c;
        }
             
             
        //Mul -->
        void operator *=(const BigNum &x){
            BigNum a=x;
            if (flag==a.flag) flag=1;else flag=-1;
            a.flag=1;
                 
            memset(DOF,0,sizeof DOF);
            for (int i=1;i<=le;++i)
                for (int j=1;j<=a.le;++j)
                    DOF[i+j-1]+=v[i]*a.v[j];
            le+=a.le+9;
            for (int i=1; i<=le; ++i) v[i]=0;
            for (int i=1;i<=le;++i) DOF[i+1]+=DOF[i]/Base,DOF[i]%=Base;
            while (DOF[le]==0 && le>1) --le;
            for (int i=1;i<=le;++i) v[i]=DOF[i];
        }
        void operator *=(const int &x){
            *this *= BigNum(x);
        }
        void operator *=(const LL &x){
            *this *= BigNum(x);
        }
             
             
        //Div -->
        void operator /=(int x){
            if (x==0){
                cerr <<"Error: div 0!"; return;
            }
            BigNum a; a=x;
            if (flag==a.flag) flag=1;else flag=-1;
            a.flag=1;
            if (x < 0) x = -x;
             
            memset(DOF,0,sizeof DOF);
            LL rest=0;
            for (int i=le;i>=1;--i){
                rest=rest*Base+v[i];
                DOF[i]=rest/x; rest%=x;
                v[i]=0;
            }
            for (int i=le;i>=1;--i) v[i]=DOF[i];
            while (v[le]==0 && le>1) --le;
        }
        void operator /=(const BigNum &x){
            if (x==0){
                cerr <<"Error: div 0!"; return;
            }
            BigNum a=*this,b=x,c,d;
            if (a.flag==b.flag) flag=1;else flag=-1;
            a.flag = b.flag = 1;
            for (int i=le;i>0;--i) v[i]=0;
            le=a.le-b.le+1;
             
            for (int i=le;i>=1;--i){
                c=BigNum(b,i-1);
                for (int j=log2(Base);j>=0;--j){
                    d=c; d*=Pw2[j];
                    if (!(a < d)) v[i]+=Pw2[j],a-=d;
                }
            }
            for (int i=1;i<=le;++i) v[i+1]+=v[i]/Base,v[i]%=Base;
            while (v[le+1]>0) ++le;
            while (v[le]==0 && le>1) --le;
        }
             
             
        //Mod -->
        void operator %=(int p){
            if (p==0){
                cerr <<"Error: mod 0!"; return;
            }
            LL d=0; if (p < 0) p=-p;
            for (int i=le;i>=1;--i) d=(d*Base+v[i])%p,v[i]=0;
            le=1; v[1]=d;
            while (v[le]>=Base) v[le+1]+=v[le]/Base,v[le]%=Base,++le;
        }
             
        void operator %=(const BigNum &x){
            if (x==0){
                cerr <<"Error: mod 0!"; return;
            }
            BigNum a=*this,b=x,c,d;
            for (int i=le;i>0;--i) v[i]=0;
            le=a.le-b.le+1;
                 
            for (int i=le;i>=1;--i){
                c=BigNum(b,i-1);
                for (int j=log2(Base);j>=0;--j){
                    d=c; d*=Pw2[j];
                    if (!(a < d)) a-=d;
                }
            }
            *this = a;
        }
             
             
        //Power -->
        BigNum pow(int b){
            BigNum a,c; a=*this; c=1;
            for (;b;b>>=1,a*=a) if (b&1) c*=a;
            return c;
        }
        BigNum pow(int x,int b){
            BigNum c,a; c=1; a=x;
            for (;b;b>>=1,a*=a) if (b&1) c*=a;
            return c;
        }
        int pow2(int a,int b){
            int c=1;
            for (;b;b>>=1,a*=a) if (b&1) c*=a;
            return c;
        }
             
             
        //Shr and Shl -->
        void operator <<=(int x){
            if (x<=30) *this *= pow2(2,x);
                else *this *= pow(2,x);
        }
        void operator >>=(int x){
            if (x<=30) *this /= pow2(2,x);
                else *this /= pow(2,x);
        }
 
         
        void rev() {
            if (le > 1 || v[le]) flag = -flag;
            return;
        }
         
    };
         
         
    //Compare -->
    bool operator ==(const int &a,const BigNum &b){
        return b == a;
    }
    bool operator !=(const BigNum &a,const BigNum &b){
        return !(a == b);
    }
    bool operator !=(const BigNum &a,const int &b){
        return !(a == b);
    }
    bool operator !=(const int &a,const BigNum &b){
        return !(b == a);
    }
         
         
    bool operator <(const BigNum &a,const int &b){
        return a < BigNum(b);
    }
    bool operator <(const int &a,const BigNum &b){
        return BigNum(a) < b;
    }
    bool operator >(const BigNum &a,const int &b){
        return a > BigNum(b);
    }
    bool operator >(const int &a,const BigNum &b){
        return BigNum(a) > b;
    }
    bool operator <=(const BigNum &a,const BigNum &b){
        if (a > b) return 0; return 1;
    }
    bool operator >=(const BigNum &a,const BigNum &b){
        if (a < b) return 0; return 1;
    }
    bool operator <=(const BigNum &a,const int &b){
        if (a > b) return 0; return 1;
    }
    bool operator <=(const int &a,const BigNum &b){
        if (a > b) return 0; return 1;
    }
    bool operator >=(const BigNum &a,const int &b){
        if (a < b) return 0; return 1;
    }
    bool operator >=(const int &a,const BigNum &b){
        if (a < b) return 0; return 1;
    }
         
         
    int max(const int &a,const int &b){
        if (a < b) return b; return a;
    }
    int min(const int &a,const int &b){
        if (a < b) return a; return b;
    }
    BigNum max(const BigNum &a,const BigNum &b){
        if (a < b) return b; return a;
    }
    BigNum min(const BigNum &a,const BigNum &b){
        if (a < b) return a; return b;
    }
         
         
    //Add -->
    BigNum operator +(const BigNum &a,const BigNum &b){
        BigNum c=a; c+=b; return c;
    }
    BigNum operator +(const BigNum &a,const int &b){
        BigNum c=a; c+=b; return c;
    }
    BigNum operator +(const int &a,const BigNum &b){
        BigNum c=b; c+=a; return c;
    }
         
         
    //Sub -->
    BigNum operator -(const BigNum &a,const BigNum &b){
        BigNum c=a; c-=b; return c;
    }
    BigNum operator -(const BigNum &a,const int &b){
        BigNum c=a; c-=b; return c;
    }
    BigNum operator -(const int &a,const BigNum &b){
        BigNum c=b; c-=a; return c;
    }
         
         
    //Mul -->
    BigNum operator *(const BigNum &a,const BigNum &b){
        BigNum c=a; c*=b; return c;
    }
    BigNum operator *(const BigNum &a,const int &b){
        BigNum c=a; c*=b; return c;
    }
    BigNum operator *(const int &a,const BigNum &b){
        BigNum c=b; c*=a; return c;
    }
         
         
    //Div -->
    BigNum operator /(const BigNum &a,const int &b){
        BigNum c=a; c/=b; return c;
    }
    BigNum operator /(const int &a,const BigNum &b){
        BigNum c=b; c/=a; return c;
    }
    BigNum operator /(const BigNum &a,const BigNum &b){
        BigNum c=a; c/=b; return c;
    }
         
         
    //Mod -->
    BigNum operator %(const BigNum &a,const int &b){
        BigNum c=a; c%=b; return c;
    }
    BigNum operator %(const int &a,const BigNum &b){
        BigNum c=b; c%=a; return c;
    }
    BigNum operator %(const BigNum &a,const BigNum &b){
        BigNum c=a; c%=b; return c;
    }
         
    //Shr and Shl -->
    BigNum operator <<(const BigNum &a,const int b){
        BigNum c=a; c<<=b; return c;
    }
    BigNum operator <<(const BigNum &a,BigNum &b){
        return a << b.IntoInt();
    }
    BigNum operator >>(const BigNum &a,const int &b){
        BigNum c=a; c>>=b; return c;
    }
    BigNum operator >>(const BigNum &a,BigNum &b){
        return a >> b.IntoInt();
    }
 
         
    //Abs -->
    BigNum abs(const BigNum &x){
        BigNum c=x; c.flag=1; return c;
    }
         
         
    //Odd -->
    int odd(const BigNum &x){
        if (x.v[1] & 1) return 1; return 0;
    }
         
         
    //Gcd -->
    BigNum gcd(const BigNum &x,const BigNum &y){
        if (x.le == 1 && !x.v[1]) return y;
        if (y.le == 1 && !y.v[1]) return x;
        BigNum a=x,b=y,c=BigNum(1);
        while (a!=b){
            if (a < b) swap(a,b);
            if (odd(a) && odd(b)) a-=b; else
            if (odd(a)) b/=2; else
            if (odd(b)) a/=2; else
                a/=2,b/=2,c*=2;
        }return a*c;
    }
         
         
    //Sqrt -->
    BigNum sqrt(const BigNum &x){
        if (x<0){
            cerr <<"Error: sqrt nagetive!";
            return 0;
        }
        BigNum l,r,m,A;
        l=BigNum(x.le/2,1); r=BigNum(x.le/2+2,1);
        while (l<=r){
            m=(l+r)>>1;
            if (m*m<=x) A=m,l=m+1; else r=m-1;
        }return A;
    }
    BigNum sqrt(const BigNum &a,int b){
        BigNum x=a;
        if (x<0 && b%2==0){
            cerr <<"Error: sqrt nagetive!";
            return 0;
        }
        BigNum l,r,m,A;
        int frog=x.flag; x.flag=1;
        l=0; r=1;
        while (r.pow(b)<x) l=r,r*=2;
        while (l<=r){
            m=(l+r)>>1;
            if (m.pow(b)<=x) A=m,l=m+1; else r=m-1;
        }
        if (frog==-1) A.flag=-1;
        return A;
    }
         
         
    //Read and Print -->
    string yz; char cyz;
    void Read(BigNum &a){
        a.Clear();
        while (cin.peek()==' ') getchar();
        if (cin.peek()=='-'){
            a.flag=-1; cin >>cyz;
        }
        cin >>yz;
        int len=yz.length();
        a.le=len/Bit;
        for (int i=1;i<=a.le;++i){
            int l=len-Bit*i,r=l+Bit-1;
            for (int j=l;j<=r;++j) a.v[i]=a.v[i]*10+yz[j]-'0';
        }
        if(len%Bit!=0){
            int r=len-Bit*a.le-1;
            ++a.le;
            for (int j=0;j<=r;++j) a.v[a.le]=a.v[a.le]*10+yz[j]-'0';
        }
    }
         
    void PrintWith(int x,int k){
        for (int i=k-1;i>=0;--i) if (Pw10[i]>x) putchar('0');
            else putchar(x/Pw10[i]+'0'),x%=Pw10[i];
    }
    void Print(const BigNum &a){
        if (a.flag==-1 && (a.le > 1 || a.v[a.le])) putchar('-');
        printf("%d",a.v[a.le]);
        for (int i=a.le-1;i>=1;--i) PrintWith(a.v[i],Bit);
    }
    void Println(const BigNum &a){
        Print(a); puts("");
    }
};
 
using namespace BigNumber;