#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
 
//template
#define rep(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define ALL(v) (v).begin(),(v).end()
typedef long long int ll;
const int inf = 0x3fffffff; const ll INF = 0x1fffffffffffffff; const double eps=1e-12;
template<typename T>inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
template<typename T>inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
//end
 
template<typename T>struct FFT{
   struct C{
      T x,y;
      C(T _x=0,T _y=0):x(_x),y(_y){}
      C operator~()const{return {x,-y};}
      C operator+(const C& c)const{return {x+c.x,y+c.y};}
      C operator-(const C& c)const{return {x-c.x,y-c.y};}
      C operator*(const C& c)const{return {x*c.x-y*c.y,x*c.y+y*c.x};}
   };
   vector<C> rt;
   FFT(int lg=20){
      rt.resize(1<<lg,1);
      rep(k,1,lg){
         int d=1<<k;
         rep(i,0,d){
            if(i&1)rt[d+i]=C(cos(2*M_PI*i/d),sin(2*M_PI*i/d));
            else rt[d+i]=rt[(d+i)>>1];
         }
      }
   }
   void fft(vector<C>& a,bool inv=0){
      int n=a.size(); assert((n&(n-1))==0);
      if(inv){
         for(int i=1;i<n;i<<=1)for(int j=0;j<n;j+=i*2)for(int k=0;k<i;k++){
            a[i+j+k]=a[i+j+k]*~rt[i*2+k]; C tmp=a[j+k]-a[i+j+k];
            a[j+k]=a[j+k]+a[i+j+k]; a[i+j+k]=tmp;
         } rep(i,0,n)a[i].x/=n,a[i].y/=n;
      }
      else{
         for(int i=n>>1;i;i>>=1)for(int j=0;j<n;j+=i*2)for(int k=0;k<i;k++){
            C tmp=a[j+k]-a[i+j+k];
            a[j+k]=a[j+k]+a[i+j+k]; a[i+j+k]=tmp*rt[i*2+k];
         }
      }
      for(int i=0,j=1;j<n-1;j++){
         for(int k=n>>1;k>(i^=k);k>>=1);
         if(j<i)swap(a[i],a[j]);
      }
   }
   vector<ll> conv(vector<ll> a,vector<ll> b){
      if(a.empty() or b.empty())return vector<ll>();
      int n=a.size()+b.size()-1,m=1; vector<ll> res(n);
      if(n<=256){
         rep(i,0,a.size())rep(j,0,b.size())res[i+j]+=a[i]*b[j];
         return res;
      }
      while(m<n){m<<=1;} vector<C> c(m);
      rep(i,0,a.size())c[i].x=a[i]; rep(i,0,b.size())c[i].y=b[i];
      fft(c); C rad(0,-0.25/m);
      for(int i=0,j=0;i<=m/2;i++,j=(m-i)&(m-1)){
         C z=(c[j]*c[j]-~(c[i]*c[i]))*rad;
         if(i!=j)c[j]=(c[i]*c[i]-~(c[j]*c[j]))*rad;
         c[i]=z;
      } fft(c); rep(i,0,n)res[i]=c[i].x+0.5; return res;
   }
};
 
FFT<double> fft(20);
template<int D>struct bigint{
   static const int B=pow(10,D);
   int sign=0; vector<ll> v;
   static int get_D(){return D;}
   static int get_B(){return B;}
   bigint(ll x=0){
      if(x<0)x*=-1,sign=1;
      while(x){v.push_back(x%B); x/=B;}
   }
   bigint(string s){
      if(s[0]=='-')s.erase(s.begin()),sign=1;
      int add=0,cnt=0,base=1;
      while(s.size()){
         if(cnt==D){
            v.push_back(add);
            cnt=0; add=0; base=1;
         }
         add=(s.back()-'0')*base+add;
         cnt++; base*=10; s.pop_back();
      } if(add)v.push_back(add);
   }
   bigint operator-()const{bigint res=*this; res.sign^=1;return res;}
   bigint abs()const{bigint res=*this; res.sign=0; return res;}
   ll& operator[](const int i){return v[i];}
   int size()const{return v.size();}
   void norm(){
      rep(i,0,v.size()-1){
         if(v[i]>=0){v[i+1]+=v[i]/B; v[i]%=B;}
         else{int c=(-v[i]+B-1)/B; v[i]+=c*B; v[i+1]-=c;}
      }
      while(!v.empty() and v.back()>=B){
         int c=v.back()/B;
         v.back()%=B; v.push_back(c);
      }
      while(!v.empty() and v.back()==0)v.pop_back();
   }
   string to_str()const{
      string res;
      if(v.empty())return "0";
      if(sign)res+='-';
      res+=to_string(v.back());
      for(int i=v.size()-2;i>=0;i--){
         string add; int w=v[i];
         rep(_,0,D){
            add+=('0'+(w%10)); w/=10;
         } reverse(ALL(add)); res+=add;
      } return res;
   }
   friend istream& operator>>(istream& is,bigint<D>& x){
      string tmp; is>>tmp; x=bigint(tmp); return is;
   }
   friend ostream& operator<<(ostream& os,bigint<D> x){
      os<<x.to_str(); return os;
   }
   bigint& operator<<=(const int& x){
      if(!v.empty()){
         vector<ll> add(x,0);
         v.insert(v.begin(),ALL(add));
      } return *this;
   }
   bigint& operator>>=(const int& x){
      v=vector<ll>(v.begin()+min(x,(int)v.size()),v.end());
      return *this;
   }
   bigint& operator+=(const bigint& x){
      if(sign!=x.sign){*this-=(-x); return *this;}
      if((int)v.size()<(int)x.size())v.resize(x.size(),0);
      rep(i,0,x.size()){v[i]+=x.v[i];} norm(); return *this;
   }
   bigint& operator-=(const bigint& x){
      if(sign!=x.sign){*this+=(-x); return *this;}
      if(abs()<x.abs()){*this=x-(*this); sign^=1; return *this;}
      rep(i,0,x.size()){v[i]-=x.v[i];} norm(); return *this;
   }
   bigint& operator*=(const bigint& x){
      sign^=x.sign;
      auto v1=fft.conv(v,x.v);
      v.assign(v1.size(),0);
      rep(i,0,v1.size()){
         ll val=v1[i];
         for(int j=i;val;j++){
            if(j==(int)v.size())v.push_back(0);
            v[j]+=val%B; val/=B;
         }
      } norm(); return *this;
   }
   bigint& operator/=(const bigint& x){  
      bigint a=abs(),b=x.abs(); sign^=x.sign;
      if(a<b)return *this=bigint();
      int d=a.size()-b.size()+1;
      bigint inv(1LL*B*B/b.v.back()),pre;
      int cur=2,bcur=1; pre=bigint(0);
      while(inv!=pre or bcur<b.size()){
         bcur=min(bcur<<1,b.size());
         bigint c; c.v=vector<ll>(b.v.end()-bcur,b.v.end());
         pre=inv; inv*=((bigint(2)<<(cur+bcur-1))-inv*c);
         cur=min(cur<<1,d);
         inv.v=vector<ll>(inv.v.end()-cur,inv.v.end());
      }
      inv.v=vector<ll>(inv.v.end()-d,inv.v.end());
      bigint res=a*inv; res>>=(a.size());
      bigint mul=res*b; while(mul+b<=a){res+=bigint(1); mul+=b;}
      v=res.v; return *this;
   }
   bigint& operator%=(const bigint& x){
      bigint div=(*this)/x; (*this)-=div*x; return *this;
   }
   bigint square(){
      bigint res=*this; res.sign=0;
      auto v1=fft.conv(v,v);
      res.v.assign(v1.size(),0);
      rep(i,0,v1.size()){
         ll val=v1[i];
         for(int j=i;val;j++){
            if(j==(int)res.v.size())res.v.push_back(0);
            res.v[j]+=val%B; val/=B;
         }
      } res.norm(); return res;
   }
   bigint mul(ll x){
      bigint res=*this; if(x<0)res.sign^=1,x*=-1;
      for(int i=res.v.size()-1;i>=0;i--)res.v[i]*=x;
      res.norm(); return res;
   }
   bigint div(ll x){
      bigint res=*this; if(x<0)res.sign^=1,x*=-1;
      for(int i=res.v.size()-1;i>=0;i--){
         if(res.v[i]%x!=0 and i!=0){res.v[i-1]+=B*(res.v[i]%x);} res.v[i]/=x;
      } res.norm(); return res;
   }
   bigint operator<<(const int& x)const{return bigint(*this)<<=x;}
   bigint operator>>(const int& x)const{return bigint(*this)>>=x;}
   bigint operator+(const bigint& x)const{return bigint(*this)+=x;}
   bigint operator-(const bigint& x)const{return bigint(*this)-=x;}
   bigint operator*(const bigint& x)const{return bigint(*this)*=x;}
   bigint operator/(const bigint& x)const{return bigint(*this)/=x;}
   bigint operator%(const bigint& x)const{return bigint(*this)%=x;}
   bool operator<(const bigint& x)const{
      if(sign!=x.sign)return sign>x.sign;
      if((int)v.size()!=(int)x.size()){
         if(sign)return (int)x.size()<(int)v.size();
         else return (int)v.size()<(int)x.size();
      }
      for(int i=v.size()-1;i>=0;i--)if(v[i]!=x.v[i]){
         if(sign)return x.v[i]<v[i];
         else return v[i]<x.v[i];
      }
      return false;
   }
   bool operator>(const bigint& x)const{return x<*this;}
   bool operator<=(const bigint& x)const{return !(*this>x);}
   bool operator>=(const bigint& x)const{return !(*this<x);}
   bool operator==(const bigint& x)const{return !(*this<x) and !(*this>x);}
   bool operator!=(const bigint& x)const{return !(*this==x);}
};
typedef bigint<5> Bigint;
 
struct Bigfloat{
   Bigint v; int p=0;
   Bigfloat(){}
   Bigfloat(const ll& _v){v=Bigint(_v);}
   Bigfloat(const Bigint& _v,int _p=0):v(_v),p(_p){}
   void set(int _p){if(p<_p){v>>=(_p-p);} else{v<<=(p-_p);} p=_p;}
   Bigint to_int()const{if(p<0)return v>>(-p); else return v<<p;}
   Bigfloat& operator+=(const Bigfloat& x){
      if(p>x.p)set(x.p),v+=x.v;
      else v+=x.v<<(x.p-p);
      return *this;
   }
   Bigfloat& operator-=(const Bigfloat& x){
      if(p>x.p)set(x.p),v-=x.v;
      else v-=x.v<<(x.p-p);
      return *this;
   }
   Bigfloat square(){Bigfloat res=*this; res.p*=2; res.v=res.v.square(); return res;}
   Bigfloat mul(ll x){Bigfloat res=*this; res.v=v.mul(x); return res;}
   Bigfloat div(ll x){Bigfloat res=*this; res.v=v.div(x); return res;}
   Bigfloat& operator*=(const Bigfloat& x){p+=x.p; v*=x.v; return *this;}
   Bigfloat& operator/=(const Bigfloat& x){p-=x.p; v/=x.v; return *this;}
   Bigfloat operator+(const Bigfloat& x)const{return Bigfloat(*this)+=x;}
   Bigfloat operator-(const Bigfloat& x)const{return Bigfloat(*this)-=x;}
   Bigfloat operator*(const Bigfloat& x)const{return Bigfloat(*this)*=x;}
   Bigfloat operator/(const Bigfloat& x)const{return Bigfloat(*this)/=x;}
   string to_str(){
      string res=v.abs().to_str(); int d=Bigint::get_D();
      if(p*d>0)res+=string(p*d,'0');
      else if(-p*d>=1 and -p*d<(int)res.size()){
         res=res.substr(0,(int)res.size()+p*d)+'.'+res.substr((int)res.size()+p*d);
      }
      else if(-p*d>=(int)res.size())res="0."+string(-p*d-(int)res.size(),'0')+res;
      if(v.sign){res.insert(res.begin(),'-');} return res;
   }
   friend ostream& operator<<(ostream& os,Bigfloat x){
      os<<x.to_str(); return os;
   }
};
 
int main(){
   Bigint x,y; cin>>x>>y;
   cout<<x*y<<endl;
   return 0;
}


Measured memory_bytes: 24064