（维修）高精模板

2018-6-2

特殊版（vector动态数组存）

#pragma GCC optimize("Ofast")
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
#define pb push_back
typedef long long LL;
typedef int B_INT;
#define p_c "%04d"
#define i_c "%d"
#define b_c "10000"
//const char p_c[]="%08lld";
//const char i_c[]="%lld";
//const char b_c[]="100000000";
const B_INT p=4;//压p位,int压4位加乘法可能导致溢出,longlong压8位乘法会炸而且慢
const B_INT base=10000;//压p位，最大数为10^p-1
const int maxl=31000;//如果有乘法，则大于最大读入位数/p*2
//fft乘容易掉精度，不能压太多位
//const B_INT l2b=14;//=向上取整(log2(base))
const B_INT l2b=13;//=向下取整(log2(base))
const int fftlen=33000;//32768>31000且为2的幂
struct Bigint
{
#define TRY(a,x) {if((a).size()<(x)+1){    B_INT k=0;while((1<<(k+1))<=((x)+1))++k;a.resize(1<<(k+1));}}
/*
基本类型（char,int,float,double等）的静态成员可以在类里面声明并初始化，
非基本类（char[],string ,自定义等）必须在类里面声明，类外初始化。
*/
    vector<B_INT> a;
    Bigint(){a.pb(0);}//a[0]->len,a[i]->从后往前数第i个p位;0的长度为0
    Bigint(const char *str){*this=str;}
    Bigint(const Bigint& b){a=b.a;}
    Bigint(int x){*this=x;}

    Bigint& operator=(const Bigint& b){a=b.a;return *this;}
    Bigint& operator=(int x)
    {
        a.clear();a.pb(0);
        while(x){++a[0];a.pb(x%base);x/=base;}
        return *this;
    }
    Bigint& operator=(const char *str)
    {
        a.clear();a.pb(0);
        B_INT k=0,p=1;const char *str1=(str+strlen(str)-1);
        while(str1>=str)
        {
            k=k+p*(*str1-48);
            if(p==base){++a[0];a.pb(k%base);k/=base;p=1;}
            --str1;p*=10;
        }
        ++a[0];a.pb(k);
        while(a[0]&&a[a[0]]==0)    --a[0];
        //vector<B_INT> t=a;swap(t,a);
        return *this;
    }

    friend Bigint operator+(const Bigint&,const Bigint&);
    friend Bigint& operator+=(Bigint&,const Bigint&);
    friend Bigint operator+(const Bigint&,int x);
    friend Bigint& operator+=(Bigint&,int x);

    friend Bigint operator-(const Bigint&,const Bigint&);
    friend Bigint& operator-=(Bigint&,const Bigint&);

    friend Bigint operator*(const Bigint&,const Bigint&);
    friend Bigint& operator*=(Bigint&,const Bigint&);
    friend Bigint operator*(const Bigint&,int x);
    friend Bigint& operator*=(Bigint& a,int x);

    friend Bigint operator/(const Bigint&,const Bigint&);
    friend Bigint& operator/=(Bigint&,const Bigint&);
    friend Bigint operator/(const Bigint& a,int x);
    friend Bigint& operator/=(Bigint &,int);

    friend Bigint operator%(const Bigint&,const Bigint&);

    friend bool operator<(const Bigint& a,const Bigint& b);
    friend bool operator<=(const Bigint& a,const Bigint& b);
    friend bool operator>(const Bigint& a,const Bigint& b);
    friend bool operator>=(const Bigint& a,const Bigint& b);
    friend bool operator==(const Bigint& a,const Bigint& b);
    friend bool operator!=(const Bigint& a,const Bigint& b);

    void print() const
    {
        printf(i_c,a[a[0]]);
        for(B_INT i=a[0]-1;i>0;i--)
            printf(p_c,a[i]);
    }
    void println() const    {print();puts("");}
    void println(const char* x) const   {print();puts(x);}
    bool odd() const    {return a[0]?(a[1]&1):0;}
};
LL buf[maxl<<1];
const double Pi=acos(-1.0);
struct cpl
{
    double x,y;
    cpl(double xx=0,double yy=0):x(xx),y(yy){}
};
cpl operator+(const cpl& a,const cpl& b){return cpl(a.x+b.x,a.y+b.y);}
cpl operator-(const cpl& a,const cpl& b){return cpl(a.x-b.x,a.y-b.y);}
cpl operator*(const cpl& a,const cpl& b){return cpl(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}
int rev[fftlen];cpl t1[fftlen],t2[fftlen];
void dft(cpl *a,int len,int idx)//将a做dft，结果放入a,dft->idx=1,idft->idx=-1
{
    cpl wn,wnk,t1,t2;int i,j,k;
    for(i=0;i<len;i++)    if(i<rev[i])    swap(a[i],a[rev[i]]);
    //例如将23的二进制(10111)翻转(共5位),先得到01011(后四位)的翻转(11010)，然后右移一位后在前面补上一个1(因为23&1为1)
    for(i=1;i<len;i<<=1)
    {
        wn=cpl(cos(Pi/i),idx*sin(Pi/i));
        for(j=0;j<len;j+=(i<<1))//每一次合并[j,j+i),[j+i,j+2i)
        {
            wnk=cpl(1,0);
            for(k=j;k<j+i;k++)
            {
                t1=a[k];t2=wnk*a[k+i];
                a[k]=t1+t2;a[k+i]=t1-t2;
                wnk=wnk*wn;
            }
        }
    }
    if(idx==-1)
        for(i=0;i<len;i++)
            a[i].x/=len,a[i].y/=len;
}
const Bigint zero=0,one=1;
//const Bigint bas=base;
//const Bigint pw2[]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576};
const B_INT pw22[]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576};
bool operator<(const Bigint& a,const Bigint& b)
{
    if(a.a[0]!=b.a[0])
        return a.a[0]<b.a[0];
    for(B_INT i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]<b.a[i];
    return 0;//相等
}
/*
非静态成员函数后面加const（加到非成员函数或静态成员后面会产生编译错误），
表示成员函数隐含传入的this指针为 const指针，
决定了在该成员函数中，
任意修改它所在的类的成员的操作都是不允许的
（因为隐含了对this指针的const引用）；
唯一的例外是对于 mutable修饰的成员。
加了const的成员函数可以被非const对象和const对象调用，
但不加const的成员函数只能被非const对象调用。
下方b是const,const函数不能修改其数据成员
*/
bool operator>(const Bigint& a,const Bigint& b)
{
    return b<a;
    /*
    if(a.a[0]!=b.a[0])
        return a.a[0]>b.a[0];
    for(int i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]>b.a[i];
    return false;//相等
    */
}
bool operator<=(const Bigint& a,const Bigint& b)
{
    return !(b<a);
    /*
    if(a.a[0]!=b.a[0])
        return a.a[0]>b.a[0];
    for(int i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]>b.a[i];
    return true;//相等
    */
}
bool operator>=(const Bigint& a,const Bigint& b)
{
    return !(a<b);
    /*
    if(a.a[0]!=b.a[0])
        return a.a[0]>b.a[0];
    for(int i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]>b.a[i];
    return true;//相等
    */
}
bool operator==(const Bigint& a,const Bigint& b)
{
    if(a.a[0]!=b.a[0])
        return 0;
    for(B_INT i=a.a[0];i>0;--i)
        if(a.a[i]!=b.a[i])
            return 0;
    return 1;
}
bool operator!=(const Bigint& a,const Bigint& b)
{
    return !(a==b);
}
Bigint operator+(const Bigint& a,const Bigint& b){Bigint c=a;c+=b;return c;}
Bigint& operator+=(Bigint& a,const Bigint& b)
{
    B_INT i;
    a.a[0]=max(a.a[0],b.a[0]);
    TRY(a.a,a.a[0]+1);
    for(i=1;i<=a.a[0];++i)
    {
        if(i<=b.a[0])    a.a[i]+=b.a[i];
        a.a[i+1]+=a.a[i]/base;
        a.a[i]%=base;
    }
    if(a.a[a.a[0]+1]>0) ++a.a[0];
    return a;
}
Bigint operator+(const Bigint& a,int x){Bigint c=a;c+=x;return c;}
Bigint& operator+=(Bigint& a,int x)
{
    B_INT i;
    if(x>=base)    return a+=Bigint(x);
    TRY(a.a,a.a[0]+1);
    a.a[1]+=x;
    for(i=1;i<=a.a[0];++i)
        if(a.a[i]>=base)    {++a.a[i+1];a.a[i]-=base;}
        else    break;
    if(a.a[a.a[0]+1]>0) ++a.a[0];
    return a;
}
Bigint operator-(const Bigint& a,const Bigint& b){Bigint c=a;c-=b;return c;}
Bigint& operator-=(Bigint &a,const Bigint &b)//要求保证减数b小于等于被减数a
{
    B_INT i;
    a.a[0]=max(a.a[0],b.a[0]);
    //TRY(a.a,a.a[0]+1);//b<=a,所以减完后位数不可能增多
    for(i=1;i<=min(a.a[0],b.a[0]);++i)    a.a[i]-=b.a[i];
    for(i=1;i<=a.a[0];++i)
        if(a.a[i]<0)    {a.a[i]+=base;a.a[i+1]--;}
    while(a.a[0]&&a.a[a.a[0]]==0)    --a.a[0];
    //vector<B_INT> t=a.a;swap(t,a.a);
    return a;
}
Bigint operator*(const Bigint& a,const Bigint& b){Bigint c=a;c*=b;return c;}
Bigint& operator*=(Bigint& a,const Bigint& b)
{
    if(a==zero||b==zero)    {return a=zero;}
    int i,len=a.a[0]+b.a[0]-1,bit=0;
    while((1<<bit)<len)    bit++;
    len=(1<<bit);
    for(i=0;i<len;++i)
        rev[i]=(rev[i>>1]>>1)|((i&1)<<(bit-1));
    for(i=1;i<=a.a[0];++i)
        t1[i-1].x=a.a[i],t1[i-1].y=0;
    for(i=a.a[0];i<len;++i)
        t1[i].x=t1[i].y=0;
    for(i=1;i<=b.a[0];++i)
        t2[i-1].x=b.a[i],t2[i-1].y=0;
    for(i=b.a[0];i<len;++i)
        t2[i].x=t2[i].y=0;
    dft(t1,len,1);dft(t2,len,1);
    for(i=0;i<len;++i)  t1[i]=t1[i]*t2[i];
    dft(t1,len,-1);
    for(i=1;i<=len;++i)   buf[i]=(LL)(t1[i-1].x+0.5);
    buf[len+1]=0;//
    for(i=1;i<=len;++i)
    {
        buf[i+1]+=buf[i]/base;
        buf[i]%=base;
    }
    if(buf[len+1])  ++len;
    while(buf[len]==0)  --len;
    a.a[0]=len;
    TRY(a.a,len);
    for(i=1;i<=len;i++) a.a[i]=buf[i];
    return a;
}
Bigint operator*(const Bigint& a,int x){Bigint c=a;c*=x;return c;}
Bigint& operator*=(Bigint& a,int x)
{
    if(x==0)    return a=zero;
    if(x>=base)    return a*=Bigint(x);
    B_INT i;
    //a[a[0]+1]=0
    memset(buf,0,sizeof(buf));
    for(i=1;i<=a.a[0];++i)
    {
        //printf("%d %d
",i,a.a[i]);
        buf[i]=(LL)a.a[i]*x;//注意LL
        //a.a[i+1]+=buf[0]/base;
        //a.a[i]=buf[i]%base;//printf("%daa
",a.a[i]);
    }
    for(i=1;i<=a.a[0];++i)
    {
        //printf("%lldss
",buf[i]);
        a.a[i]=buf[i]%base;
        buf[i+1]+=buf[i]/base;
    }
    //if(a.a[a.a[0]+1]>0)    ++a.a[0];
    //if(buf[buf[0]+1]>0) {a.a[++a.a[0]]=buf[buf[0]+1];}
    if(buf[a.a[0]+1]>0)    {++a.a[0];a.a.pb(buf[a.a[0]]);}
    return a;
}
Bigint operator/(const Bigint& a,const Bigint& b)
{
    if(a<b) return zero;//必须加这句
    Bigint t=zero,c,d;c.a[0]=a.a[0]-b.a[0]+1;TRY(c.a,c.a[0]);
    B_INT i,j;
    for(i=a.a[0];i>=1;--i)
    {
       t*=base;t+=a.a[i];
       for(j=l2b;j>=0;--j)
       {
           d=b*pw22[j];
           if(t>=d)    {c.a[i]+=pw22[j];t-=d;}
       }
       //printf("%dt2
",c.a[i]);
    }
    while(c.a[0]&&c.a[c.a[0]]==0) --c.a[0];
    //vector<B_INT> t=c.a;swap(t,c.a);
    return c;
}
Bigint& operator/=(Bigint& a,const Bigint& b){a=a/b;return a;}
Bigint operator/(const Bigint& a,int x){Bigint c=a;c/=x;return c;}
Bigint& operator/=(Bigint& a,int x)//要求不超过base的小数字
{
    B_INT i;LL t=0;
    for(i=a.a[0];i>=1;--i)
    {
        t*=base;t+=a.a[i];// int xx;printf("%lldkfk
",t);
        a.a[i]=t/x;//printf("%dkfk
",a.a[i]);scanf("%d",&xx);
        t%=x;
    }
    while(a.a[0]&&a.a[a.a[0]]==0) --a.a[0];
    return a;
}
Bigint operator%(const Bigint& a,const Bigint& b)
{
    //return *this-*this/b*b;
    Bigint t=zero,d;
    B_INT i,j;
    for(i=a.a[0];i>=1;--i)
    {
        t=t*base+a.a[i];
        for(j=l2b;j>=0;--j)
        {
            d=b*pw22[j];
            if(t>=d)    t-=d;
        }
    }
    return t;
}
void swap(Bigint &a,Bigint &b)    {swap(a.a,b.a);}
Bigint x[3];
char str[100010];
Bigint gcd(Bigint a,Bigint b)
{
    Bigint c=one;
    while(a!=b)
    {
        if(a<b) swap(a,b);
        //(a/2).println("k2");
        //a.print();puts("a");b.print();puts("b");puts("");
        if(a.odd()&&b.odd())  a-=b;
        else    if(a.odd())
            b/=2;
        else if(b.odd())
            a/=2;
        else
            a/=2,b/=2,c*=2;
        //a.print();puts("a2");b.print();puts("b2");puts("");c.println("c2");int t;scanf("%d",&t);
    }
    return a*c;
}
//Bigint gcd(Bigint a,Bigint b)
//{
//    Bigint t;
//    static Bigint zero=0;
//    while(b!=zero)
//    {
//        t=a;
//        a=b;
//        b=t%b;
//    }
//    return a;
//}
int main()
{
    /*
    bool fl;int t;//scanf("%d",&t);
    //(Bigint("13582583")*15345).print();
    //(Bigint("3948636459042352478494043859377305164061320248669026579423660")).println();
    //(Bigint("3948636459042352478494043859377305164061320248669026579423660")/Bigint("2")).println();
    while(scanf("%s",str+1)==1)
    {
        fl=0;
        if(str[1]=='-') x[0]=str+2,fl^=1;
        else    x[0]=str+1;
        scanf("%s",str+1);
        if(str[1]=='-') x[1]=str+2,fl^=1;
        else    x[1]=str+1;
        //(x[0]+x[1]).println();
        //if(x[0]>=x[1])  (x[0]-x[1]).println();
        //else    putchar('-'),(x[1]-x[0]).println();
        //x[0].println();x[1].println();
        x[2]=x[0]*x[1];
        if(fl&&x[2]!=zero)  putchar('-');
        x[2].println();
        //(x[0]/x[1]).println();
        //(x[0]%x[1]).println();
    }
    //(gcd(x[0],x[1])).print();;
    //(x[0]*x[1]).print();
    //(Bigint("8392523")%Bigint("5")).print();
    //printf("
%d",(Bigint("233")-Bigint("233"))==Bigint("1"));
    */
    scanf("%s",str);
    x[0]=str;
    scanf("%s",str);
    x[1]=str;
    //(x[0]+x[1]).println();
    //if(x[0]>=x[1])  (x[0]-x[1]).println();
    //else    putchar('-'),(x[1]-x[0]).println();
    //(x[0]*x[1]).println();
    //(x[0]/x[1]).println();
    //(x[0]%x[1]).println();
    gcd(x[0],x[1]).println();
    return 0;
}

---

2018-3-4

（加入FFT优化的高精度乘法）

注意：对拍得出，两个乘数在80000位及以下保持压4位应该不会出现精度问题，乘数在80000到390000位则只能压3位或以下（只测了几组随机数据的精度，所以位数超过10000最好还是只压3位）

带注释版本：

#pragma GCC optimize("Ofast")
#pragma GCC target("sse3","sse2","sse")
#pragma GCC target("avx","sse4","sse4.1","sse4.2","ssse3")
#pragma GCC target("f16c")
//#pragma GCC target("fma","avx2")
//#pragma GCC target("xop","fma4")
#pragma GCC optimize("inline","fast-math","unroll-loops","no-stack-protector")
#pragma GCC diagnostic error "-fwhole-program"
#pragma GCC diagnostic error "-fcse-skip-blocks"
#pragma GCC diagnostic error "-funsafe-loop-optimizations"
#pragma GCC diagnostic error "-std=c++14"
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
typedef int B_INT;
#define p_c "%04d"
#define i_c "%d"
#define b_c "10000"
//const char p_c[]="%08lld";
//const char i_c[]="%lld";
//const char b_c[]="100000000";
const B_INT p=4;//压p位,int压4位加乘法可能导致溢出,longlong压8位乘法会炸而且慢
const B_INT base=10000;//压p位，最大数为10^p-1
const int maxl=31000;//如果有乘法，则大于最大读入位数/p*2
//fft乘容易掉精度，不能压太多位
//const B_INT l2b=14;//=向上取整(log2(base))
const B_INT l2b=13;//=向下取整(log2(base))
const int fftlen=33000;//4096>4000且为2的幂
struct Bigint
{
/*
基本类型（char,int,float,double等）的静态成员可以在类里面声明并初始化，
非基本类（char[],string ,自定义等）必须在类里面声明，类外初始化。
*/
    B_INT a[maxl];//a[0]->len,a[i]->从后往前数第i个p位
    Bigint(){memset(a,0,sizeof(a));}
    Bigint(const char *str){*this=str;}
    Bigint(const Bigint& b){memcpy(a,b.a,sizeof(a));}
    Bigint(int x){*this=x;}

    Bigint& operator=(const Bigint& b){memcpy(a,b.a,sizeof(a));return *this;}
    Bigint& operator=(int x)
    {
        memset(a,0,sizeof(a));
        do{a[++a[0]]=x%base;x/=base;}while(x);
        return *this;
    }
    Bigint& operator=(const char *str)
    {
        memset(a,0,sizeof(a));
        B_INT k=0,p=1;char *str1=(char*)(str+strlen(str)-1);
        while(str1>=str)
        {
            k=k+p*(*str1-48);
            if(p==base){a[++a[0]]=k%base;k/=base;p=1;}
            --str1;p*=10;
        }
        a[++a[0]]=k;
        return *this;
    }

    friend Bigint operator+(const Bigint&,const Bigint&);
    friend Bigint& operator+=(Bigint&,const Bigint&);
    friend Bigint operator+(const Bigint&,int x);
    friend Bigint& operator+=(Bigint&,int x);

    friend Bigint operator-(const Bigint&,const Bigint&);
    friend Bigint& operator-=(Bigint&,const Bigint&);

    friend Bigint operator*(const Bigint&,const Bigint&);
    friend Bigint& operator*=(Bigint&,const Bigint&);
    friend Bigint operator*(const Bigint&,int x);
    friend Bigint& operator*=(Bigint& a,int x);

    friend Bigint operator/(const Bigint&,const Bigint&);
    friend Bigint& operator/=(Bigint&,const Bigint&);
    friend Bigint operator/(const Bigint& a,int x);
    friend Bigint& operator/=(Bigint &,int);

    friend Bigint operator%(const Bigint&,const Bigint&);

    friend bool operator<(const Bigint& a,const Bigint& b);
    friend bool operator<=(const Bigint& a,const Bigint& b);
    friend bool operator>(const Bigint& a,const Bigint& b);
    friend bool operator>=(const Bigint& a,const Bigint& b);
    friend bool operator==(const Bigint& a,const Bigint& b);
    friend bool operator!=(const Bigint& a,const Bigint& b);

    void print() const
    {
        printf(i_c,a[a[0]]);
        for(B_INT i=a[0]-1;i>0;i--)
            printf(p_c,a[i]);
    }
    void println() const    {print();puts("");}
    void println(const char* x) const   {print();puts(x);}
    bool odd() const    {return a[1]&1;}
};
LL buf[maxl<<1];
const double Pi=acos(-1.0);
struct cpl
{
    double x,y;
    cpl(double xx=0,double yy=0):x(xx),y(yy){}
};
cpl operator+(const cpl& a,const cpl& b){return cpl(a.x+b.x,a.y+b.y);}
cpl operator-(const cpl& a,const cpl& b){return cpl(a.x-b.x,a.y-b.y);}
cpl operator*(const cpl& a,const cpl& b){return cpl(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}
int rev[fftlen];cpl t1[fftlen],t2[fftlen];
void dft(cpl *a,int len,int idx)//将a做dft，结果放入a,dft->idx=1,idft->idx=-1
{
    cpl wn,wnk,t1,t2;int i,j,k;
    for(i=0;i<len;i++)    if(i<rev[i])    swap(a[i],a[rev[i]]);
    //例如将23的二进制(10111)翻转(共5位),先得到01011(后四位)的翻转(11010)，然后右移一位后在前面补上一个1(因为23&1为1)
    for(i=1;i<len;i<<=1)
    {
        wn=cpl(cos(Pi/i),idx*sin(Pi/i));
        for(j=0;j<len;j+=(i<<1))//每一次合并[j,j+i),[j+i,j+2i)
        {
            wnk=cpl(1,0);
            for(k=j;k<j+i;k++)
            {
                t1=a[k];t2=wnk*a[k+i];
                a[k]=t1+t2;a[k+i]=t1-t2;
                wnk=wnk*wn;
            }
        }
    }
    if(idx==-1)
        for(i=0;i<len;i++)
            a[i].x/=len,a[i].y/=len;
}
const Bigint zero=0,one=1;
//const Bigint bas=base;
//const Bigint pw2[]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576};
const B_INT pw22[]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576};
bool operator<(const Bigint& a,const Bigint& b)
{
    if(a.a[0]!=b.a[0])
        return a.a[0]<b.a[0];
    for(B_INT i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]<b.a[i];
    return 0;//相等
}
/*
非静态成员函数后面加const（加到非成员函数或静态成员后面会产生编译错误），
表示成员函数隐含传入的this指针为 const指针，
决定了在该成员函数中，
任意修改它所在的类的成员的操作都是不允许的
（因为隐含了对this指针的const引用）；
唯一的例外是对于 mutable修饰的成员。
加了const的成员函数可以被非const对象和const对象调用，
但不加const的成员函数只能被非const对象调用。
下方b是const,const函数不能修改其数据成员
*/
bool operator>(const Bigint& a,const Bigint& b)
{
    return b<a;
    /*
    if(a.a[0]!=b.a[0])
        return a.a[0]>b.a[0];
    for(int i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]>b.a[i];
    return false;//相等
    */
}
bool operator<=(const Bigint& a,const Bigint& b)
{
    return !(b<a);
    /*
    if(a.a[0]!=b.a[0])
        return a.a[0]>b.a[0];
    for(int i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]>b.a[i];
    return true;//相等
    */
}
bool operator>=(const Bigint& a,const Bigint& b)
{
    return !(a<b);
    /*
    if(a.a[0]!=b.a[0])
        return a.a[0]>b.a[0];
    for(int i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]>b.a[i];
    return true;//相等
    */
}
bool operator==(const Bigint& a,const Bigint& b)
{
    if(a.a[0]!=b.a[0])
        return 0;
    for(B_INT i=a.a[0];i>0;--i)
        if(a.a[i]!=b.a[i])
            return 0;
    return 1;
}
bool operator!=(const Bigint& a,const Bigint& b)
{
    return !(a==b);
}
Bigint operator+(const Bigint& a,const Bigint& b){Bigint c=a;c+=b;return c;}
Bigint& operator+=(Bigint& a,const Bigint& b)
{
    B_INT i;
    a.a[0]=max(a.a[0],b.a[0]);
    for(i=1;i<=a.a[0];i++)
    {
        a.a[i]+=b.a[i];
        a.a[i+1]+=a.a[i]/base;
        a.a[i]%=base;
    }
    if(a.a[a.a[0]+1]>0) a.a[0]++;
    return a;
}
Bigint operator+(const Bigint& a,int x){Bigint c=a;c+=x;return c;}
Bigint& operator+=(Bigint& a,int x)//要求不超过base的小数字
{
    B_INT i;
    a.a[1]+=x;
    for(i=1;i<=a.a[0];++i)
        if(a.a[i]>=base)    {++a.a[i+1];a.a[i]-=base;}
        else    break;
    if(a.a[a.a[0]+1]>0) ++a.a[0];
    return a;
}
Bigint operator-(const Bigint& a,const Bigint& b){Bigint c=a;c-=b;return c;}
Bigint& operator-=(Bigint &a,const Bigint &b)//要求保证减数小于被减数
{
    B_INT i;
    a.a[0]=std::max(a.a[0],b.a[0]);
    for(i=1;i<=a.a[0];++i)    a.a[i]-=b.a[i];
    for(i=1;i<=a.a[0];++i)
        if(a.a[i]<0)    {a.a[i]+=base;a.a[i+1]--;}
    while(a.a[a.a[0]]==0&&a.a[0]>1)    --a.a[0];
    return a;
}
Bigint operator*(const Bigint& a,const Bigint& b){Bigint c=a;c*=b;return c;}
Bigint& operator*=(Bigint& a,const Bigint& b)
{
    if(a==zero||b==zero)    {return a=zero;}
    int i,len=a.a[0]+b.a[0]-1,bit=0;
    while((1<<bit)<len)    bit++;
    len=(1<<bit);
    for(i=0;i<len;++i)
        rev[i]=(rev[i>>1]>>1)|((i&1)<<(bit-1));
    for(i=1;i<=a.a[0];++i)
        t1[i-1].x=a.a[i],t1[i-1].y=0;
    for(i=a.a[0];i<len;++i)
        t1[i].x=t1[i].y=0;
    for(i=1;i<=b.a[0];++i)
        t2[i-1].x=b.a[i],t2[i-1].y=0;
    for(i=b.a[0];i<len;++i)
        t2[i].x=t2[i].y=0;
    dft(t1,len,1);dft(t2,len,1);
    for(i=0;i<len;++i)  t1[i]=t1[i]*t2[i];
    dft(t1,len,-1);
    for(i=1;i<=len;++i)   buf[i]=(LL)(t1[i-1].x+0.5);
    buf[len+1]=0;//
    for(i=1;i<=len;++i)
    {
        buf[i+1]+=buf[i]/base;
        buf[i]%=base;
    }
    if(buf[len+1])  ++len;
    while(buf[len]==0)  --len;
    a.a[0]=len;
    for(i=1;i<=len;i++) a.a[i]=buf[i];
    return a;
}
Bigint operator*(const Bigint& a,int x){Bigint c=a;c*=x;return c;}
Bigint& operator*=(Bigint& a,int x)//要求不超过base的小数字
{
    if(x==0)    {a=zero;return a;}
    B_INT i;
    //a[a[0]+1]=0
    memset(buf,0,sizeof(buf));
    for(i=1;i<=a.a[0];++i)
    {
        //printf("%d %d
",i,a.a[i]);
        buf[i]=(LL)a.a[i]*x;//注意LL
        //a.a[i+1]+=buf[0]/base;
        //a.a[i]=buf[i]%base;//printf("%daa
",a.a[i]);
    }
    for(i=1;i<=a.a[0];++i)
    {
        //printf("%lldss
",buf[i]);
        a.a[i]=buf[i]%base;
        buf[i+1]+=buf[i]/base;
    }
    //if(a.a[a.a[0]+1]>0)    ++a.a[0];
    //if(buf[buf[0]+1]>0) {a.a[++a.a[0]]=buf[buf[0]+1];}
    if(buf[a.a[0]+1]>0)    {++a.a[0];a.a[a.a[0]]=buf[a.a[0]];}
    return a;
}
Bigint operator/(const Bigint& a,const Bigint& b)
{
    if(a<b) return zero;//必须加这句
    Bigint t=zero,c,d;c.a[0]=a.a[0]-b.a[0]+1;
    B_INT i,j;
    for(i=a.a[0];i>=1;--i)
    {
       t*=base;t+=a.a[i];
       for(j=l2b;j>=0;--j)
       {
           d=b*pw22[j];
           if(t>=d)    {c.a[i]+=pw22[j];t-=d;}
       }
       //printf("%dt2
",c.a[i]);
    }
    while(c.a[0]>1&&c.a[c.a[0]]==0) --c.a[0];
    return c;
}
Bigint& operator/=(Bigint& a,const Bigint& b){a=a/b;return a;}
Bigint operator/(const Bigint& a,int x){Bigint c=a;c/=x;return c;}
Bigint& operator/=(Bigint& a,int x)//要求不超过base的小数字
{
    B_INT i;LL t=0;
    for(i=a.a[0];i>=1;--i)
    {
        t*=base;t+=a.a[i];// int xx;printf("%lldkfk
",t);
        a.a[i]=t/x;//printf("%dkfk
",a.a[i]);scanf("%d",&xx);
        t%=x;
    }
    while(a.a[0]>1&&a.a[a.a[0]]==0) --a.a[0];
    return a;
}
Bigint operator%(const Bigint& a,const Bigint& b)
{
    //return *this-*this/b*b;
    Bigint t=zero,d;
    B_INT i,j;
    for(i=a.a[0];i>=1;--i)
    {
        t=t*base+a.a[i];
        for(j=l2b;j>=0;--j)
        {
            d=b*pw22[j];
            if(t>=d)    t-=d;
        }
    }
    return t;
}

Bigint x[3];
char str[50010];
Bigint gcd(Bigint a,Bigint b)
{
    Bigint c=one,t;
    while(a!=b)
    {
        if(a<b) {t=a;a=b;b=t;}
        //(a/2).println("k2");
        //a.print();puts("a");b.print();puts("b");puts("");
        if(a.odd()&&b.odd())  a-=b;
        else    if(a.odd())
            b/=2;
        else if(b.odd())
            a/=2;
        else
            a/=2,b/=2,c*=2;
        //a.print();puts("a2");b.print();puts("b2");puts("");c.println("c2");int t;scanf("%d",&t);
    }
    return a*c;
}
//Bigint gcd(Bigint a,Bigint b)
//{
//    Bigint t;
//    static Bigint zero=0;
//    while(b!=zero)
//    {
//        t=a;
//        a=b;
//        b=t%b;
//    }
//    return a;
//}
int main()
{
    bool fl;int t;scanf("%d",&t);
    //(Bigint("13582583")*15345).print();
    //(Bigint("3948636459042352478494043859377305164061320248669026579423660")).println();
    //(Bigint("3948636459042352478494043859377305164061320248669026579423660")/Bigint("2")).println();
    while(scanf("%s",str+1)==1)
    {
        fl=0;
        if(str[1]=='-') x[0]=str+2,fl^=1;
        else    x[0]=str+1;
        scanf("%s",str+1);
        if(str[1]=='-') x[1]=str+2,fl^=1;
        else    x[1]=str+1;
        //(x[0]+x[1]).println();
        //if(x[0]>=x[1])  (x[0]-x[1]).println();
        //else    putchar('-'),(x[1]-x[0]).println();
        //x[0].println();x[1].println();
        x[2]=x[0]*x[1];
        if(fl&&x[2]!=zero)  putchar('-');
        x[2].println();
        //(x[0]/x[1]).println();
        //(x[0]%x[1]).println();
    }
    //(gcd(x[0],x[1])).print();;
    //(x[0]*x[1]).print();
    //(Bigint("8392523")%Bigint("5")).print();
    //printf("
%d",(Bigint("233")-Bigint("233"))==Bigint("1"));
//    scanf("%s",str);
//    x[0]=str;
//    scanf("%s",str);
//    x[1]=str;
//  if(x[0]<x[1])
//  {
//      printf("-");
//      x[2]=x[0];
//      x[0]=x[1];
//      x[1]=x[2];
//  }
//  (x[0]-x[1]).print();
//  (x[0]*x[1]).print();
//    printf("%d",x[0]>x[1]);
//    (x[1]=x[1]).print();
//  puts("");
//  x[0].print();
//  puts("");
//  x[1].print();
    return 0;
}

压行版本：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
typedef int B_INT;
#define p_c "%04d"
#define i_c "%d"
#define b_c "10000"
const B_INT p=4,base=10000,l2b=13;
const int maxl=5100,fftlen=8200;
struct Bigint{
B_INT a[maxl];
Bigint(){memset(a,0,sizeof(a));}
Bigint(const char *str){*this=str;}
Bigint(const Bigint& b){memcpy(a,b.a,sizeof(a));}
Bigint(int x){*this=x;}
Bigint& operator=(const Bigint& b){memcpy(a,b.a,sizeof(a));return *this;}
Bigint& operator=(int x){memset(a,0,sizeof(a));do{a[++a[0]]=x%base;x/=base;}while(x);return *this;}
Bigint& operator=(const char *str){memset(a,0,sizeof(a));
B_INT k=0,p=1;char *str1=(char*)(str+strlen(str)-1);
while(str1>=str){k=k+p*(*str1-48);if(p==base){a[++a[0]]=k%base;k/=base;p=1;}--str1;p*=10;}
a[++a[0]]=k;return *this;}
friend Bigint operator+(const Bigint&,const Bigint&);
friend Bigint& operator+=(Bigint&,const Bigint&);
friend Bigint operator+(const Bigint&,int x);
friend Bigint& operator+=(Bigint&,int x);
friend Bigint operator-(const Bigint&,const Bigint&);
friend Bigint& operator-=(Bigint&,const Bigint&);
friend Bigint operator*(const Bigint&,const Bigint&);
friend Bigint& operator*=(Bigint&,const Bigint&);
friend Bigint operator*(const Bigint&,int x);
friend Bigint& operator*=(Bigint& a,int x);
friend Bigint operator/(const Bigint&,const Bigint&);
friend Bigint& operator/=(Bigint&,const Bigint&);
friend Bigint operator/(const Bigint& a,int x);
friend Bigint& operator/=(Bigint &,int);
friend Bigint operator%(const Bigint&,const Bigint&);
friend bool operator<(const Bigint& a,const Bigint& b);
friend bool operator<=(const Bigint& a,const Bigint& b);
friend bool operator>(const Bigint& a,const Bigint& b);
friend bool operator>=(const Bigint& a,const Bigint& b);
friend bool operator==(const Bigint& a,const Bigint& b);
friend bool operator!=(const Bigint& a,const Bigint& b);
void print()const{printf(i_c,a[a[0]]);for(B_INT i=a[0]-1;i>0;i--)printf(p_c,a[i]);}
void println()const{print();puts("");}
void println(const char* x)const{print();puts(x);}
bool odd()const{return a[1]&1;}};
LL buf[maxl<<1];const double Pi=acos(-1.0);
struct cpl{double x,y;cpl(double xx=0,double yy=0):x(xx),y(yy){}};
cpl operator+(const cpl& a,const cpl& b){return cpl(a.x+b.x,a.y+b.y);}
cpl operator-(const cpl& a,const cpl& b){return cpl(a.x-b.x,a.y-b.y);}
cpl operator*(const cpl& a,const cpl& b){return cpl(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}
int rev[fftlen];cpl t1[fftlen],t2[fftlen];
void dft(cpl *a,int len,int idx){cpl wn,wnk,t1,t2;int i,j,k;
for(i=0;i<len;i++)if(i<rev[i])swap(a[i],a[rev[i]]);
for(i=1;i<len;i<<=1){wn=cpl(cos(Pi/i),idx*sin(Pi/i));for(j=0;j<len;j+=(i<<1))
{wnk=cpl(1,0);for(k=j;k<j+i;k++){t1=a[k];t2=wnk*a[k+i];a[k]=t1+t2;a[k+i]=t1-t2;wnk=wnk*wn;}}}
if(idx==-1)for(i=0;i<len;i++)a[i].x/=len,a[i].y/=len;}
const Bigint zero=0,one=1;const B_INT pw22[]={1,2,4,8,16,32,64,128,256,512,1024,
2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576};
bool operator<(const Bigint& a,const Bigint& b){if(a.a[0]!=b.a[0])return a.a[0]<b.a[0];
for(B_INT i=a.a[0];i>0;i--)if(a.a[i]!=b.a[i])return a.a[i]<b.a[i];return 0;}
bool operator>(const Bigint& a,const Bigint& b){return b<a;}
bool operator<=(const Bigint& a,const Bigint& b){return !(b<a);}
bool operator>=(const Bigint& a,const Bigint& b){return !(a<b);}
bool operator==(const Bigint& a,const Bigint& b){if(a.a[0]!=b.a[0])return 0;
for(B_INT i=a.a[0];i>0;--i)if(a.a[i]!=b.a[i])return 0;return 1;}
bool operator!=(const Bigint& a,const Bigint& b){return !(a==b);}
Bigint& operator+=(Bigint& a,const Bigint& b){B_INT i;a.a[0]=max(a.a[0],b.a[0]);
for(i=1;i<=a.a[0];i++){a.a[i]+=b.a[i];a.a[i+1]+=a.a[i]/base;a.a[i]%=base;}if(a.a[a.a[0]+1]>0) a.a[0]++;return a;}
Bigint operator+(const Bigint& a,const Bigint& b){Bigint c=a;c+=b;return c;}
Bigint operator+(const Bigint& a,int x){Bigint c=a;c+=x;return c;}
Bigint& operator+=(Bigint& a,int x){B_INT i;a.a[1]+=x;
for(i=1;i<=a.a[0];++i)if(a.a[i]>=base){++a.a[i+1];a.a[i]-=base;}else    break;
if(a.a[a.a[0]+1]>0) ++a.a[0];return a;}
Bigint& operator-=(Bigint &a,const Bigint &b){B_INT i;a.a[0]=std::max(a.a[0],b.a[0]);
for(i=1;i<=a.a[0];++i)a.a[i]-=b.a[i];for(i=1;i<=a.a[0];++i)if(a.a[i]<0){a.a[i]+=base;a.a[i+1]--;}
while(a.a[a.a[0]]==0&&a.a[0]>1)--a.a[0];return a;}
Bigint operator-(const Bigint& a,const Bigint& b){Bigint c=a;c-=b;return c;}
Bigint operator*(const Bigint& a,const Bigint& b){Bigint c=a;c*=b;return c;}
Bigint& operator*=(Bigint& a,const Bigint& b){if(a==zero||b==zero){return a=zero;}
int i,len=a.a[0]+b.a[0]-1,bit=0;while((1<<bit)<len)bit++;len=(1<<bit);
for(i=0;i<len;++i)rev[i]=(rev[i>>1]>>1)|((i&1)<<(bit-1));
for(i=1;i<=a.a[0];++i)t1[i-1].x=a.a[i],t1[i-1].y=0;for(i=a.a[0];i<len;++i)t1[i].x=t1[i].y=0;
for(i=1;i<=b.a[0];++i)t2[i-1].x=b.a[i],t2[i-1].y=0;for(i=b.a[0];i<len;++i)t2[i].x=t2[i].y=0;
dft(t1,len,1);dft(t2,len,1);for(i=0;i<len;++i)t1[i]=t1[i]*t2[i];dft(t1,len,-1);
for(i=1;i<=len;++i)buf[i]=(LL)(t1[i-1].x+0.5);buf[len+1]=0;for(i=1;i<=len;++i)
{buf[i+1]+=buf[i]/base;buf[i]%=base;}if(buf[len+1])++len;while(buf[len]==0)--len;
a.a[0]=len;for(i=1;i<=len;i++) a.a[i]=buf[i];return a;}
Bigint operator*(const Bigint& a,int x){Bigint c=a;c*=x;return c;}
Bigint& operator*=(Bigint& a,int x){if(x==0){a=zero;return a;}B_INT i;memset(buf,0,sizeof(buf));
for(i=1;i<=a.a[0];++i)buf[i]=(LL)a.a[i]*x;for(i=1;i<=a.a[0];++i){a.a[i]=buf[i]%base;buf[i+1]+=buf[i]/base;}
if(buf[a.a[0]+1]>0){++a.a[0];a.a[a.a[0]]=buf[a.a[0]];}return a;}
Bigint operator/(const Bigint& a,const Bigint& b){if(a<b) return zero;Bigint t=zero,c,d;
c.a[0]=a.a[0]-b.a[0]+1;B_INT i,j;for(i=a.a[0];i>=1;--i){t*=base;t+=a.a[i];for(j=l2b;j>=0;--j)
{d=b*pw22[j];if(t>=d){c.a[i]+=pw22[j];t-=d;}}}while(c.a[0]>1&&c.a[c.a[0]]==0) --c.a[0];return c;}
Bigint& operator/=(Bigint& a,const Bigint& b){a=a/b;return a;}
Bigint operator/(const Bigint& a,int x){Bigint c=a;c/=x;return c;}
Bigint& operator/=(Bigint& a,int x){B_INT i;LL t=0;for(i=a.a[0];i>=1;--i)
{t*=base;t+=a.a[i];a.a[i]=t/x;t%=x;}while(a.a[0]>1&&a.a[a.a[0]]==0)--a.a[0];return a;}
Bigint operator%(const Bigint& a,const Bigint& b){Bigint t=zero,d;B_INT i,j;
for(i=a.a[0];i>=1;--i){t=t*base+a.a[i];for(j=l2b;j>=0;--j){d=b*pw22[j];if(t>=d)t-=d;}}return t;}
Bigint gcd(Bigint a,Bigint b){Bigint c=one,t;while(a!=b){if(a<b) {t=a;a=b;b=t;}if(a.odd()&&b.odd())    a-=b;
else if(a.odd()) b/=2;else if(b.odd())a/=2;else a/=2,b/=2,c*=2;}return a*c;}
Bigint x[3];
char str[30010];
int main()
{
    scanf("%s",str);x[0]=str;
    scanf("%s",str);x[1]=str;
    (x[0]+x[1]).println();
    if(x[0]>=x[1])  (x[0]-x[1]).println();
    else    putchar('-'),(x[1]-x[0]).println();
    (x[0]*x[1]).println();
    (x[0]/x[1]).println();
    (x[0]%x[1]).println();
    return 0;
}

---

2018-2-6

附：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <algorithm>
using namespace std;
typedef long long LL;

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 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 || flag==a.flag && le<a.le) return 1;
            if (flag>a.flag || flag==a.flag && le>a.le) return 0;
            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 || flag==a.flag && le<a.le) return 0;
            if (flag>a.flag || flag==a.flag && le>a.le) return 1;
            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) 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;

            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;
            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*=x;
            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);
        }
    };


    //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){
        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) 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;



int main() {
    BigNum a,b,c,d;
    Read(a); Read(b);
    Println(gcd(a,b));
    return 0;
}

奇怪的东西：

//#pragma GCC optimize(3)
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;typedef long long LL;typedef int X;
#define p_c "%05d"
#define i_c "%d"
#define b_c "100000"
#define M memcpy
#define E memset
#define R return
#define C const
#define O operator
#define F for
#define Q printf
#define L bool
#define S sizeof
C X p=5,e=100000;C int maxl=4000,l2b=16;
struct B{X a[maxl];
B(){E(a,0,S(a));}B(C char *str){*this=str;}B(C B& b){M(a,b.a,S(a));}
B(int x){*this=x;}B& O=(C B& b){M(a,b.a,S(a));R *this;}
B& O=(int x){E(a,0,S(a));do{a[++a[0]]=x%e;x/=e;}while(x);R *this;}
B& O=(C char *str){E(a,0,S(a));X k=0,p=1;char *str1=(char*)(str+strlen(str)-1);
while(str1>=str){k=k+p*(*str1-48);if(p==e){a[++a[0]]=k%e;k/=e;p=1;}--str1;p*=10;}a[++a[0]]=k;R *this;}
void P()C{Q(i_c,a[a[0]]);F(X i=a[0]-1;i>0;i--)Q(p_c,a[i]);}
void println()C{P();puts("");}void println(C char* x) C{P();puts(x);}L odd() C{R a[1]&1;}};
LL buf[maxl<<1];C B z=0,one=1;
C X pw22[]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576};
L O<(C B& a,C B& b){if(a.a[0]!=b.a[0])R a.a[0]<b.a[0];F(X i=a.a[0];i>0;i--)if(a.a[i]!=b.a[i])R a.a[i]<b.a[i];R 0;}
L O>(C B& a,C B& b){R b<a;}L O<=(C B& a,C B& b){R !(b<a);}L O>=(C B& a,C B& b){R !(a<b);}
L O==(C B& a,C B& b){if(a.a[0]!=b.a[0])R 0;F(X i=a.a[0];i>0;--i)if(a.a[i]!=b.a[i])R 0;R 1;}
L O!=(C B& a,C B& b){R !(a==b);}
B& O+=(B& a,C B& b){X i;a.a[0]=max(a.a[0],b.a[0]);
F(i=1;i<=a.a[0];i++){a.a[i]+=b.a[i];a.a[i+1]+=a.a[i]/e;a.a[i]%=e;}if(a.a[a.a[0]+1]>0) a.a[0]++;R a;}
B O+(C B& a,C B& b){B c=a;c+=b;R c;}B O+(C B& a,int x){B c=a;c+=x;R c;}
B& O+=(B& a,int x){X i;a.a[1]+=x;
F(i=1;i<=a.a[0];++i)if(a.a[i]>=e){++a.a[i+1];a.a[i]-=e;}else break;if(a.a[a.a[0]+1]>0) ++a.a[0];R a;}
B& O-=(B &a,C B &b){X i;a.a[0]=max(a.a[0],b.a[0]);
F(i=1;i<=a.a[0];++i)a.a[i]-=b.a[i];F(i=1;i<=a.a[0];++i)if(a.a[i]<0){a.a[i]+=e;a.a[i+1]--;}
while(a.a[a.a[0]]==0&&a.a[0]>1)--a.a[0];R a;}
B O-(C B& a,C B& b){B c=a;c-=b;R c;}
B& O*=(B& a,C B& b){X i,j;if(a==z||b==z){a=z;R a;}
E(buf,0,S(buf));F(i=1;i<=a.a[0];i++)F(j=1;j<=b.a[0];j++)buf[i+j-1]+=(LL)a.a[i]*b.a[j];
buf[0]=a.a[0]+b.a[0]-1;F(i=1;i<=buf[0];++i){buf[i+1]+=buf[i]/e;a.a[i]=buf[i]%e;}
a.a[0]=buf[0];if(buf[buf[0]+1]>0) {a.a[++a.a[0]]=buf[buf[0]+1];}R a;}
B O*(C B& a,C B& b){B c=a;c*=b;R c;}
B O*(C B& a,int x){B c=a;c*=x;R c;}
B& O*=(B& a,int x){if(x==0)    {a=z;R a;}X i;E(buf,0,S(buf));
F(i=1;i<=a.a[0];++i)  buf[i]=(LL)a.a[i]*x;F(i=1;i<=a.a[0];++i)  {a.a[i]=buf[i]%e;buf[i+1]+=buf[i]/e;}
if(buf[a.a[0]+1]>0) {++a.a[0];a.a[a.a[0]]=buf[a.a[0]];}R a;}
B O/(C B& a,C B& b){if(a<b) R z;B t=z,c,d;
c.a[0]=a.a[0]-b.a[0]+1;X i,j;F(i=a.a[0];i>=1;--i){t*=e;t+=a.a[i];F(j=l2b;j>=0;--j)
{d=b*pw22[j];if(t>=d)    {c.a[i]+=pw22[j];t-=d;}}}while(c.a[0]>1&&c.a[c.a[0]]==0) --c.a[0];R c;}
B& O/=(B& a,C B& b){a=a/b;R a;}
B O/(C B& a,int x){B c=a;c/=x;R c;}
B& O/=(B& a,int x){X i;LL t=0;F(i=a.a[0];i>=1;--i)
{t*=e;t+=a.a[i];a.a[i]=t/x;t%=x;}while(a.a[0]>1&&a.a[a.a[0]]==0) --a.a[0];R a;}
B O%(C B& a,C B& b){B t=z,d;X i,j;
F(i=a.a[0];i>=1;--i){t=t*e+a.a[i];F(j=l2b;j>=0;--j){d=b*pw22[j];if(t>=d)t-=d;}}R t;}

B gcd(B a,B b){B c=one,t;while(a!=b){if(a<b) {t=a;a=b;b=t;}if(a.odd()&&b.odd())    a-=b;
else if(a.odd()) b/=2;else if(b.odd())a/=2;else a/=2,b/=2,c*=2;}R a*c;}
B x[3];char str[10010];
int main()
{
    scanf("%s",str+1);x[0]=str+1;
    scanf("%s",str+1);x[1]=str+1;
    (x[0]+x[1]).println();
    if(x[0]>=x[1])
        (x[0]-x[1]).println();
    else
        putchar('-'),(x[1]-x[0]).println();
    (x[0]*x[1]).println();
    (x[0]/x[1]).println();
    (x[0]%x[1]).println();
    R 0;
}

压行版本：

//#pragma GCC optimize(3)
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
typedef int B_INT;
#define p_c "%05d"
#define i_c "%d"
#define b_c "100000"
const B_INT p=5,base=100000;
const int maxl=4000,l2b=16;
struct Bigint{
B_INT a[maxl];
Bigint(){memset(a,0,sizeof(a));}
Bigint(const char *str){*this=str;}
Bigint(const Bigint& b){memcpy(a,b.a,sizeof(a));}
Bigint(int x){*this=x;}
Bigint& operator=(const Bigint& b){memcpy(a,b.a,sizeof(a));return *this;}
Bigint& operator=(int x){memset(a,0,sizeof(a));do{a[++a[0]]=x%base;x/=base;}while(x);return *this;}
Bigint& operator=(const char *str){memset(a,0,sizeof(a));B_INT k=0,p=1;char *str1=(char*)(str+strlen(str)-1);
while(str1>=str){k=k+p*(*str1-48);if(p==base){a[++a[0]]=k%base;k/=base;p=1;}--str1;p*=10;}a[++a[0]]=k;return *this;}
void print() const{printf(i_c,a[a[0]]);for(B_INT i=a[0]-1;i>0;i--)printf(p_c,a[i]);}
void println() const{print();puts("");}
void println(const char* x) const{print();puts(x);}
bool odd() const{return a[1]&1;}};
LL buf[maxl<<1];const Bigint zero=0,one=1;
const B_INT pw22[]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576};
bool operator<(const Bigint& a,const Bigint& b){if(a.a[0]!=b.a[0])return a.a[0]<b.a[0];
for(B_INT i=a.a[0];i>0;i--)if(a.a[i]!=b.a[i])return a.a[i]<b.a[i];return 0;}
bool operator>(const Bigint& a,const Bigint& b){return b<a;}
bool operator<=(const Bigint& a,const Bigint& b){return !(b<a);}
bool operator>=(const Bigint& a,const Bigint& b){return !(a<b);}
bool operator==(const Bigint& a,const Bigint& b){if(a.a[0]!=b.a[0])return 0;
for(B_INT i=a.a[0];i>0;--i)if(a.a[i]!=b.a[i])return 0;return 1;}
bool operator!=(const Bigint& a,const Bigint& b){return !(a==b);}
Bigint& operator+=(Bigint& a,const Bigint& b){B_INT i;a.a[0]=max(a.a[0],b.a[0]);
for(i=1;i<=a.a[0];i++){a.a[i]+=b.a[i];a.a[i+1]+=a.a[i]/base;a.a[i]%=base;}if(a.a[a.a[0]+1]>0) a.a[0]++;return a;}
Bigint operator+(const Bigint& a,const Bigint& b){Bigint c=a;c+=b;return c;}
Bigint operator+(const Bigint& a,int x){Bigint c=a;c+=x;return c;}
Bigint& operator+=(Bigint& a,int x){B_INT i;a.a[1]+=x;
for(i=1;i<=a.a[0];++i)if(a.a[i]>=base){++a.a[i+1];a.a[i]-=base;}else    break;
if(a.a[a.a[0]+1]>0) ++a.a[0];return a;}
Bigint& operator-=(Bigint &a,const Bigint &b){B_INT i;a.a[0]=std::max(a.a[0],b.a[0]);
for(i=1;i<=a.a[0];++i)a.a[i]-=b.a[i];for(i=1;i<=a.a[0];++i)if(a.a[i]<0){a.a[i]+=base;a.a[i+1]--;}
while(a.a[a.a[0]]==0&&a.a[0]>1)--a.a[0];return a;}
Bigint operator-(const Bigint& a,const Bigint& b){Bigint c=a;c-=b;return c;}
Bigint& operator*=(Bigint& a,const Bigint& b){B_INT i,j;if(a==zero||b==zero){a=zero;return a;}
memset(buf,0,sizeof(buf));for(i=1;i<=a.a[0];i++)for(j=1;j<=b.a[0];j++)buf[i+j-1]+=(LL)a.a[i]*b.a[j];
buf[0]=a.a[0]+b.a[0]-1;for(i=1;i<=buf[0];++i){buf[i+1]+=buf[i]/base;a.a[i]=buf[i]%base;}
a.a[0]=buf[0];if(buf[buf[0]+1]>0) {a.a[++a.a[0]]=buf[buf[0]+1];}return a;}
Bigint operator*(const Bigint& a,const Bigint& b){Bigint c=a;c*=b;return c;}
Bigint operator*(const Bigint& a,int x){Bigint c=a;c*=x;return c;}
Bigint& operator*=(Bigint& a,int x){if(x==0)    {a=zero;return a;}B_INT i;memset(buf,0,sizeof(buf));
for(i=1;i<=a.a[0];++i)  buf[i]=(LL)a.a[i]*x;for(i=1;i<=a.a[0];++i)  {a.a[i]=buf[i]%base;buf[i+1]+=buf[i]/base;}
if(buf[a.a[0]+1]>0)    {++a.a[0];a.a[a.a[0]]=buf[a.a[0]];}return a;}
Bigint operator/(const Bigint& a,const Bigint& b){if(a<b) return zero;Bigint t=zero,c,d;
c.a[0]=a.a[0]-b.a[0]+1;B_INT i,j;for(i=a.a[0];i>=1;--i){t*=base;t+=a.a[i];for(j=l2b;j>=0;--j)
{d=b*pw22[j];if(t>=d)    {c.a[i]+=pw22[j];t-=d;}}}while(c.a[0]>1&&c.a[c.a[0]]==0) --c.a[0];return c;}
Bigint& operator/=(Bigint& a,const Bigint& b){a=a/b;return a;}
Bigint operator/(const Bigint& a,int x){Bigint c=a;c/=x;return c;}
Bigint& operator/=(Bigint& a,int x){B_INT i;LL t=0;for(i=a.a[0];i>=1;--i)
{t*=base;t+=a.a[i];a.a[i]=t/x;t%=x;}while(a.a[0]>1&&a.a[a.a[0]]==0) --a.a[0];return a;}
Bigint operator%(const Bigint& a,const Bigint& b){Bigint t=zero,d;B_INT i,j;
for(i=a.a[0];i>=1;--i){t=t*base+a.a[i];for(j=l2b;j>=0;--j){d=b*pw22[j];if(t>=d)t-=d;}}return t;}

Bigint gcd(Bigint a,Bigint b){Bigint c=one,t;while(a!=b){if(a<b) {t=a;a=b;b=t;}if(a.odd()&&b.odd())    a-=b;
else if(a.odd()) b/=2;else if(b.odd())a/=2;else a/=2,b/=2,c*=2;}return a*c;}
Bigint x[3];char str[10010];
int main()
{
    scanf("%s",str+1);x[0]=str+1;
    scanf("%s",str+1);x[1]=str+1;
    (x[0]+x[1]).println();
    if(x[0]>=x[1])
        (x[0]-x[1]).println();
    else
        putchar('-'),(x[1]-x[0]).println();
    (x[0]*x[1]).println();
    (x[0]/x[1]).println();
    (x[0]%x[1]).println();
    return 0;
}

带注释版本：

//#pragma GCC optimize(3)//O3
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
typedef int B_INT;
#define p_c "%05d"
#define i_c "%d"
#define b_c "100000"
//const char p_c[]="%08lld";
//const char i_c[]="%lld";
//const char b_c[]="100000000";
const B_INT p=5;//压p位,int压4位加乘法可能导致溢出,longlong压8位乘法会炸而且慢
const B_INT base=100000;//压p位，最大数为10^p-1
const int maxl=4000;
//const B_INT l2b=17;//=向上取整(log2(base))
const B_INT l2b=16;//=向下取整(log2(base))
struct Bigint
{
/*
基本类型（char,int,float,double等）的静态成员可以在类里面声明并初始化，
非基本类（char[],string ,自定义等）必须在类里面声明，类外初始化。
*/
    B_INT a[maxl];//a[0]->len,a[i]->从后往前数第i个p位
    Bigint(){memset(a,0,sizeof(a));}
    Bigint(const char *str){*this=str;}
    Bigint(const Bigint& b){memcpy(a,b.a,sizeof(a));}
    Bigint(int x){*this=x;}

    Bigint& operator=(const Bigint& b){memcpy(a,b.a,sizeof(a));return *this;}
    Bigint& operator=(int x)
    {
        memset(a,0,sizeof(a));
        do{a[++a[0]]=x%base;x/=base;}while(x);
        return *this;
    }
    Bigint& operator=(const char *str)
    {
        memset(a,0,sizeof(a));
        B_INT k=0,p=1;char *str1=(char*)(str+strlen(str)-1);
        while(str1>=str)
        {
            k=k+p*(*str1-48);
            if(p==base){a[++a[0]]=k%base;k/=base;p=1;}
            --str1;p*=10;
        }
        a[++a[0]]=k;
        return *this;
    }

    friend Bigint operator+(const Bigint&,const Bigint&);
    friend Bigint& operator+=(Bigint&,const Bigint&);
    friend Bigint operator+(const Bigint&,int x);
    friend Bigint& operator+=(Bigint&,int x);

    friend Bigint operator-(const Bigint&,const Bigint&);
    friend Bigint& operator-=(Bigint&,const Bigint&);

    friend Bigint operator*(const Bigint&,const Bigint&);
    friend Bigint& operator*=(Bigint&,const Bigint&);
    friend Bigint operator*(const Bigint&,int x);
    friend Bigint& operator*=(Bigint& a,int x);

    friend Bigint operator/(const Bigint&,const Bigint&);
    friend Bigint& operator/=(Bigint&,const Bigint&);
    friend Bigint operator/(const Bigint& a,int x);
    friend Bigint& operator/=(Bigint &,int);

    friend Bigint operator%(const Bigint&,const Bigint&);

    friend bool operator<(const Bigint& a,const Bigint& b);
    friend bool operator<=(const Bigint& a,const Bigint& b);
    friend bool operator>(const Bigint& a,const Bigint& b);
    friend bool operator>=(const Bigint& a,const Bigint& b);
    friend bool operator==(const Bigint& a,const Bigint& b);
    friend bool operator!=(const Bigint& a,const Bigint& b);

    void print() const
    {
        printf(i_c,a[a[0]]);
        for(B_INT i=a[0]-1;i>0;i--)
            printf(p_c,a[i]);
    }
    void println() const    {print();puts("");}
    void println(const char* x) const   {print();puts(x);}
    bool odd() const    {return a[1]&1;}
};
LL buf[maxl<<1];
const Bigint zero=0,one=1;
//const Bigint bas=base;
//const Bigint pw2[]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576};
const B_INT pw22[]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576};
bool operator<(const Bigint& a,const Bigint& b)
{
    if(a.a[0]!=b.a[0])
        return a.a[0]<b.a[0];
    for(B_INT i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]<b.a[i];
    return 0;//相等
}
/*
非静态成员函数后面加const（加到非成员函数或静态成员后面会产生编译错误），
表示成员函数隐含传入的this指针为 const指针，
决定了在该成员函数中，
任意修改它所在的类的成员的操作都是不允许的
（因为隐含了对this指针的const引用）；
唯一的例外是对于 mutable修饰的成员。
加了const的成员函数可以被非const对象和const对象调用，
但不加const的成员函数只能被非const对象调用。
下方b是const,const函数不能修改其数据成员
*/
bool operator>(const Bigint& a,const Bigint& b)
{
    return b<a;
    /*
    if(a.a[0]!=b.a[0])
        return a.a[0]>b.a[0];
    for(int i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]>b.a[i];
    return false;//相等
    */
}
bool operator<=(const Bigint& a,const Bigint& b)
{
    return !(b<a);
    /*
    if(a.a[0]!=b.a[0])
        return a.a[0]>b.a[0];
    for(int i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]>b.a[i];
    return true;//相等
    */
}
bool operator>=(const Bigint& a,const Bigint& b)
{
    return !(a<b);
    /*
    if(a.a[0]!=b.a[0])
        return a.a[0]>b.a[0];
    for(int i=a.a[0];i>0;i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]>b.a[i];
    return true;//相等
    */
}
bool operator==(const Bigint& a,const Bigint& b)
{
    if(a.a[0]!=b.a[0])
        return 0;
    for(B_INT i=a.a[0];i>0;--i)
        if(a.a[i]!=b.a[i])
            return 0;
    return 1;
}
bool operator!=(const Bigint& a,const Bigint& b)
{
    return !(a==b);
}
Bigint operator+(const Bigint& a,const Bigint& b){Bigint c=a;c+=b;return c;}
Bigint& operator+=(Bigint& a,const Bigint& b)
{
    B_INT i;
    a.a[0]=max(a.a[0],b.a[0]);
    for(i=1;i<=a.a[0];i++)
    {
        a.a[i]+=b.a[i];
        a.a[i+1]+=a.a[i]/base;
        a.a[i]%=base;
    }
    if(a.a[a.a[0]+1]>0) a.a[0]++;
    return a;
}
Bigint operator+(const Bigint& a,int x){Bigint c=a;c+=x;return c;}
Bigint& operator+=(Bigint& a,int x)//要求不超过base的小数字
{
    B_INT i;
    a.a[1]+=x;
    for(i=1;i<=a.a[0];++i)
        if(a.a[i]>=base)    {++a.a[i+1];a.a[i]-=base;}
        else    break;
    if(a.a[a.a[0]+1]>0) ++a.a[0];
    return a;
}
Bigint operator-(const Bigint& a,const Bigint& b){Bigint c=a;c-=b;return c;}
Bigint& operator-=(Bigint &a,const Bigint &b)//要求保证减数小于被减数
{
    B_INT i;
    a.a[0]=std::max(a.a[0],b.a[0]);
    for(i=1;i<=a.a[0];++i)    a.a[i]-=b.a[i];
    for(i=1;i<=a.a[0];++i)
        if(a.a[i]<0)    {a.a[i]+=base;a.a[i+1]--;}
    while(a.a[a.a[0]]==0&&a.a[0]>1)    --a.a[0];
    return a;
}
Bigint operator*(const Bigint& a,const Bigint& b){Bigint c=a;c*=b;return c;}
Bigint& operator*=(Bigint& a,const Bigint& b)
{
    B_INT i,j;
    if(a==zero||b==zero)    {a=zero;return a;}
    memset(buf,0,sizeof(buf));
    for(i=1;i<=a.a[0];i++)
        for(j=1;j<=b.a[0];j++)
            buf[i+j-1]+=(LL)a.a[i]*b.a[j];//注意(LL)
    buf[0]=a.a[0]+b.a[0]-1;
    //buf[buf[0]+1]=0
    for(i=1;i<=buf[0];++i)
    {
        buf[i+1]+=buf[i]/base;
        a.a[i]=buf[i]%base;
    }
    a.a[0]=buf[0];
    if(buf[buf[0]+1]>0) {a.a[++a.a[0]]=buf[buf[0]+1];}
    return a;
}
Bigint operator*(const Bigint& a,int x){Bigint c=a;c*=x;return c;}
Bigint& operator*=(Bigint& a,int x)//要求不超过base的小数字
{
    if(x==0)    {a=zero;return a;}
    B_INT i;
    //a[a[0]+1]=0
    memset(buf,0,sizeof(buf));
    for(i=1;i<=a.a[0];++i)
    {
        //printf("%d %d
",i,a.a[i]);
        buf[i]=(LL)a.a[i]*x;//注意LL
        //a.a[i+1]+=buf[0]/base;
        //a.a[i]=buf[i]%base;//printf("%daa
",a.a[i]);
    }
    for(i=1;i<=a.a[0];++i)
    {
        //printf("%lldss
",buf[i]);
        a.a[i]=buf[i]%base;
        buf[i+1]+=buf[i]/base;
    }
    //if(a.a[a.a[0]+1]>0)    ++a.a[0];
    //if(buf[buf[0]+1]>0) {a.a[++a.a[0]]=buf[buf[0]+1];}
    if(buf[a.a[0]+1]>0)    {++a.a[0];a.a[a.a[0]]=buf[a.a[0]];}
    return a;
}
Bigint operator/(const Bigint& a,const Bigint& b)
{
    if(a<b) return zero;//必须加这句
    Bigint t=zero,c,d;c.a[0]=a.a[0]-b.a[0]+1;
    B_INT i,j;
    for(i=a.a[0];i>=1;--i)
    {
       t*=base;t+=a.a[i];
       for(j=l2b;j>=0;--j)
       {
           d=b*pw22[j];
           if(t>=d)    {c.a[i]+=pw22[j];t-=d;}
       }
       //printf("%dt2
",c.a[i]);
    }
    while(c.a[0]>1&&c.a[c.a[0]]==0) --c.a[0];
    return c;
}
Bigint& operator/=(Bigint& a,const Bigint& b){a=a/b;return a;}
Bigint operator/(const Bigint& a,int x){Bigint c=a;c/=x;return c;}
Bigint& operator/=(Bigint& a,int x)//要求不超过base的小数字
{
    B_INT i;LL t=0;
    for(i=a.a[0];i>=1;--i)
    {
        t*=base;t+=a.a[i];// int xx;printf("%lldkfk
",t);
        a.a[i]=t/x;//printf("%dkfk
",a.a[i]);scanf("%d",&xx);
        t%=x;
    }
    while(a.a[0]>1&&a.a[a.a[0]]==0) --a.a[0];
    return a;
}
Bigint operator%(const Bigint& a,const Bigint& b)
{
    //return *this-*this/b*b;
    Bigint t=zero,d;
    B_INT i,j;
    for(i=a.a[0];i>=1;--i)
    {
        t=t*base+a.a[i];
        for(j=l2b;j>=0;--j)
        {
            d=b*pw22[j];
            if(t>=d)    t-=d;
        }
    }
    return t;
}

Bigint x[3];
char str[10010];
Bigint gcd(Bigint a,Bigint b)
{
    Bigint c=one,t;
    while(a!=b)
    {
        if(a<b) {t=a;a=b;b=t;}
        //(a/2).println("k2");
        //a.print();puts("a");b.print();puts("b");puts("");
        if(a.odd()&&b.odd())  a-=b;
        else    if(a.odd())
            b/=2;
        else if(b.odd())
            a/=2;
        else
            a/=2,b/=2,c*=2;
        //a.print();puts("a2");b.print();puts("b2");puts("");c.println("c2");int t;scanf("%d",&t);
    }
    return a*c;
}
//Bigint gcd(Bigint a,Bigint b)
//{
//    Bigint t;
//    static Bigint zero=0;
//    while(b!=zero)
//    {
//        t=a;
//        a=b;
//        b=t%b;
//    }
//    return a;
//}
int main()
{
    //(Bigint("13582583")*15345).print();
    //(Bigint("3948636459042352478494043859377305164061320248669026579423660")).println();
    //(Bigint("3948636459042352478494043859377305164061320248669026579423660")/Bigint("2")).println();
    scanf("%s",str+1);x[0]=str+1;
    scanf("%s",str+1);x[1]=str+1;
    //(gcd(x[0],x[1])).print();;
    (x[0]/x[1]).print();
    //(x[0]*x[1]).print();
    //(Bigint("8392523")%Bigint("5")).print();
    //printf("
%d",(Bigint("233")-Bigint("233"))==Bigint("1"));
//    scanf("%s",str);
//    x[0]=str;
//    scanf("%s",str);
//    x[1]=str;
//  if(x[0]<x[1])
//  {
//      printf("-");
//      x[2]=x[0];
//      x[0]=x[1];
//      x[1]=x[2];
//  }
//  (x[0]-x[1]).print();
//  (x[0]*x[1]).print();
//    printf("%d",x[0]>x[1]);
//    (x[1]=x[1]).print();
//  puts("");
//  x[0].print();
//  puts("");
//  x[1].print();
    return 0;
}

---

 （比较）简单的版本：

#include<cstdio>
#include<cstring>
#include<algorithm>
struct Bigint
{
    #define p_c "%08lld"
    #define i_c "%lld"
    typedef long long B_INT;
    static const B_INT p=8;
    static const B_INT base=100000000;
    static const int maxl=3000;
    B_INT a[maxl];
    Bigint()
    {
        memset(a,0,sizeof(a));
    }
    Bigint(const char *str)
    {
        memset(a,0,sizeof(a));
        B_INT k=0,p=1;
        const char *str1=str+strlen(str)-1;
        while(str1>=str)
        {
            k=k+p*(*str1-48);
            if(p==base)
            {
                a[++a[0]]=k%base;
                k/=base;
                p=1;
            }
            str1--;
            p*=10;
        }
        a[++a[0]]=k;
    }
    Bigint(const Bigint& b)
    {
        memcpy(a,b.a,sizeof(a));
    }
    Bigint& operator=(const Bigint& b)
    {
        memcpy(a,b.a,sizeof(a));
        return *this;
    }
    Bigint& operator=(const char *str)
    {
        memset(a,0,sizeof(a));
        B_INT k=0,p=1;
        const char *str1=str+strlen(str)-1;
        while(str1>=str)
        {
            k=k+p*(*str1-48);
            if(p==base)
            {
                a[++a[0]]=k%base;
                k/=base;
                p=1;
            }
            str1--;
            p*=10;
        }
        a[++a[0]]=k;
        return *this;
    }
    Bigint operator+(const Bigint &b) const
    {
        Bigint c;
        B_INT i;
        c.a[0]=std::max(a[0],b.a[0]);
        for(i=1;i<=c.a[0];i++)
        {
            c.a[i]+=a[i]+b.a[i];
            c.a[i+1]=c.a[i]/base;
            c.a[i]%=base;
        }
        if(c.a[c.a[0]+1]>0)
            c.a[0]++;
        return c;
    }
    Bigint operator*(const Bigint &b) const
    {
        Bigint c;
        B_INT i,j;
        for(i=1;i<=a[0];i++)
            for(j=1;j<=b.a[0];j++)
                c.a[i+j-1]+=a[i]*b.a[j];
        c.a[0]=a[0]+b.a[0]-1;
        for(i=1;i<=c.a[0];i++)
        {
            c.a[i+1]+=c.a[i]/base;
            c.a[i]%=base;
        }
        if(c.a[c.a[0]+1]>0)
            c.a[0]++;
        return c;
    }
    Bigint operator-(const Bigint &b) const
    {
        Bigint c;
        B_INT i;
        c.a[0]=std::max(a[0],b.a[0]);
        for(i=1;i<=c.a[0];i++)
            c.a[i]=a[i]-b.a[i];
        for(i=1;i<=c.a[0];i++)
            if(c.a[i]<0)
            {
                c.a[i]+=base;
                c.a[i+1]--;
            }
        while(c.a[c.a[0]]==0&&c.a[0]>0)
            c.a[0]--;
        return c;
    }
    Bigint& operator+=(const Bigint &b)
    {
        *this=*this+b;
        return *this;
    }
    Bigint& operator-=(const Bigint &b)
    {
        *this=*this-b;
        return *this;
    }
    Bigint& operator*=(const Bigint &b)
    {
        *this=(*this)*b;
        return *this;
    }
    bool operator<(const Bigint &b) const
    {
        if(a[0]!=b.a[0])
            return a[0]<b.a[0];
        for(B_INT i=a[0];i>0;i--)
            if(a[i]!=b.a[i])
                return a[i]<b.a[i];
        return false;
    }
    bool operator>(const Bigint &b) const
    {
        return b<*this;
    }
    bool operator<=(const Bigint &b) const
    {
        return !(b<*this);
    }
    bool operator>=(const Bigint &b) const
    {
        return !(*this<b);
    }
    bool operator==(const Bigint &b) const
    {
        if(a[0]!=b.a[0])
            return false;
        for(B_INT i=a[0];i>0;i--)
            if(a[i]!=b.a[i])
                return false;
        return true;
    }
    bool operator!=(const Bigint &b) const
    {
        return !(*this==b);
    }
    void print()
    {
        printf(i_c,a[a[0]]);
        for(B_INT i=a[0]-1;i>0;i--)
            printf(p_c,a[i]);
    }
    #undef p_c
    #undef i_c
};
int main()
{
    return 0;
}

带说明版本:

#include<cstdio>
#include<cstring>
#include<algorithm>
typedef long long B_INT;
const char p_c[]="%08lld";
const char i_c[]="%lld";
struct Bigint
{
/*
基本类型（char,int,float,double等）的静态成员可以在类里面声明并初始化，
非基本类（char[],string ,自定义等）必须在类里面声明，类外初始化。
*/
    static const B_INT p=8;//压p位,int压4位加乘法可能导致溢出
    static const B_INT base=100000000;//压p位，最大数为10^p-1
    static const int maxl=3000;
    B_INT a[maxl];//a[0]->len,a[i]->从后往前数第i个p位
    Bigint()
    {
        memset(a,0,sizeof(a));
    }
//  Bigint(char *str)
//  {
//      memset(a,0,sizeof(a));
//      B_INT k=0,p=1;
//      char *str1=str+strlen(str)-1;
//      while(str1>=str)
//      {
//          k=k+p*(*str1-48);
//          if(p==base)
//          {
//              a[++a[0]]=k%base;
//              k/=base;
//              p=1;
//          }
//          str1--;
//          p*=10;
//      }
//      a[++a[0]]=k;
//  }
    Bigint(const Bigint& b)
    {
        memcpy(a,b.a,sizeof(a));
    }
    Bigint& operator=(const Bigint& b)
    {
        memcpy(a,b.a,sizeof(a));
        return *this;
    }
    Bigint& operator=(char *str)
    {
        memset(a,0,sizeof(a));
        B_INT k=0,p=1;
        char *str1=str+strlen(str)-1;
        while(str1>=str)
        {
            k=k+p*(*str1-48);
            if(p==base)
            {
                a[++a[0]]=k%base;
                k/=base;
                p=1;
            }
            str1--;
            p*=10;
        }
        a[++a[0]]=k;
        return *this;
    }
    Bigint operator+(const Bigint &b) const
    {
        Bigint c;
        B_INT i;
        c.a[0]=std::max(a[0],b.a[0]);
        for(i=1;i<=c.a[0];i++)
        {
            c.a[i]+=a[i]+b.a[i];
            c.a[i+1]=c.a[i]/base;
            c.a[i]%=base;
        }
        if(c.a[c.a[0]+1]>0)
            c.a[0]++;
        return c;
    }
    Bigint operator*(const Bigint &b) const
    {
        Bigint c;
        B_INT i,j;
        for(i=1;i<=a[0];i++)
            for(j=1;j<=b.a[0];j++)
                c.a[i+j-1]+=a[i]*b.a[j];
        c.a[0]=a[0]+b.a[0]-1;
        for(i=1;i<=c.a[0];i++)
        {
            c.a[i+1]+=c.a[i]/base;
            c.a[i]%=base;
        }
        if(c.a[c.a[0]+1]>0)
            c.a[0]++;
        return c;
    }
    Bigint operator-(const Bigint &b) const//要求保证减数小于被减数
    {
        Bigint c;
        B_INT i;
        c.a[0]=std::max(a[0],b.a[0]);
        for(i=1;i<=c.a[0];i++)
            c.a[i]=a[i]-b.a[i];
        for(i=1;i<=c.a[0];i++)
            if(c.a[i]<0)
            {
                c.a[i]+=base;
                c.a[i+1]--;
            }
        while(c.a[c.a[0]]==0&&c.a[0]>0)
            c.a[0]--;
        return c;
    }
    Bigint& operator+=(const Bigint &b)
    {
        *this=*this+b;
        return *this;
    }
    Bigint& operator-=(const Bigint &b)
    {
        *this=*this-b;
        return *this;
    }
    Bigint& operator*=(const Bigint &b)
    {
        *this=(*this)*b;
        return *this;
    }
    bool operator<(const Bigint &b) const
    {
        if(a[0]!=b.a[0])
            return a[0]<b.a[0];
        for(B_INT i=a[0];i>0;i--)
            if(a[i]!=b.a[i])
                return a[i]<b.a[i];
        return false;//相等
    }
    /*
    非静态成员函数后面加const（加到非成员函数或静态成员后面会产生编译错误），
    表示成员函数隐含传入的this指针为 const指针，
    决定了在该成员函数中，
    任意修改它所在的类的成员的操作都是不允许的
    （因为隐含了对this指针的const引用）；
    唯一的例外是对于 mutable修饰的成员。
    加了const的成员函数可以被非const对象和const对象调用，
    但不加const的成员函数只能被非const对象调用。
    下方b是const,const函数不能修改其数据成员
    */
    bool operator>(const Bigint &b) const
    {
        return b<*this;
        /*
        if(a[0]!=b.a[0])
            return a[0]>b.a[0];
        for(int i=a[0];i>0;i--)
            if(a[i]!=b.a[i])
                return a[i]>b.a[i];
        return false;//相等
        */
    }
    bool operator<=(const Bigint &b) const
    {
        return !(b<*this);
        /*
        if(a[0]!=b.a[0])
            return a[0]>b.a[0];
        for(int i=a[0];i>0;i--)
            if(a[i]!=b.a[i])
                return a[i]>b.a[i];
        return true;//相等
        */
    }
    bool operator>=(const Bigint &b) const
    {
        return !(*this<b);
        /*
        if(a[0]!=b.a[0])
            return a[0]>b.a[0];
        for(int i=a[0];i>0;i--)
            if(a[i]!=b.a[i])
                return a[i]>b.a[i];
        return true;//相等
        */
    }
    bool operator==(const Bigint &b) const
    {
        if(a[0]!=b.a[0])
            return false;
        for(B_INT i=a[0];i>0;i--)
            if(a[i]!=b.a[i])
                return false;
        return true;
    }
    bool operator!=(const Bigint &b) const
    {
        return !(*this==b);
    }
    void print()
    {
        printf(i_c,a[a[0]]);
        for(B_INT i=a[0]-1;i>0;i--)
            printf(p_c,a[i]);
    }
}x[3];
char str[10010];
int main()
{
    scanf("%s",str);
    x[0]=str;
    scanf("%s",str);
    x[1]=str;
//  if(x[0]<x[1])
//  {
//      printf("-");
//      x[2]=x[0];
//      x[0]=x[1];
//      x[1]=x[2];
//  }
//  (x[0]-x[1]).print();
//  (x[0]*x[1]).print();
    //printf("%d",x[0]>x[1]);
    (x[1]=x[1]).print();
//  puts("");
//  x[0].print();
//  puts("");
//  x[1].print();
    return 0;
}

old2:

#include<cstdio>
#include<cstring>
#include<algorithm>
typedef long long B_INT;
const char p_c[]="%08lld";
const char i_c[]="%lld";
struct Bigint
{
/*
基本类型（char,int,float,double等）的静态成员可以在类里面声明并初始化，
非基本类（char[],string ,自定义等）必须在类里面声明，类外初始化。
*/
	static const B_INT p=8;//压p位,int压4位加乘法可能导致溢出
	static const B_INT base=100000000;//压p位，最大数为10^p-1
	static const int maxl=3000;
	B_INT a[maxl];//a[0]->len,a[i]->从后往前数第i个p位
	Bigint()
	{
		memset(a,0,sizeof(a));
	}
//	Bigint(char *str)
//	{
//		memset(a,0,sizeof(a));
//		B_INT k=0,p=1;
//		char *str1=str+strlen(str)-1;
//		while(str1>=str)
//		{
//			k=k+p*(*str1-48);
//			if(p==base)
//			{
//				a[++a[0]]=k%base;
//				k/=base;
//				p=1;
//			}
//			str1--;
//			p*=10;
//		}
//		a[++a[0]]=k;
//	}
	Bigint(const Bigint& b)
	{
		memcpy(a,b.a,sizeof(a));
	}
	Bigint& operator=(const Bigint& b)
	{
		memcpy(a,b.a,sizeof(a));
	}
	Bigint& operator=(char *str)
	{
		memset(a,0,sizeof(a));
		B_INT k=0,p=1;
		char *str1=str+strlen(str)-1;
		while(str1>=str)
		{
			k=k+p*(*str1-48);
			if(p==base)
			{
				a[++a[0]]=k%base;
				k/=base;
				p=1;
			}
			str1--;
			p*=10;
		}
		a[++a[0]]=k;
		return *this;
	}
	Bigint operator+(const Bigint &b) const
	{
		Bigint c;
		B_INT i;
		c.a[0]=std::max(a[0],b.a[0]);
		for(i=1;i<=c.a[0];i++)
		{
			c.a[i]+=a[i]+b.a[i];
			c.a[i+1]=c.a[i]/base;
			c.a[i]%=base;
		}
		if(c.a[c.a[0]+1]>0)
			c.a[0]++;
		return c;
	}
	Bigint operator*(const Bigint &b) const
	{
		Bigint c;
		B_INT i,j;
		for(i=1;i<=a[0];i++)
			for(j=1;j<=b.a[0];j++)
				c.a[i+j-1]+=a[i]*b.a[j];
		c.a[0]=a[0]+b.a[0]-1;
		for(i=1;i<=c.a[0];i++)
		{
			c.a[i+1]+=c.a[i]/base;
			c.a[i]%=base;
		}
		if(c.a[c.a[0]+1]>0)
			c.a[0]++;
		return c;
	}
	Bigint operator-(const Bigint &b) const//要求保证减数小于被减数 
	{
		Bigint c;
		B_INT i;
		c.a[0]=std::max(a[0],b.a[0]);
		for(i=1;i<=c.a[0];i++)
			c.a[i]=a[i]-b.a[i];
		for(i=1;i<=c.a[0];i++)
			if(c.a[i]<0)
			{
				c.a[i]+=base;
				c.a[i+1]--;
			}
		while(c.a[c.a[0]]==0&&c.a[0]>0)
			c.a[0]--;
		return c;
	}
	Bigint& operator+=(const Bigint &b)
	{
		*this=*this+b;
		return *this;
	}
	Bigint& operator-=(const Bigint &b)
	{
		*this=*this-b;
		return *this;
	}
	Bigint& operator*=(const Bigint &b)
	{
		*this=(*this)*b;
		return *this;
	}
	bool operator<(const Bigint &b) const
	{
		if(a[0]!=b.a[0])
			return a[0]<b.a[0];
		for(B_INT i=a[0];i>0;i--)
			if(a[i]!=b.a[i])
				return a[i]<b.a[i];
		return false;//相等
	}
	/*
	非静态成员函数后面加const（加到非成员函数或静态成员后面会产生编译错误），
	表示成员函数隐含传入的this指针为 const指针，
	决定了在该成员函数中，
	任意修改它所在的类的成员的操作都是不允许的
	（因为隐含了对this指针的const引用）；
	唯一的例外是对于 mutable修饰的成员。
	加了const的成员函数可以被非const对象和const对象调用，
	但不加const的成员函数只能被非const对象调用。
	下方b是const,const函数不能修改其数据成员
	*/
	bool operator>(const Bigint &b) const
	{
		return b<*this;
		/*
		if(a[0]!=b.a[0])
			return a[0]>b.a[0];
		for(int i=a[0];i>0;i--)
			if(a[i]!=b.a[i])
				return a[i]>b.a[i];
		return false;//相等
		*/
	}
	bool operator<=(const Bigint &b) const
	{
		return !(b<*this);
		/*
		if(a[0]!=b.a[0])
			return a[0]>b.a[0];
		for(int i=a[0];i>0;i--)
			if(a[i]!=b.a[i])
				return a[i]>b.a[i];
		return true;//相等
		*/
	}
	bool operator>=(const Bigint &b) const
	{
		return !(*this<b);
		/*
		if(a[0]!=b.a[0])
			return a[0]>b.a[0];
		for(int i=a[0];i>0;i--)
			if(a[i]!=b.a[i])
				return a[i]>b.a[i];
		return true;//相等
		*/
	}
	bool operator==(const Bigint &b) const
	{
		if(a[0]!=b.a[0])
			return false;
		for(B_INT i=a[0];i>0;i--)
			if(a[i]!=b.a[i])
				return false;
		return true;
	}
	bool operator!=(const Bigint &b) const
	{
		return !(*this==b);
	}
	void print()
	{
		printf(i_c,a[a[0]]);
		for(B_INT i=a[0]-1;i>0;i--)
			printf(p_c,a[i]);
	}
}x[3];
char str[10010];
int main()
{
	scanf("%s",str);
	x[0]=str;
	scanf("%s",str);
	x[1]=str;
//	if(x[0]<x[1])
//	{
//		printf("-");
//		x[2]=x[0];
//		x[0]=x[1];
//		x[1]=x[2];
//	}
//	(x[0]-x[1]).print();
//	(x[0]*x[1]).print();
	//printf("%d",x[0]>x[1]);
	(x[1]=x[1]).print();
//	puts("");
//	x[0].print();
//	puts("");
//	x[1].print();
	return 0;
}