Go: package main

import (
    "fmt"
)

func main() {
    var a, b float64
    fmt.Scanf("%v %v", &a, &b)
    fmt.Println(a * b)
}

C++: #include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
//---------------------------------------------------------------------------------------------------
/*---------------------------------------------------------------------------------------------------
　　　　　　　　　　　 ∧＿∧  
　　　　　 ∧＿∧ 　（´<_｀ ）　 Welcome to My Coding Space!
　　　　 （ ´_ゝ`）　/　 ⌒i     
　　　　／　　　＼　 　 |　|     
　　　 /　　 /￣￣￣￣/　　|  
　 ＿_(__ﾆつ/　    ＿/ .| .|＿＿＿＿  
　 　　　＼/＿＿＿＿/　（u　⊃  
---------------------------------------------------------------------------------------------------*/





int D, C;
//---------------------------------------------------------------------------------------------------
void _main() {
    cin >> D >> C;
    int ans = D * C;
    cout << ans << endl;
}

C++: #include<iostream>
using namespace std;

int main(){
	int desk,chair;
	cin >> desk >> chair;
	cout << desk * chair << '\n';
	return 0;
}

C++: #include<iostream>
using namespace std;
int main (){
	int d, c, x;
	cin >> d >> c;
	x = d * c;

	cout << x <<endl;

	return 0;
}

C++: #include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <functional>

#define INF (2 << 28)
#define fr first
#define sc second
using namespace std;

typedef long long ll;
typedef pair<int, int> iP;

int main(){
  
  int d, c;
  cin >> d >> c;
  cout << d * c << endl;
 
}

C++: #include <iostream>
using namespace std;
int main(){
  int d,c;
  cout << d*c << endl;
  return 0;
}

C++: #include<iostream>
using namespace std;
int main()
{
	int d, c;
	cin >> d >> c;
	cout << d*c << endl;;
}

C++: #include<iostream>

int main(void)
{
  int n1, n2;

  cin>>n1>>n2;

  cout<<n2*n1<<endl;

  return 0;
  
}

C++: #include "bits/stdc++.h"

using namespace std;


int main(){
	int a,b;
	cin>>a>>b;
	cout<<a*b<<endl;;
	return 0;
}

C++: #define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;
template <class A, class B> inline bool chmax(A &a, const B &b) { return b > a && (a = b, true); }
template <class A, class B> inline bool chmin(A &a, const B &b) { return b < a && (a = b, true); }
typedef long long ll;
typedef vector<int> vint;
typedef pair<int, int> pint;
typedef vector<long long> vlong;
typedef vector<string> vstring;
#define vpush(a,x) a.push_back(x);
#define rep(i, n) REP(i, 0, n)
#define all(v) v.begin(), v.end()
#define REP(i, x, n) for(int i = x; i < n; i++)
const int INF = 1 << 30;
const int dx[] = {1,0,-1,0,1,1,-1,-1};
const int dy[] = {0,-1,0,1,1,-1,-1,1};
#define stp(x)  setprecision(x)
const long double PI=3.14159265358979323846264338327950;
int main(){
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  int d,c;
  cin>>d>>c;
  cout<<d*c<<'\n';
  return(0);
}

C++: #include <iostream>
#include <stdio>
using namespace std;

int main() {
  int a, b;
  scanf("%d%d", &a, &b);
  cout << a * b<< endl;
  return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;
int main(){
    int a,b;
    cin>>a>>b;
    cout<<a*b<<endl;
    return 0;
}

C++: #include <iostream>
using namespace std;
int main() {
	int a,b;
	cin>>a>>b;
	cout<<a*b<<endl;
	return 0;
}

C++: #include <stdio.h>
int main() {int x, y;scanf("%d%d",&x,&y);printf("%d\n",x*y);}

C++: #include <iostream>
using namespace std;
int main() {
	int d, c;
	cin >> d >> c;
	cout << d * c << endl;
	return 0;
}

C++: #include<iostream>
using namespace std;
int main(void) {
	int a, b;
	cin >> a >> b;
	cout << a * b << endl;
	return 0;
}

C++: #include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
#include<queue>
#include<stack>
#include<bitset>
#include<functional>
#include<map>
#include<unordered_set>
using namespace std;
//int p = 998244353;
int p = 1000000007;
#define int long long
#define vel vector<long long>
#define vvel vector<vel>
#define rep(i,n) for(int i=0;i<n;i++)
#define sor(v) sort(v.begin(),v.end())
#define mmax(a,b) a=max(a,b)
#define mmin(a,b) a=min(a,b)
#define mkp make_pair
#define pin pair<int,int>
#define qin pair<int,pin>
#define V vector
#define Endl endl
#define veb vector<bool>
#define rev(s) reverse(s.begin(),s.end())
int max_kai = 150000;
vel kai(max_kai, 1);
vel inv_kai;
int rui(int a, int n) {
	if (n == 0) { return 1; }
	int x = rui(a, n / 2);
	x *= x; x %= p;
	if (n % 2 == 1) { x *= a; x %= p; }
	return x;
}
int inv(int a) { return rui(a, p - 2); }
void make_kai() {
	for (int i = 1; i < max_kai; i++) { kai[i] = kai[i - 1] * i; kai[i] %= p; }
	inv_kai = kai;
	rep(i, max_kai) { inv_kai[i] = inv(kai[i]); }
}
int nCr(int n, int r) {
	int a = kai[n] * inv_kai[r]; a %= p;
	a *= inv_kai[n - r]; a %= p;
	return a;
}
vel pa;
int root(int x) {
	if (pa[x] == -1) { return x; }
	int ans = root(pa[x]); pa[x] = ans;
	return ans;
}
void marge(int x, int y) {
	x = root(x);
	y = root(y);
	if (x != y) {pa[x] = y;}
}
#define lower(h,val) lower_bound(h.begin(),h.end(),val)-h.begin()
#define upper(h,val) upper_bound(h.begin(),h.end(),val)-h.begin()
int num_lp(int a, vel &nex) {
	unordered_set<int> se;
	int ans = 0;
	while (true) {
		if (se.find(a) != se.end()) {
			break;
		}
		se.insert(a);
		a = nex[a];
		ans++;
	}
	return ans;
}
int find_cr(int a, vel &nex) {
	unordered_set<int> se;
	while (true) {
		if (se.find(a) != se.end()) {break;}
		se.insert(a);
		a = nex[a];
	}
	return num_lp(a, nex);
}
int inf = 2000000000;
vvel dp;
int solve(vvel &sum, int i, int j, bool is_f) {
	int h = sum.size(); h--;
	int w = sum[0].size();
	if (i == h || j == w) { return 0; }
	if (dp[i][j] == inf) {
		int ans1 = solve(sum, i + 1, j, !is_f);
		int ans2 = solve(sum, i, j + 1, !is_f);
		ans2 += sum[i][j];
		if (is_f) {
			dp[i][j] = min(ans1, ans2);
		}
		else {
			dp[i][j] = max(ans1, ans2);
		}
	}
	return dp[i][j];
}
int rui10(int a) {
	if (a == 0) { return 1; }
	return 10 * rui10(a - 1);
}
int gcd(int a, int b) {
	if (a < b) { swap(a, b); }
	if (b == 0) { return a; }
	return gcd(b, a%b);
}
vel mul(vel &a, vel &b) {
	int n = a.size();
	vel c(n,-1);
	rep(i, n) {
		rep(j, n) {
			if (a[i] >= 0 && b[j] >= 0) {
				mmax(c[(i + j) % n], a[i] + b[j]);
			}
		}
	}
	return c;
}
vel rui(vel &a, int n) {
	if (n == 1) { return a; }
	vel b = rui(a, n / 2);
	b = mul(b, b);
	if (n % 2 == 1) {
		b = mul(b, a);
	}
	return b;
}
signed main(){
	int d, c; cin >> d >> c;
	cout << c * d << endl;
	return 0;
}

C++: #include <iostream>
using namespace std;

int main(){
	int a,b;
	cin >> a >> b;
	cout << a * b << endl;
}

C++: #include <stdio.h>
int main(void){
	
	int b,c;
	int a;
	
	scanf("%d %d",&b,&c);
	a = b * c;
	printf("%d",a);
	
	
	
	return 0;
}

C++: #include<iostream>
using namespace std;
int main(){
int t,y;
cin>>t>>y;
cout<<t*y<<endl;
return 0;
}

C++: #include <iostream>
using namespace std;
int main(void){
  int d,c;
  cin>>d>>c;
  cout<<d*c<<endl;
}

C++: #include <stdio.h>

int main()
{
   int  a,b, c;
   scanf("%d %d", &a, &b);
   c = a * b;
   printf("%d\n",c);
}

C++: #include <iostream>
int main(){
  int d,c;
  std::cin >> d >> c;
  std::cout << d*c << std::endl;
  return 0;
}

C++: #include <iostream>
using namespace std;

int main(){
  int d,c
  cin>>d>>c;
  cout<<d*c<<'\n';
  return 0;
}

C++: #include <cstdio>
int main()
{
  int a,b;
  scanf("%d %d",&a,&b);
  printf("%d\n",a*b);
  return 0;
}