Problem:
 Score : 100 points    Problem Statement Compute A \times B .      Constraints  1 \leq A \leq 100  1 \leq B \leq 100  All values in input are integers.         Input Input is given from Standard Input in the following format:  A  B       Output Print the value A \times B as an integer.        Sample Input 1 2 5      Sample Output 1 10  We have 2 \times 5 = 10 .       Sample Input 2 100 100      Sample Output 2 10000

Solution (Python):
import math

A,B=input().split()
A = int(A)
B = float(B)

print(math.floor(A*B))

Solution (Python):

import math
def num():
    return map(int , input().split())
def nu():
    return int(input())
def li():
    return input().split()
def sli():
    return list(map(str, input().split()))
def lli ():
    return list (map(int, input ().split ()))
def fli():
    return [float(x) for x in input().split()]

a, b = num()
print(a * b)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
a , b  = list(map(int,input().split()))
print(a*b)

Solution (Python):
l = list(map(int,input().split()))
ans = 1

for i in l:
    ans *= i
if ans > 10**18:
    ans=-1
print(ans)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
from math import floor
import numpy as np
inputs = input().split()
multiple = np.int64(inputs[0]) * np.float64(inputs[1])

multiple_str = str(multiple)
if '.' in multiple_str:
    ans = multiple_str.split('.')[0]
else:
    ans = multiple_str

print(ans)

Solution (Python):
nums = [int(e) for e in input().split()]
print(nums[0] * nums[1])

Solution (Python):
a , b = map(int,input().split())
print(a*b)

Solution (Python):
A, B = map(int,input().split())
print(int(A*B))

Solution (Python):
def main():
    A, B = map(int, input().split())
    print(A * B)

if __name__ == "__main__":
    main()

Solution (Python):
a ,b= map(int, input().split())

print(a*b)

Solution (Python):
import decimal

def main():
    a, b = input().split()
    a = int(a)
    b = decimal.Decimal(b)
    print(int(a * b))



if __name__ == '__main__':
    main()

Solution (Python):
A, B = map(int, input().split())
print(A * B)

Solution (Python):
a, b = input().split()
a = float(a)
b = float(b)
import math
if b == 0.00:
  print(0)
else:
  print(int(a*b))

Solution (Python):
def main():
    a, b = map(int, input().split())
    ans = a * b
    print(f'{ans}')


if __name__ == '__main__':
    main()

Solution (Python):
A,B=map(int,input().split())

print(int(A*B))

Solution (Python):
A, B = input().split()
print(int(A)*int(B))

Solution (Python):
I = lambda : list(map(int,input().split()))
a,b=I()
print(a*b)

Solution (Python):
A,B=map(int,input().split())
print(A*B)

Solution (Python):
a,b = map(int,input().split())
print(int(a*b))

Solution (Python):
A,B =map(int,input().split())
print(A*B)

Solution (Python):
a = input()
list = a.split(" ")
x = int(list[0])
y = int(list[1])
print(x*y)

Solution (Python):
a, b = input().split()
a = int(a) 
b= int(b)
print(a*b)

Solution (Python):

l = []
l = list(map(float,input().split()))
ans = l[0] * l[1]
print(int(ans))

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
AB = list(map(int, input().split()))
print(AB[0] * AB[1])

Solution (Python):
a,b = map(int,input().split())

print(a*b)

Solution (Python):
print(eval(input().replace(" ","*")))

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
a, b = map(int, input().split())
print(a * b)

Solution (Python):
if __name__ == "__main__":
    a, b = map(int, input().split())
    print(a*b)

Solution (Python):
str = input().split()

print(int(str[0]) * int(str[1]))

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
A, B = map(int, input().split())

print(A * B)

Solution (Python):
a,b=(int(x) for x in input().split())
print(a * b)

Solution (Python):
a,b=map(int, input().split())
print(a*b)

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):
A, B = map(int, input().split())
print(A * B)

Solution (Python):
A, B = map(int, input().split())
if (1<=A<=100 and 1<=B<=100):
    result = A * B
    print(result)

Solution (Python):

def main():

    A, B = map(int, input().split())

    AB = A*B
    print(AB)


if __name__ == '__main__':
    main()

Solution (Python):


hairu = input()
kita = hairu.split(" ")
a = int(kita[0])
b = int(kita[1])

print(a*b)

Solution (Python):
import decimal
decimal.getcontext().prec = 5
S = input().split()
A = int(S[0])
B = float(S[1])

B = decimal.Decimal(B)

print(int((A*B)/1))

Solution (Python):
A, B = map(int, input().split())

print(A * B)

Solution (Python):
A, B = map(float, input().split())
mod = 10000
a = int(A // mod)
a2 = int(A % mod)
B = int(100 * B)
ans = a * B * mod + a2 * B 
print(ans // 100)

Solution (Python):
x,y = map(int,input().split())

print(x*y)

Solution (Python):
A,B = map(int, input().split())

print(A*B)

Solution (Python):
A,B=map(int,input().split())
print(A*B)

Solution (Python):
a, b = map(int, input().split())
print(a *b)

Solution (Python):
A,B=list(map(int,input().split()))
print(A*B)

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):

import sys


sysread = sys.stdin.readline
read = sys.stdin.read



sys.setrecursionlimit(10 ** 7)







import math

def run():
    A,B = map(int, input().split())
    print(A*B)




if __name__ == "__main__":
    run()

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
A, B = map(int, input().split())
print(int(A * B))

Solution (Python):
a,b = input().split()
print(int(a)*int(b))

Solution (Python):
a,b = map(int,input().split())

print (a*b)

Solution (Python):
x, y = list(map(int, input().split()))
print(x * y)

Solution (Python):
A, B = map(int, input().split())

print(A * B)

Solution (Python):
import math
a, b = input().split()
a = int(a)
b = round(float(b)*100)

ans = math.floor(a*b*0.01)
print(ans)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):
A,B= map(int, input().split())

print(A * B)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
AB = input()
AB = AB.split()
A = int(AB[0])
B = int(AB[1])

print(int(A*B))

Solution (Python):
A,B = map(int,input().split())
print(A * B)

Solution (Python):
import math
a,b = input().split()
k = int(a) * int(b)
answer = math.floor(k)
print(answer)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):


i = list(map(int, input().split()))

print(i[0]*i[1])

Solution (Python):
in_str = input().split(" ")
a, b = int(in_str[0]), int(in_str[1])
result = a*b
print(result)

Solution (Python):
a,b = list(map(int,input().split()))
print(a*b)

Solution (Python):
(a,b) = map(int,input().split())
print(a*b)

Solution (Python):
input_nums = input().split()

output = 1

x = map((lambda x: int(x)), input_nums)

for num in x:
    output *= num
    
print(output)

Solution (Python):
inputs= list(input().split())
A=int(inputs[0])
B=int(float(inputs[1])*100//1)
Ans=A*B/100//1
print(int(Ans))

Solution (Python):
a, b = map(int, input().split())
print (a*b)

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
a, b = map(int, input().split())

print("{}".format(a*b))

Solution (Python):
A,B=map(int,input().split())
print(A*B)

Solution (Python):
import sys
def main():
    A, B = map(int, input().split())

    print(A*B)
main()

Solution (Python):
num = list(map(int,input().split(" ")))

print(num[0]*num[1])

Solution (Python):
a,b=map(int, input().split())

if 1 <= a and a <= 100 and 1 <= b and b <= 100:
  result=a*b
  print(result)

Solution (Python):
a, b = map(int,input().split())
print(a * b)

Solution (Python):
import sys


try:
    sys.stdin = open(sys.path[0] + '/input.txt', 'r')
    sys.stdout = open(sys.path[0] + '/output.txt', 'w')
except FileNotFoundError:
    pass

a, b = list(map(int, input().split()))
print(a * b)

Solution (Python):
l = input().split(" ")
a = int(l[0])
b = int(l[1])
print(str(a*b))

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
a, b = map(int, input().split())
c = a * b
print(c)

Solution (Python):
A, B = map(int, input().split())
print(A * B)

Solution (Python):
a, b = map(int,input().split())
print(a*b)

Solution (Python):
A, B = list(map(int, input().split()))

print(A*B)

Solution (Python):
A,B=list(map(int,input().split()))
print(A*B)

Solution (Python):
import numpy as np
input = input().split(" ")
nl = list()
for ele in input:
  nl.append(int(ele))
def multiplyList(myList) : 
    result = 1
    for x in myList: 
         result = result * x  
    return result
res = multiplyList(nl)
print(res)

Solution (Python):
i = input().split(" ")
A = int(i[0]) 
B = int(i[1])
num = A * B
print(num)

Solution (Python):
x, y = [int(x) for x in input().split()]
print(x*y)

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):
i = list(map(int, input().split()))
print(i[0]*i[1])

Solution (Python):
A, B = map(int, input().split())

print(str(A * B))

Solution (Python):
a, b=input().split()
a=int(a)
b=int(b)
print(a*b)

Solution (Python):
M, N = map(int, input().split())
print(M*N)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
A, B = map(int, input().split())

print(A*B)

Solution (Python):
A,B =map(int,input().split())
print(A*B)

Solution (Python):
import sys
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()
mod = 10**9 + 7

a,b = get_ints()
print(a*b)

Solution (Python):
A,B=(int(x) for x in input().split())
num = A * B
print(num)

Solution (Python):
import math
import re

a = input()
b = int(re.sub('\s.+$','',a))
c = float(re.sub('^.+\s','',a))
d = float(b * c)
print(math.floor(d))

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):


A,B = map(int,input().split())

print("{}".format(A*B))

Solution (Python):
import sys
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()
mod = 10**9 + 7

a,b = get_ints()
print(a*b)

Solution (Python):
x = input()
a, b = map(int, x.split(" "))
print(a * b)

Solution (Python):
A, B = map(int, input().split())

ans = A * B
print(ans)

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):
A,B = map(int,input().split())
print(A*B)

Solution (Python):

a,b = map(int,input().split())
print(a*b)

Solution (Python):
a, b = [int(_) for _ in input().split()]
print(a*b)

Solution (Python):
A,B=map(int,input().split())
C=A*B
print(C)

Solution (Python):


t = str(input()).split(" ")
r = int(t[0]) * int(t[1])
print(r)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
A,B = map(int, input().split())

print(A*B)

Solution (Python):
a, b = map(int, input().split())

print(a * b)

Solution (Python):
a, b = [int(x) for x in input().split(" ")]
 
print(a * b)

Solution (Python):
a,b= map(int,input().split())
print(a*b)

Solution (Python):
l = input()
a = int(l.split()[0])
b = int(l.split()[1])
print(a*b)

Solution (Python):
A, B = map(int, input().split())
print(A * B)

Solution (Python):
A,B=map(int,input().split())
print(A*B)

Solution (Python):
import math
def solve():
    a, b = input().split()
    a = int(a)
    b = float(b)
    print(int(a*b))
    return 0
 
if __name__ == "__main__":
    solve()

Solution (Python):
import math

arr = list(map(int, input().split()))

a = arr[0]
b = arr[1]

print(a*b)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)

def int1(x): return int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

def SI(): return input().split()

def printlist(lst, k='\n'): print(k.join(list(map(str, lst))))
INF = float('inf')

from math import ceil, floor, log2
from collections import deque
from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product
from heapq import heapify, heappop, heappush


def solve():
    a, b = MI()
    print(a * b)


if __name__ == '__main__':
    solve()

Solution (Python):
a,b = map(int,input().split())
print(a * b)

Solution (Python):
import sys
from functools import lru_cache
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

A, B= map(int, read().split())
print(A*B)

Solution (Python):
A,B=map(float,input().split())
print(int(A*B))

Solution (Python):
A,B=map(int,input().split())
print(A*B)

Solution (Python):
A, B = map(int, input().split())


print(A*B)

Solution (Python):
import sys
def inpl(): return list(map(int, sys.stdin.readline().split()))

x  = inpl()

print(x[0]*x[1])

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):
N = list(map(int,input().split()))

ans = N[0] * N[1]

print(ans)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
a,b = map(int, input().split())
print(a*b)

Solution (Python):
print((lambda a, b: a * b)(*map(int, input().split())))

Solution (Python):
A, B = map(int, input().split())
ans = A * B
print(ans)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
p = list(map(int,input().split()))
print(p[0]*p[1])

Solution (Python):
import sys

input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]

tin=lambda : map(int, input().split())
lin=lambda : list(tin())
mod=1000000007



def main():
	
	b , c = tin()
	
	print(b*c)
	
	
	

isTest=False

def pa(v):
	if isTest:
		print(v)
		
def input_clipboard():
	import clipboard
	input_text=clipboard.get()
	input_l=input_text.splitlines()
	for l in input_l:
		yield l

if __name__ == "__main__":
	if sys.platform =='ios':
		if input_method==input_methods[0]:
			ic=input_clipboard()
			input = lambda : ic.__next__()
		elif input_method==input_methods[1]:
			sys.stdin=open('inputFile.txt')
		else:
			pass
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

Solution (Python):
it = input()
it = it.split()
a = int(it[0])
b = int(it[1])

print(a*b)

Solution (Python):
list = input().split(" ")
a = int(list[0])
b = int(list[1])
c =  a * b
print(c)

Solution (Python):
A, B = map(int,input().split())
print(A * B)

Solution (Python):
a,b =map(int,input().split())
if 1 <= a <=100 and 1 <= b <= 100:
     print(a*b)

Solution (Python):
AB = [int(x) for x in input().split()]
a = AB[0]
b = AB[1]
print(a*b)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
a,b = list(map(int,input().split()))
print(a*b)

Solution (Python):
import math
N,K=input().split()
N=int(N)
K=eval(K)
K=round(K,2)

print(math.trunc(N*K))

Solution (Python):
a, b = [int(x) for x in input().split()]
print(a * b)

Solution (Python):
import math
a, b = input().split()

a = int(a)
b = int(float(b)*100)
ans = a*b
ans = math.floor(ans/100)

print(ans)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
a, b = map(int, input().split())
print(a * b)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
from math import floor,ceil,sqrt,factorial,log
from heapq import heapify, heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from decimal import Decimal
inf = float('inf')
mod = 1000000007

a, b = map(int, input().split())

print(a*b)

Solution (Python):
List = list(map(int, input().split()))
print(List[0]*List[1])

Solution (Python):
a, b = [int(i) for i in input().split()]
print(a*b)

Solution (Python):
x,y = map(int,input().split())
print(x*y)

Solution (Python):


a,b = list(map(int, input().split()))

print(a*b)

Solution (Python):
A, B = map(int, input().split())

print(A * B)

Solution (Python):
a,b = map(int, input().split())
print(a*b)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
a, b = map(int, input().split())

print(a*b)

Solution (Python):
a, b = map(int, input().split())

print(a * b)

Solution (Python):
A, B = map(int, input().split())
ans = A * B
print(ans)

Solution (Python):
A, B = map(int, input().split())
print(A * B)

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):
A = list(map(int, input().split()))
print(A[0]*A[1])

Solution (Python):
A, B = map(int, input().split())
print(A * B)

Solution (Python):
A,B = map(int,input().split())
print(A*B)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
A,B = map(int, input().split())
print(A*B)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):


a, b = map(int, input().split())
print(a * b)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
A,B =map(int,input().split())
print(A*B)

Solution (Python):
n=input().split()
a=int(n[0])
b=int(n[1])
ans=a*b
print(ans)

Solution (Python):
a, b = map(int, input().split())
print(a * b)

Solution (Python):
a = input().split()
A = a[0]
B = a[1]

print(int(A)*int(B))

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
A, B = map(int, input().split())
print(A * B)

Solution (Python):


a, b  = map(int, input().split())
print(a*b)

Solution (Python):
a=list(map(int,input().split()))
print(a[0]*a[1])

Solution (Python):
A, B = map(int, input().split())

print(A*B)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
a,b= map(int, input().split())
print(a*b)

Solution (Python):
A,B = map(int,input().split())
print(A*B)

Solution (Python):
a, b = list(map(int, input().split()))
print(a*b)

Solution (Python):
from decimal import Decimal
import math
A,B = input().split()
A=Decimal(A)
B=Decimal(B)
AB=math.floor(A*B)
print(AB)

Solution (Python):
input = input()
split = input.split()
out = int(split[0]) * int(split[1])
print(out)

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):
numA, numB = map(int, input().split())
print(numA * numB)

Solution (Python):
[a,b] = [int(x) for x in input().split()]

print(a*b)

Solution (Python):
a, b = map(int,input().split())
print(a*b)

Solution (Python):
A, B= map(int,input().split())
print(A*B)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
a,b = map(int,input().split())

print(a*b)

Solution (Python):
import math

A, B = map(float, input().split(' '))

if A*B > 0:
  print(math.floor(A*B))
else:
  print(int(A*B))

Solution (Python):
a,b=map(int,input().split())

print(a*b)

Solution (Python):
A, B = map(int, input().split())
print(A * B)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
input = input()
inputArr = input.split()
x = int(inputArr[0])
y = int(inputArr[1])
if x in range(1, 101):
  if y in range(1, 101):
    print(x*y)

Solution (Python):
A, B = map(int, input().split())
print(A * B)

Solution (Python):
A,B = map(int, input().split())
ans = A*B
print(ans)

Solution (Python):
A,B = map(int, input().split())
print(A*B)

Solution (Python):
a,c = map(int, input().split())
print(a*c)

Solution (Python):
A,B = map(int,input().split())
print(A*B)

Solution (Python):
a = list(map(int,input().split()))
print(a[0] * a[1])

Solution (Python):
a, b=map(int, input().split())
print(a*b)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
print(eval(input().replace(" ","*")))

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
a,b=[int(i) for i in input().split()]
print(a*b)

Solution (Python):
A, B = map(int, input().split())
print(A * B)

Solution (Python):
x,y = map(int,input().split())
print(x*y)

Solution (Python):
A,B = map(int,input().split())
print(A*B)

Solution (Python):
A,B = map(float,input().split())
A = int(A)
print(int(A * B))

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
a, b = tuple(map(int, input().split()))
print(a * b)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
a,b = map(int, input().split())
print(a*b)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
A, B = map(int, input().split())
C  = A * B
print(C)

Solution (Python):
a,b = map(int,input().split())
print(int(a*b))

Solution (Python):
a,b = map(int, input().split())

print( str(a*b)  )

Solution (Python):
A, B = (int(x) for x in input().split())
print(A*B)

Solution (Python):

a = list(map(int, input().split()))
c = 1
for b in a:
    c = c * b
print(c)

Solution (Python):
A, B = map(int, input().split())

print(A * B)

Solution (Python):
A, B = map(int, input().split())
print(A * B)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
i = list(map(int, input().split())) 
c = i[0]*i[1]
print(c)

Solution (Python):
A,B = map(int,input().split())

print(A*B)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
A,B = map(int,input().split())
print(int(A)*int(B))

Solution (Python):
A,B = map(int,input().split())

print(A*B)

Solution (Python):
A,B = input().split()
import math
A=int(A)
B=float(B)
print(math.floor(A*B))

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
A, B = map(int,input().split())
print(A*B)

Solution (Python):
A,B = map(int,input().split())
print(A*B)

Solution (Python):

import numpy as np
from functools import *
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline



def acinput():
    return list(map(int, input().split(" ")))

a,b=acinput()

print(a*b)

Solution (Python):
a,b=map(int,input().split())
print(a*b)

Solution (Python):
a, b= input("").split()
a = int(a)
b = int(b)
print(a*b)

Solution (Python):
A, B = map(int, input().split())

print(int(A * B))

Solution (Python):
a, b = map(int,input().split()) 
print(a * b)

Solution (Python):
a, b= input("").split()
a = int(a)
b = int(b)
print(a*b)

Solution (Python):
a, b = input().split(' ')
print(int(a) * int(b))

Solution (Python):
a, b = map(int, input().split())

print(a*b)

Solution (Python):
A,B=map(int,input().split())
print(A*B)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
s = input().split()
print(int(s[0]) * int(s[1]))

Solution (Python):
x,y = map(int,input().split()) 	
print(x*y)

Solution (Python):
import sys
input = sys.stdin.readline
import math



a,b = map(int,input().split())
print(a*b)

Solution (Python):
A,B=map(int,input().split())
A=A*B
print(int(A))

Solution (Python):
x = input()
a = int(x.split(' ')[0])
b = float(x.split(' ')[1])
  
b = 100*b

ans = a*b/100
  
print ((int(ans)))

Solution (Python):
A,B=map(int, input().split())

a = A*B
print(a)

Solution (Python):
A, B = [int(x) for x in input().split()]
print(A * B)

Solution (Python):
if __name__ == '__main__':
    inputline = input()
    parsed_input = inputline.split(" ")
    print(int(parsed_input[0]) * int(parsed_input[1]))

Solution (Python):
a,b=map(int, input().split())
print(a * b)

Solution (Python):
a, b = input().split()

print(int(a)*int(b))

Solution (Python):
a,b = map(int, input().split())
r = a * b
print(r)

Solution (Python):
a, b = map(int, input().split())
print(a * b)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):



input_1 = input()
a = int(input_1.split(" ")[0])
b = int(input_1.split(" ")[1])


print(a*b)

Solution (Python):
A,B = input().split()
print(int(A)*int(B))

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
n=input().split()
a=int(n[0])
b=int(n[1])
print(a*b)

Solution (Python):
a,b = map(float,input().split())
from fractions import Fraction
import math
print(math.floor(Fraction(a)*Fraction(b)))

Solution (Python):
A, B = list(map(int,input().split()))
print(int(A*B))

Solution (Python):
a,b = map(lambda x : int(x),input().split())
print(a*b)

Solution (Python):
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
a,b=pin()
print(a*b)

Solution (Python):
a, b = map(int, input().split())
print(a * b)

Solution (Python):
A, B = map(int, input().split())

print(A * B)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


def main():
    A, B = read_values()
    print(A * B)


if __name__ == "__main__":
    main()

Solution (Python):
A,B=map(int,input().split())
print(A*B)

Solution (Python):
a, b = map(int,input().split())
print(a*b)

Solution (Python):
print(eval(input().replace(' ','*')))

Solution (Python):
a, b = map(int,input().split())
print(a*b)

Solution (Python):
A, B = map(int, input().split())
print(int(A*B))

Solution (Python):
a,b = map(int,input().split())

print(a*b)

Solution (Python):
A, B = map(int, input().split())
print(A*B)

Solution (Python):
def a():
    A, B = map(int, input().split())
    print(A * B)



if __name__ == "__main__":
    a()

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *





































def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007




def main():
	A,B = inputMap()

	print(A*B)






def bisect_left_reverse(a, x):
    if a[0] <= x:
        return 0
    if x < a[-1]:
        return len(a)
    
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] <= x:
            ok = mid
        else:
            ng = mid
    return ok

def bisect_right_reverse(a, x):
    if a[0] < x:
        return 0
    if x <= a[-1]:
        return len(a)
    
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] < x:
            ok = mid
        else:
            ng = mid
    return ok





def binary_search(list, item):
    low = 0
    high = len(list) - 1

    while low <= high:
        mid = (low + high) //2
        guess = list[mid]
        if guess == item:
            return mid
        if guess > item:
            high = mid -1
        else:
            low = mid + 1
    return None




def sunuke(N, K, mod=10**9+7):
	if N < K or K-1 < 0:
		return 0
	else:
		return combination(N-1, K-1, mod)




def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y




def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)


class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv



def dfs(graph,parent,counter,edge):
    stk = []
    stk.append(edge)
    while len(stk) > 0:
        p = stk.pop()
        for e in graph[p]:
            if parent[p] == e:
                continue
            else:
                parent[e] = p
                counter[e] += counter[p]
                stk.append(e)



if __name__ == "__main__":
	main()

Solution (Python):
a, b = map(int, input().split(' '))
print(a*b)

Solution (Python):
a, b = map(int, input().split())

print(a * b)

Solution (Python):
A,B = input().split()
A = int(A)
B = int(B)
print(A*B)

Solution (Python):
a,b=map(int, input().split())
print(a*b)

Solution (Python):
A,B=map(int,input().split())
print(A*B)

Solution (Python):
A,B = map(int,input().split())
print(A*B)

Solution (Python):
a,b = map(int,input().split())
print(a*b)

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
a, b = map(int, input().split())

print(a*b)

Solution (Python):
s = input().split()
print(int(s[0])*int(s[1]))

Solution (Python):
a, b = map(int, input().split())
print(a*b)

Solution (Python):
a,b=map(int, input().split())
print(a*b)

Solution (Python):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))

from collections import defaultdict, deque
from sys import exit
import math
import copy
from bisect import bisect_left, bisect_right
from heapq import *
import sys

INF = 10 ** 17
MOD = 1000000007

from fractions import *
def inverse(f):
    
    return 1/f


def combmod(n, k, mod=MOD):
    ret = 1
    for i in range(n - k + 1, n + 1):
        ret *= i
        ret %= mod

    for i in range(1, k + 1):
        ret *= pow(i, mod - 2, mod)
        ret %= mod

    return ret
def bunsu(n):
    ret = []
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            tmp = 0
            while(True):
                if n % i == 0:
                    tmp += 1
                    n //= i
                else:
                    break
            ret.append((i, tmp))

    ret.append((n, 1))
    return ret

def solve():
    a,b = getList()
    print(a*b)
def main():
    
    
    solve()
if __name__ == "__main__":
    solve()