大整数类

char str[1005];
struct BigInt{
    static const int M=1005,P=10000;
    #define clear(x,val) memset(x,val,sizeof(x))
    int num[M],len;
    BigInt(){clear(num,0),len=1;}

    void read(){
        scanf("%s",str);
        len=0;
        int sz=strlen(str);
        for(int i=sz-1;i>=0;i-=4){
            num[len]=0;
            for(int j=max(0,i-3);j<=i;j++)
                num[len]=(num[len]<<3)+(num[len]<<1)+(str[j]^48);
            ++len;
        }
        while(len>1&&!num[len-1])--len;
    }
    void print(){
        printf("%d",num[len-1]);
        for(int i=len-2;i>=0;i--)printf("%04d",num[i]);
        putchar('\n');
    }

    bool operator < (const BigInt &cmp)const{
        if(len!=cmp.len)return len<cmp.len;
        for(int i=len-1;i>=0;i--)
            if(num[i]!=cmp.num[i])return num[i]<cmp.num[i];
        return false;
    }
    bool operator > (const BigInt &cmp)const{return cmp<*this;}
    bool operator <= (const BigInt &cmp)const{return !(cmp<*this);}
    bool operator != (const BigInt &cmp)const{return cmp<*this||*this<cmp;}
    bool operator == (const BigInt &cmp)const{return !(cmp<*this||*this<cmp);}

    BigInt operator + (const int &p){
        BigInt B;B=*this;
        B.num[0]+=p;
        int step=0;
        while(B.num[step]>=P){
            B.num[step+1]++;
            B.num[step]-=P;
            ++step;
        }
        while(B.num[B.len])++B.len;
        return B;
    }
    BigInt operator + (const BigInt &A)const{
        BigInt B;
        B.len=max(A.len,len);
        for(int i=0;i<B.len;i++){
            B.num[i]+=num[i]+A.num[i];
            if(B.num[i]>=P){
                B.num[i]-=P;
                B.num[i+1]++;
            }
        }
        while(B.num[B.len])++B.len;
        return B;
    }

    BigInt operator - (const int &p){//保证非负 
        BigInt B;B=*this;
        B.num[0]-=p;
        int step=0;
        while(B.num[step]<0){
            B.num[step]+=P;
            B.num[step+1]--;
            ++step;
        }
        while(B.len>1&&!B.num[B.len-1])--B.len;
        return B;
    }
    BigInt operator - (const BigInt &A)const{
        BigInt B;
        B.len=max(A.len,len);
        for(int i=0;i<B.len;i++){
            B.num[i]+=num[i]-A.num[i];
            if(B.num[i]<0){
                B.num[i]+=P;
                B.num[i+1]--;
            }
        }
        while(B.len>1&&!B.num[B.len-1])--B.len;
        return B;
    }

    BigInt operator * (const int &p){
        BigInt B;
        B.len=len;
        for(int i=0;i<len;i++){
            B.num[i]+=num[i]*p;
            if(B.num[i]>=P){
                B.num[i+1]+=B.num[i]/P;
                B.num[i]%=P;
            }
        }
        while(B.num[B.len])++B.len;
        return B;
    }
    BigInt operator * (const BigInt &A)const{
        BigInt B;
        B.len=A.len+len-1;
        for(int i=0;i<len;i++)
            for(int j=0;j<A.len;j++){
                B.num[i+j]+=num[i]*A.num[j];
                if(B.num[i+j]>=P){
                    B.num[i+j+1]+=B.num[i+j]/P;
                    B.num[i+j]%=P;
                }
            }
        while(B.num[B.len])++B.len;
        return B;
    }

    BigInt operator / (const int &p){
        BigInt B=*this;
        for(int i=B.len-1;i>=0;i--){
            if(i)B.num[i-1]+=B.num[i]%p*P;
            B.num[i]/=p;
        }
        while(B.len>1&&!B.num[B.len-1])--B.len;
        return B;
    }
    BigInt operator / (const BigInt &A)const{
        BigInt L,R,res;
        if(*this<A)return res;
        R=*this;
        while(L<=R){
            BigInt mid=(L+R)/2;
            if((mid*A)<=*this){
                res=mid;
                L=mid+1;
            }else R=mid-1;
        }
        return res;
    }
};