# include <bits/stdc++.h>
 
using namespace std ;

typedef long long int ll ; 
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
typedef pair<ll,ll> Pll ;
typedef vector<vector<Pll> > VVP ;
typedef vector<vector<ll> > VV ;
typedef vector<ll> V ;

 const ll MOD = (pow(10,9)+7) ;

ll lcm(ll a,ll b){
  return (a*b)/__gcd(a,b) ;
}
void vec_p(vector<ll> &a){
  for(ll i=0;i<a.size();i++){
    cout << a[i] <<" ";
  }
  cout <<"\n" ;
} 

void sorting(vector<ll>&a){
    sort(a.begin(),a.end()) ;
}
void rev_sorting(vector<ll>&a){
    sort(a.begin(),a.end(),greater<ll> ()) ;
}
void vec_in(vector<ll>&a,ll n){
  for(ll i=0;i<n;i++){
     ll x ;
    cin >> x ;
    a.push_back(x) ;
  }
}

ll binpow(ll a,ll b){
    ll res = 1;
    while (b > 0){
        if (b & 1)
            res = (res * a);
            
        a = a * a;
        b >>= 1;
    }
    return res;
}

void Graph_in(vector<vector<Pll> > &G,ll n,vector<ll> &a){
  ll x, y ;
  for(ll i=0;i<n;i++){

    cin >> x >> y ;
    G[x].push_back(make_pair(y,a[y-1]));
    G[y].push_back(make_pair(x,a[x-1])) ;
  }
}

// ll dfs(ll root,VV &G, vector<ll> &level,vector<ll> &sub_size,vector<ll> &visit ){
//   visit[root] = 1 ;
//   sub_size[root] = 0 ;
  
//   for(ll i=0;i<G[root].size();i++){
//     ll child = G[root][i] ;
    
//     if(visit[child]== -1){
//       level[child] = level[root] + 1 ;
//       sub_size[root] += (dfs(child,G,level,sub_size,visit)+1 );
//     }
//   }

//   return sub_size[root] ;
// }

ll firstoccur(ll &a,ll &b,ll &c){
  a = a%b ;
  for(ll i=1;i<=b;i++){
    a *= 10 ;
    if(a /b == c){
      return i ;
    }
    else{
      a = a%b ;
    }
  }

  return -1 ;
}

void SieveOfEratosthenes(ll n , vector <ll> &sieve) { 
    bool prime[n+1]; 
    memset(prime, true, sizeof(prime)); 
    for (int p=2; p*p<=n; p++){  
        if (prime[p] == true){ 
            for (int i=p*p; i<=n; i += p) 
                prime[i] = false; 
        } 
    } 
  
    // Print all prime numbers 
    for (int p=2; p<=n; p++) 
       if (prime[p]) 
          sieve.push_back(p) ;
} 

const int N = 1000007 ;
int fenwick[N] = {0} ;

void update_fen(int x,int diff){
  while(x < N){
    fenwick[x] += diff ;
    x += (x & -x) ;
    // addition of lowest bit
  }
}

int pref_sum_fen(int i){
  int sum = 0 ;
  // finding prefix sum from 0 to i
  while(i > 0){
    sum += fenwick[i] ;
    // subtract lowest bit
    i -= (i & -i) ;
  }

  return sum ;

}

void extract_fen(int x){
     int low = 0 ;
     int high = N ;
     int ans = -1 ;
     while(low <= high){
       int mid = (low+high)/2 ;
       if(pref_sum_fen(mid) >= x ){
         ans = mid ;
         high = mid -1 ;
       }
       else{
         low = mid+1 ;
       }

     }

     // we get the reqd index in ans 
     // update tree
     update_fen(ans,-1) ;
}

int finding_ans(){
  int h = N ;
  int l = 0 ;
  int a = -1 ;
  while(h >= l){
     int m = (h+l)/2 ;
     if(pref_sum_fen(m) >= 1){
        a=m ;
        h = m-1 ;

     }
     else{
       l = m+1 ;
     }
  }
  return a ;
}

void ex_binlift(int x){
  int current = 0 , sum = 0 ;
  for(int i=log2(N);i>=0;i--){
    if((current+(1<<i) < N ) && sum+fenwick[current + (1<<i)] < x ){
      current += (1 << i) ;
      sum += fenwick[current] ;
    }
  }
  update_fen(current+1,-1) ;
}
 
// int fa_bl(int x){
//   int current = 0 , sum = 0 ;
//   for(int i=log2(N);i>=0;i--){
//     if((current+(1<<i) < N ) && sum+fenwick[current + (1<<i)] < x ){
//       current += (1 << i) ;
//       sum += fenwick[current] ;
//     }
//   }

//   if(sum == 0){
//     return sum ;
//   }
//   else {
//     return (current+1) ;
//   }

// }
// void Gin(VVP &G,ll n,ll &checker){
//   ll x,y,t ;
//   for(ll i=0;i<n;i++){
//     cin >> x>>y >> t ;
//     G[x].push_back(make_pair(y,t)) ;
//     G[y].push_back(make_pair(x,t)) ;
//     if(t==1){
//       checker ++ ;
//     }
//   }
// }



// void dfs(ll &root,V &visit, VVP &G,ll num){
//   if(visit[root] == -1 ){
//     visit[root] = num ;
//   }
//   for(ll i=0;i<G[root].size();i++){
//     Pll l = G[root][i] ;
//     if(l.second == 0 && visit[l.first] == -1){
//       dfs(l.first,visit,G,num) ;
//     }
//   }
// }
ll binexp(ll a, ll b, ll m) {
    a %= m;
    ll res = 1;
    while (b > 0) {
        if (b & 1)
            res = res * a % m;
        a = a * a % m;
        b >>= 1;
    }
    return res;
} 
int main(){
  fast 
  
  ll a,b ;
  cin >>a>>b ;
  cout << a*b <<"\n" ;

  
 
}

Measured memory_bytes: 3588