玄关求条

#include<bits/stdc++.h>
using namespace std;
struct CP {
    CP(double xx=0, double yy=0){x=xx,y=yy;}
    double x,y;
    CP operator+(CP const &B)const{return CP(x+B.x,y+B.y);}
    CP operator-(CP const &B)const{return CP(x-B.x,y-B.y);}
    CP operator*(CP const &B)const{return CP(x*B.x-y*B.y,x*B.y+y*B.x);}
};
const int MAXN=1<<21;
const double Pi=acos(-1)*2;
CP a[MAXN],b[MAXN];
CP f[MAXN],g[MAXN];
int tr[MAXN];
void fft(CP *f, int n, bool flag){
    for (int i=0;i<n;++i) if (i<tr[i]) swap(f[i],f[tr[i]]);
    for(int p=2;p<=n;p<<=1){
        int len=p>>1;
        CP tG(cos(2*Pi/p),sin(2*Pi/p));
        if(!flag) tG.y*=-1;
        for(int k=0;k<n;k+=p){
            CP buf(1,0);
            for(int l=k;l<k+len;l++){
                CP tt=buf*f[len+l];
                f[len+l]=f[l]-tt;
                f[l]=f[l]+tt;
                buf=buf*tG;
            }
        }
    }
}
namespace Int1024 {
    typedef long long ll;
    typedef unsigned long long ull;
    
    class __int256 {
    private:
        const static int N=1000000, base=1e8;
        int a[N],len,neg;
        
        void write(int _a)const{
            if(_a>9)write(_a/10);
            putchar((_a%10)|48);
        }
        
        int getlen(int _a)const{
            int ans=0;
            while(_a)_a/=10,++ans;
            return ans;
        }
        
    public:
        __int256(){len=1,neg=0,memset(a,0,sizeof(a));}
        
        __int256(char *s){
            memset(a,0,sizeof(a));
            int k=1;
            if(s[0]=='-'){
                int slen=strlen(s)-1;
                len=1,neg=1;
                for(int i=1;i<=slen;++i){
                    if(k==base)++len,k=1;
                    a[len]+=k*(s[slen-i+1]^48);
                    k*=10;
                }
            }else{
                int slen=strlen(s);
                len=1,neg=0;
                for(int i=1;i<=slen;++i){
                    if(k==base)++len,k=1;
                    a[len]+=k*(s[slen-i]^48);
                    k*=10;
                }
            }
        }
        
        __int256(string s){
            memset(a,0,sizeof(a));
            int k=1;
            if(s[0]=='-'){
                int slen=s.size()-1;
                len=1,neg=1;
                for(int i=1;i<=slen;++i){
                    if(k==base)++len,k=1;
                    a[len]+=k*(s[slen-i+1]^48);
                    k*=10;
                }
            }else{
                int slen=s.size();
                len=1,neg=0;
                for(int i=1;i<=slen;++i){
                    if(k==base)++len,k=1;
                    a[len]+=k*(s[slen-i]^48);
                    k*=10;
                }
            }
        }
        
        __int256(const char *s){
            memset(a,0,sizeof(a));
            int k=1;
            if(s[0]=='-'){
                int slen=strlen(s)-1;
                len=1,neg=1;
                for(int i=1;i<=slen;++i){
                    if(k==base)++len,k=1;
                    a[len]+=k*(s[slen-i+1]^48);
                    k*=10;
                }
            }else{
                int slen=strlen(s);
                len=1,neg=0;
                for(int i=1;i<=slen;++i){
                    if(k==base)++len,k=1;
                    a[len]+=k*(s[slen-i]^48);
                    k*=10;
                }
            }
        }
        
        template<typename _Tp>
        __int256(_Tp x){
            memset(a,0,sizeof(a));
            if(x<0)x=-x,neg=1;
            len=0;
            int tmp;
            while((tmp=x/base))a[++len]=x%base,x=tmp;
            a[++len]=x;
        }
        
        void get(){
            int tot=0;
            char s[100001];
            char ch=getchar();
            while(ch<'0'||ch>'9'){
                if(ch=='-'&&tot==0)s[tot++]='-';
                ch=getchar();
            }
            while(ch>='0'&&ch<='9')s[tot++]=ch,ch=getchar();
            *this=__int256(s);
        }
        
        void print()const{
            int baselen=getlen(base)-1;
            if(neg)putchar('-');
            write(a[len]);
            for(int i=len-1,tmp;i;--i){
                tmp=baselen-getlen(a[i]);
                while(tmp--)putchar('0');
                write(a[i]);
            }
        }
        
        friend istream& operator>>(istream& input,__int256& x){
            x.get();
            return input;
        }
        
        friend ostream& operator<<(ostream& output,const __int256& x){
            x.print();
            return output;
        }
        
        bool operator==(const __int256& x)const{
            if(len!=x.len||neg!=x.neg)return false;
            for(int i=1;i<=len;++i)if(a[i]!=x.a[i])return false;
            return true;
        }
        
        bool operator!=(const __int256& x)const{return !(*this==x);}
        
        bool operator>(const __int256& x)const{
            if(neg!=x.neg)return x.neg;
            if(len!=x.len)return len>x.len;
            for(int i=len;i;--i)if(a[i]!=x.a[i])return a[i]>x.a[i];
            return false;
        }
        
        bool operator<(const __int256& x)const{
            if(neg!=x.neg)return neg;
            if(len!=x.len)return len<x.len;
            for(int i=len;i;--i)if(a[i]!=x.a[i])return a[i]<x.a[i];
            return false;
        }
        
        bool operator>=(const __int256& x)const{return !(*this<x);}
        bool operator<=(const __int256& x)const{return !(*this>x);}
        
        __int256 operator-()const{
            __int256 x(*this);
            x.neg^=1;
            return x;
        }
        
        __int256 operator+(const __int256& x)const{
            if((!neg)&&x.neg)return *this-(-x);
            if(neg&&(!x.neg))return x-(-*this);
            __int256 ans;
            ans.len=max(len,x.len);
            for(int i=1;i<=ans.len;++i){
                ans.a[i]+=a[i]+x.a[i];
                if(ans.a[i]>=base)ans.a[i]-=base,++ans.a[i+1];
            }
            if(ans.a[ans.len+1])++ans.len;
            if(neg&&x.neg)ans.neg=1;
            return ans;
        }
        
        __int256 operator+=(const __int256& x){return *this=*this+x;}
        
        __int256 operator-(const __int256& x)const{
            if((!neg)&&x.neg)return *this+(-x);
            if(neg&&x.neg)return (-x)-(-*this);
            if(neg&&(!x.neg))return -((-*this)+x);
            __int256 ans;
            if(*this==x)return ans;
            if(x>*this){
                ans=(x-*this);
                ans.neg=1;
                return ans;
            }
            ans.len=max(len,x.len);
            for(int i=1;i<=ans.len;++i){
                ans.a[i]+=a[i]-x.a[i];
                if(ans.a[i]<0)ans.a[i]+=base,--ans.a[i+1];
            }
            while(ans.len&&!ans.a[ans.len])--ans.len;
            return ans;
        }
        
        __int256 operator-=(const __int256& x){return *this=*this-x;}
        
        __int256 operator*(const __int256& x)const {
            __int256 ans;
            if(*this==ans||x==ans)return ans;
            
            if(len<32||x.len<32){
                if(neg!=x.neg)ans.neg=1;
                ans.len=max(len,x.len);
                ull tmp;
                for(int i=1;i<=len;++i)
                    for(int j=1;j<=x.len;++j){
                        tmp=1ull*a[i]*x.a[j]+ans.a[i+j-1];
                        if(tmp>=base){
                            ans.a[i+j]+=tmp/base;
                            ans.a[i+j-1]=tmp%base;
                        }else ans.a[i+j-1]=tmp;
                    }
                while(ans.a[ans.len]>0)++ans.len;
                --ans.len;
                return ans;
            }
            int n=1,bit=0;
            while(n<len+x.len)n<<=1,bit++;
            for(int i=0;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)<<(bit-1));
            
            memset(f,0,sizeof(CP)*n);
            memset(g,0,sizeof(CP)*n);
            for(int i=0;i<len;++i)f[i].x=a[i+1];
            for(int i=0;i<x.len;++i)g[i].x=x.a[i+1];
            
            fft(f,n,1);
            fft(g,n,1);
            for(int i=0;i<n;++i)f[i]=f[i]*g[i];
            fft(f,n,0);
            
            if(neg!=x.neg)ans.neg=1;
            ull carry=0;
            for(int i=0;i<n||carry;++i){
                carry+=(ull)(f[i].x/n+0.5);
                if(i>=n && carry==0)break;
                ans.a[i+1]=carry%base;
                carry/=base;
                ans.len=i+1;
            }
            while(ans.len>1&&!ans.a[ans.len])--ans.len;
            return ans;
        }
        
        __int256 operator*=(const __int256& x){return *this=*this*x;}
        
        __int256 operator/(const __int256& X)const{
            // if(X==__int256(0))cerr<<"Error:divide 0\n",exit(-1);
            __int256 ans(*this),x(X),tmp(1),lt;
            if(neg!=x.neg)ans.neg=1;
            while(ans>=x)x*=2,tmp*=2;
            while(tmp.len>1||tmp.a[1]){
                if(ans>=x)ans-=x,lt+=tmp;
                x/=2,tmp/=2;
            }
            ans=lt;
            while(ans.len&&!ans.a[ans.len])--ans.len;
            if(!ans.len)return __int256();
            return ans;
        }
        
        __int256 operator/=(const __int256& X){
            // if(X==__int256(0))cerr<<"Error:divide 0\n",exit(-1);
            __int256 x(X),tmp(1),lt;
            if(neg!=x.neg)neg=1;
            else neg=0;
            while(*this>=x)x*=2,tmp*=2;
            while(tmp.len>1||tmp.a[1]){
                if(*this>=x)*this-=x,lt+=tmp;
                x/=2,tmp/=2;
            }
            *this=lt;
            while(len&&!a[len])--len;
            if(!len)*this=__int256();
            return *this;
        }
        
        __int256 operator%(const __int256& X)const{
            // if(X==__int256(0))cerr<<"Error:mod 0\n",exit(-1);
            __int256 ans(*this),x(X),tmp(1),lt;
            if(neg!=x.neg)ans.neg=1;
            while(ans>=x)x*=2,tmp*=2;
            while(tmp.len>1||tmp.a[1]){
                if(ans>=x)ans-=x,lt+=tmp;
                x/=2,tmp/=2;
            }
            return ans;
        }
        
        __int256 operator%=(const __int256& X){
            // if(X==__int256(0))cerr<<"Error:mod 0\n",exit(-1);
            __int256 x(X),tmp(1),lt;
            if(neg!=x.neg)neg=1;
            else neg=0;
            while(*this>=x)x*=2,tmp*=2;
            while(tmp.len>1||tmp.a[1]){
                if(*this>=x)*this-=x,lt+=tmp;
                x/=2,tmp/=2;
            }
            return *this;
        }
        
        template<typename _Tp>
        operator _Tp()const{return _Tp(a[1]);}
        
        template<typename _Tp>
        __int256 operator+(const _Tp& x)const{return *this+__int256(x);}
        
        template<typename _Tp>
        __int256 operator+=(const _Tp& x){return *this=*this+x;}
        
        template<typename _Tp>
        __int256 operator-(const _Tp& x)const{return *this-__int256(x);}
        
        template<typename _Tp>
        __int256 operator-=(const _Tp& x){return *this=*this-x;}
        
        template<typename _Tp>
        __int256 operator*(const _Tp& x)const{
            __int256 ans;
            if(*this==ans||x==0)return ans;
            if(neg!=(x<0))ans.neg=1;
            ans.len=len;
            ull tmp;
            for(int i=1;i<=len;++i){
                tmp=1ull*a[i]*x+ans.a[i];
                if(tmp>=base){
                    ans.a[i]=tmp%base;
                    ans.a[i+1]+=tmp/base;
                }else ans.a[i]=tmp;
            }
            while(ans.a[ans.len]>0)++ans.len;
            --ans.len;
            return ans;
        }
        
        template<typename _Tp>
        __int256 operator*=(const _Tp& x){return *this=*this*x;}
        
        template<typename _Tp>
        __int256 operator/(const _Tp& x)const{
            // if(x==0)cerr<<"Error:divide 0\n",exit(-1);
            __int256 ans;
            if(len==1&&x>a[1])return ans;
            ull res=0;
            if(neg!=(x<0))ans.neg=1;
            for(int i=len;i;--i){
                res=res*base+a[i];
                ans.a[i]=res/x;
                res%=x;
            }
            while(ans.a[ans.len]>0)++ans.len;
            --ans.len;
            return ans;
        }
        
        template<typename _Tp>
        __int256 operator/=(const _Tp& x){return *this=*this/x;}
        
        template<typename _Tp>
        __int256 operator%(const _Tp& x)const{
            // if(x==0)cerr<<"Error:mod 0\n",exit(-1);
            if(len==1&&x>a[1])return *this;
            ull res=0;
            for(int i=len;i;--i){
                res=res*base+a[i];
                res%=x;
            }
            return res;
        }
        
        template<typename _Tp>
        __int256 operator%=(const _Tp& x){return *this=*this%x;}
    };
    
    template<typename _Tp>
    const __int256 operator+(const _Tp& x,const __int256& y){return __int256(x)+y;}
    
    template<typename _Tp>
    const __int256 operator-(const _Tp& x,const __int256& y){return __int256(x)-y;}
    
    template<typename _Tp>
    const __int256 operator*(const _Tp& x,const __int256& y){return __int256(x)*y;}
    
    template<typename _Tp>
    const __int256 operator/(const _Tp& x,const __int256& y){return __int256(x)/y;}
    
    template<typename _Tp>
    const __int256 operator%(const _Tp& x,const __int256& y){return __int256(x)%y;}
}

using namespace Int1024;
signed main(){
    __int256 a,b;
    cin>>a>>b;
    cout<<(a*b);
    return 0;
}