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):
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):
X = str(input())
em = 0
Return = []
for spam in range(len(X)):
    if X[spam] == " ":
        Return.append(int(X[em:spam]))
        em = spam+1
Return.append(int(X[em:]))
x = 1
for a in Return:
    x = x * a

print(x)

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, collections, copy, heapq, itertools, math, numpy, string
import sys
from bisect import bisect_left, bisect_right, insort
from collections import deque
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def MS(): return map(str, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())



a,b = MI()
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):
x,y = map(int,input().split())
print(x*y)

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 = 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 = input().strip().split(" ") ; 
A = int ( A ) ;
B = int ( B ) ; 
print ( int ( A * B ) ) ;

Solution (Python):
import math


def main():
    A, B = map(int, input().split())
    print(A*B)
 
 
if __name__ == '__main__':
    import sys
    sys.setrecursionlimit(10000)
    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=map(int,input().split())
print(A*B)

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

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

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

Solution (Python):
import math
def C():
    a, b = input().split()
    a = int(a)
    b = float(b)
    print(math.floor(a*b))
C()

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
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))



def read_a_int(): return int(read())


def read_ints(): return list(map(int, read().split()))


def read_col(H):
    '''H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_tuple(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_matrix(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  

A, B = read_ints()
print(A * B)

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):
s = input()
s = [int(i) for i in s.split()]
print(s[0]*s[1])

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

print(a*b)

Solution (Python):
import sys
sys.setrecursionlimit(300000)

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')


A, B = MI()
print(A * B)

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

Solution (Python):
A,B=input().strip().split()
A,B=[int(A),int(B)]    
if A>=1 and A<=100:
    if B>=1 and B<=100:
        print(A*B)

Solution (Python):
i = list(map(int, input().split()))
ans=i[0]*i[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):
line = input().rstrip()
line = line.split(' ')
A = int(line[0])
B = int(line[1])
print(A*B)

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())

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=(input().split())
a,b=int(a),int(b)

x=a*b
print(x)

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

Solution (Python):
def main():
    A, B = [int(value) for value in input().split(" ")]
    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):
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 = list(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):



import sys
from collections import deque as deq

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):
def mul3():
    m,n = map(float,input().split())
    return int(m*n)

if __name__ == "__main__":
    print(mul3())

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 8)
ni = lambda: int(sys.stdin.readline())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
ns = lambda: sys.stdin.readline().rstrip()

A, B = nm()


def solve():
    return A * B


print(solve())

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())
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):
import math
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())
print(A*B)

Solution (Python):
il = [int(k) for k in input().split()]
A = il[0]
B = il[1]

print(A*B)

Solution (Python):
one, two = map(int, input().split())
print(one * two)

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

Solution (Python):


import sys






























def main():
    mod = 1000000007                
    inf = float('inf')              
    
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a, b = mi()
    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):
a,b=(int(x) for x in input().split())

result = a * b
print(result)

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

Solution (Python):
n, m = map(int, input().split(' '))

print(n * m)

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 = list(map(int,input().split(" ")))

print(A*B)

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

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

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

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

print(a*b)

Solution (Python):


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


if __name__ == '__main__':
    main()

Solution (Python):
i = input()
sp = i.split(' ')

if int(sp[0]) < 0 and int(sp[0]) > 100:
  pass
if int(sp[1]) < 0 and int(sp[1]) > 100:
  pass
else:
  print(int(sp[0]) * int(sp[1]))

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

s = a * b

print(s)

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

Solution (Python):




text = input()



num_data = text.split(' ')


print(int(num_data[0]) * int(num_data[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):
x, y = map(int,input().split())
z = x * y
print(z)

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

Solution (Python):
import sys

def main():
    a, b = map(int, sys.stdin.readline().split())
    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):
Left, Right = map(int,input().split())
Answer = Left * Right
print(Answer)

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

Solution (Python):
import math
n, m = map(str, input().split())
answer = int(n) * float(m)
print(math.floor(answer))

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):
line=input().split()
line=[int(i) for i in line]

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

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



if __name__ == '__main__':
    main()

Solution (Python):
import math
C, D = map(int, input().split())


print(C*D)

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().rstrip().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):
import sys
a, b = [int(x) for x in sys.stdin.readline().split(" ")]
print(a * b)

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

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

if 1 <= int(N[0]) <= 100 and 1 <= int(N[1]) <= 100:
    S = int(N[0]) * int(N[1])
    print(S)
else:
    print("choose value between 1 to 100")

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=input()
a=a.split()

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

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

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 = input().split(" ")

print(int(a[0])*int(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 = list(map(int, input().split(' ')))
print(a * b)

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

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

Solution (Python):

import sys
read = sys.stdin.buffer.read

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

print(A * B)

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

print(a*b)

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

print(int(C))

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

Solution (Python):
x,y = input().split()
print(int(x)*int(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 = 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=[int(i) for i in input().split()]
print(a*b)

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

Solution (Python):
l=input().rstrip().rsplit(" ")
print(int(l[0])*int(l[1]))

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

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

Solution (Python):
def LI():
    return list(map(int, input().split()))

a, b = LI()

def main():
    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):
n, m= map(int, input().split())
print(n*m)

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 = list(map(int, input().split()))

print(AB[0]*AB[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):
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=map(int,input().split())
print(A*B)

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())
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):


LI = lambda: list(map(int, input().split()))


A, B = LI()


def main():
    ans = A * B
    print(ans)


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):
def resolve():
    A, B = map(int, input().split())
    ans = A*B
    print(ans)
resolve()

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

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

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):
def solve(A, B):
    print(A * B)


if __name__ == '__main__':
    A, B = map(int, input().split())
    solve(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(eval(input().replace(' ','*')))

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

Solution (Python):


p = 1

flag = False
n = input().split()
for i in n:
    x = int(i)
    p = p * x
    if p > 1000000000000000000:
        flag = True
        p = 1

if flag:
    print(-1)
else:
    print(p)

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 = [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 = list(map(int, input().split()))
print(a[0] * a[1])

Solution (Python):

import sys, io, os, re
import bisect
from pprint import pprint
from math import sin, cos, pi, radians, sqrt
from copy import copy, deepcopy
from collections import deque
from fractions import gcd

def array1(n): return [0] * n
def array2(n, m): return [[0] * m for x in range(n)]
def array3(n, m, l): return [[[0] * l for y in xrange(m)] for x in xrange(n)]



a, b = map(int, sys.stdin.readline().strip().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):

L,R = map(int,input().split())

ans = L*R
print(ans)

Solution (Python):
n,m = map(int, input().split())
print(n*m)

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=list(map(int,input().split()))
print(A*B)

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

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,M ] = map(int,input().split())
print(N*M)

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, b = [int(x) for x in input().split(" ")]

mult = a * b

print(mult)

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):
a, b = input().split()
print(int(a) * int(b))

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

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):
aaa = list(map(int, input().split()))

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

Solution (Python):
i = list(map(int, input().split()))
print(i[0]*i[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):
x,y = map(int,input().split())
print(x*y)

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):
n,m = map(int,input().split())
ans = 0
ans = m*n
print(ans)

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

Solution (Python):
def main():
    
    a = list( map( int, input().split()))
    sum = 1
    print(a[0]*a[1])
    
if __name__ == '__main__':
    main()

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

Solution (Python):
L, R = input().split()
print(int(L)*int(R))

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 =(int(x) for x in input().split())
print(A*B)

Solution (Python):
from sys import stdin

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

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

print(a*b)

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

ans = 1

for num in arr:
	ans *= num
	
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):

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

Solution (Python):
import sys,bisect,string,math,time,functools,random,fractions
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
rep=range
def Golf():n,*t=map(int,open(0).read().split())
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def RA():return map(int,open(0).read().split())
def GI(V,E,ls=None,Directed=False,index=1):
    org_inp=[];g=[[] for i in range(V)]
    FromStdin=True if ls==None else False
    for i in range(E):
        if FromStdin:
            inp=LI()
            org_inp.append(inp)
        else:
            inp=ls[i]
        if len(inp)==2:
            a,b=inp;c=1
        else:
            a,b,c=inp
        if index==1:a-=1;b-=1
        aa=(a,c);bb=(b,c);g[a].append(bb)
        if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'

    mp=[boundary]*(w+2);found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
    mp+=[boundary]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def accum(ls):
    rt=[0]
    for i in ls:rt+=[rt[-1]+i]
    return rt
def bit_combination(n,base=2):
    rt=[]
    for tb in range(base**n):s=[tb//(base**bt)%base for bt in range(n)];rt+=[s]
    return rt
def gcd(x,y):
    if y==0:return x
    if x%y==0:return y
    while x%y!=0:x,y=y,x%y
    return y
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)
 
YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
l_alp=string.ascii_lowercase

read=sys.stdin.buffer.read
readline=sys.stdin.buffer.readline
input=lambda: sys.stdin.readline().rstrip()


class Tree:
    def __init__(self,inp_size=None,ls=None,init=True,index=0):
        self.LCA_init_stat=False
        self.ETtable=[]
        if init:
            if ls==None:
                self.stdin(inp_size,index=index)
            else:
                self.size=len(ls)+1
                self.edges,_=GI(self.size,self.size-1,ls,index=index)
        return
 
    def stdin(self,inp_size=None,index=1):
        if inp_size==None:
            self.size=int(input())
        else:
            self.size=inp_size
        self.edges,_=GI(self.size,self.size-1,index=index)
        return
    
    def listin(self,ls,index=0):
        self.size=len(ls)+1
        self.edges,_=GI(self.size,self.size-1,ls,index=index)
        return
 
    def __str__(self):
        return  str(self.edges)
 
    def dfs(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
        q=deque()
        q.append(x)
        v=[-1]*self.size
        v[x]=root_v
        while q:
            c=q.pop()
            for nb,d in self.edges[c]:
                if v[nb]==-1:
                    q.append(nb)
                    v[nb]=func(v[c],nb,d)
        return v
 
    def EulerTour(self,x):
        q=deque()
        q.append(x)
        self.depth=[None]*self.size
        self.depth[x]=0
        self.ETtable=[]
        self.ETdepth=[]
        self.ETin=[-1]*self.size
        self.ETout=[-1]*self.size
        cnt=0
        while q:
            c=q.pop()
            if c<0:
                ce=~c
            else:
                ce=c
                for nb,d in self.edges[ce]:
                    if self.depth[nb]==None:
                        q.append(~ce)
                        q.append(nb)
                        self.depth[nb]=self.depth[ce]+1
            self.ETtable.append(ce)
            self.ETdepth.append(self.depth[ce])
            if self.ETin[ce]==-1:
                self.ETin[ce]=cnt
            else:
                self.ETout[ce]=cnt
            cnt+=1
        return
    
    def LCA_init(self,root):
        self.EulerTour(root)
        self.st=SparseTable(self.ETdepth,init_func=min,init_idl=inf)
        
        self.LCA_init_stat=True
        return
    
    def LCA(self,root,x,y):
        if self.LCA_init_stat==False:
            self.LCA_init(root)
        xin,xout=self.ETin[x],self.ETout[x]
        yin,yout=self.ETin[y],self.ETout[y]
        a=min(xin,yin)
        b=max(xout,yout,xin,yin)
        id_of_min_dep_in_et=self.st.query_id(a,b+1)
        return self.ETtable[id_of_min_dep_in_et]




class SparseTable: 
    def __init__(self,ls,init_func=min,init_idl=float('inf')):
        self.func=init_func
        self.idl=init_idl
        self.size=len(ls)
        self.N0=self.size.bit_length()
        self.table=[ls[:]]
        self.index=[list(range(self.size))]
        self.lg=[0]*(self.size+1)
        
        for i in range(2,self.size+1):
            self.lg[i]=self.lg[i>>1]+1
 
        for i in range(self.N0):
            tmp=[self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) for j in range(self.size)]
            tmp_id=[self.index[i][j] if self.table[i][j]==self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) else self.index[i][min(j+(1<<i),self.size-1)] for j in range(self.size)]
            self.table+=[tmp]
            self.index+=[tmp_id]
    
    
    def query(self,l,r):
        if r>self.size:r=self.size
        
        N=self.lg[r-l]
        return self.func(self.table[N][l],self.table[N][max(0,r-(1<<N))])
    
    
    def query_id(self,l,r):
        if r>self.size:r=self.size
        
        N=self.lg[r-l]
        a,b=self.index[N][l],self.index[N][max(0,r-(1<<N))]
        if self.table[0][a]==self.func(self.table[N][l],self.table[N][max(0,r-(1<<N))]):
            b=a
        return b
    
    
    def right_bound(self,pos,x):
        k=(self.size-pos).bit_length()
        for j in range(k)[::-1]:
            nx=pos+(1<<j)
            if nx<n and self.query(pos,nx+1)<=x:
                pos+=(1<<j)
        return pos
    
    
    def left_bound(self,pos,x):
        k=pos.bit_length()
        for j in range(k)[::-1]:
            nx=pos-(1<<j)
            if 0<=nx and self.query(nx,pos+1)<=x:
                pos-=(1<<j)
        return pos

    def __str__(self):
        return str(self.table[0])
 
    def print(self):
        for i in self.table:
            print(*i)
 



def primeFactor(N):
    i,n=2,N
    ret={}
    d,sq=2,99
    while i<=sq:
        k=0
        while n%i==0:
            n,k,ret[i]=n//i,k+1,k+1
        if k>0 or i==97:
            sq=int(n**(1/2)+0.5)
        if i<4:
            i=i*2-1
        else:
            i,d=i+d,d^6
    if n>1:
        ret[n]=1
    return ret




def PrimeNumSet(N):
    Max = int(N**0.5)
    seachList = [i for i in range(2,N+1)]
    primeNum = []
    while seachList:
        if seachList[0] <= Max:
            break
        primeNum.append(seachList[0])
        tmp = seachList[0]
        seachList = [i for i in seachList if i % tmp != 0]
    primeNum.extend(seachList)
    return primeNum



def LCM(b,mo=10**9+7):
    prs=PrimeNumSet(max(b))
    M=dict(zip(prs,[0]*len(prs)))
    for i in b:
        dc=primeFactor(i)
        for j,k in dc.items():
            M[j]=max(M[j],k)
    
    r=1
    for j,k in M.items():
        if k!=0:
            r*=pow(j,k,mo)
            r%=mo
    return r

 
show_flg=False
show_flg=True
ans=0


a,b=LI()
ans=a*b
print(ans)

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

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

Solution (Python):


A,B=input().split()

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

Solution (Python):
import sys
readline=sys.stdin.readline
 
A,B=map(int,readline().split())
print(A * B)

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

print(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):
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()
getcontext().prec = 400

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

Solution (Python):
import sys
input = sys.stdin.readline
import numpy as np

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


print(int(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())
1 <= A <= 100
1 <= B <= 100
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):
in_d = input()

a, b = in_d.split()
a = int(a)
b = int(b)

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):
def main():
    a, b = [int(v) for v in input().split(' ')]
    print(int(a * b))


if __name__ == '__main__':
    main()