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

Solution (Python):

def main():
    A, B =tuple(int(c) for c in input().split(' '))
    print(A*B)


if __name__ == "__main__":
    main()

Solution (Python):
from sys import stdin, setrecursionlimit


def main():
    input = stdin.buffer.readline
    a, b = map(int, input().split())
    print(a * b)


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

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

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

Solution (Python):

import sys


def solve(A: int, B: int):
    print(A*B)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(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,K=map(int,input().split())
print(N*K)

Solution (Python):
b,c = map(int,input().split())
print(b*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 sys
sys.setrecursionlimit(10**6)

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 = [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):
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right


from functools import reduce
from pprint import pprint

INF = float("inf")

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col,reverse_flag):
    data.sort(key=lambda x:x[col],reverse=reverse_flag)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def mycount(ls,x):
    
    l = bisect_left(ls,x)
    r = bisect_right(ls,x)
    return (r-l)

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

def I():
    return int(input())

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

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

def CI(n):
    return [ int(input()) for _ in range(n) ]

def LI(n):
    return [ list(map(int,input().split())) for _ in range(n) ]

def S():
    return input()

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

def RS():
    return list(input().split())

def CS(n):
    return [ input() for _ in range(n) ]

def LS(n):
    return [ list(input().split()) for _ in range(n) ]

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

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

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

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

Solution (Python):

import numpy as np
from collections import deque
import collections
import heapq

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

import math


def inp():
    return(int(input()))



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



def instr():
    s = input()
    return(list(s[:len(s)]))



def invr():
    return(map(int, input().split()))


a, b = invr()

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

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


def _ia(): return map(int, sys.stdin.readline().strip().split())


def main():
    a, b = _ia()
    return a * b


if __name__ == "__main__":
    print(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):
import sys
a,b = map(int, sys.stdin.readline().rstrip("\n").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):
import sys
sys.setrecursionlimit(10 ** 8)

def Z(): return int(input())
def ZZ(): return [int(_) for _ in input().split()]

def main():
    a, b = ZZ()
    print(a*b)

    return

if __name__ == '__main__':
    main()

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

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

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

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())
print(a*b)

Solution (Python):
import sys

readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prl = lambda x: print(*x ,sep='\n')

n,m = nm()

print(n*m)

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):
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
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))


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

Solution (Python):
from sys import stdin


def main():
    _in = [_.rstrip() for _ in stdin.readlines()]
    A,B = list(map(int,_in[0].split(' ')))  
    
    cnt = A*B
    
    print(cnt)


if __name__ == "__main__":
    main()

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



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

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

Solution (Python):
import sys, math,os
from io import BytesIO, IOBase


from collections import defaultdict as dd, deque, Counter

def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7


def main():

    a,b=mdata()
    out(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):
def main():
    A, B = map(int, input().split())

    print(A*B)


if __name__ == "__main__":
    main()

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

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

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):
i,j=map(int,input().split())
print(i*j)

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):
import sys

X, Y = map(int, sys.stdin.readline().rstrip().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):
from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
import bisect
import numpy as np
import math
from collections import deque
from collections import defaultdict
from math import gcd

N, M = map(int, input().split())


print(N*M)

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

Solution (Python):
import sys



N, K = map(int, sys.stdin.readline().rstrip().split())

print(N*K)

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
sys.setrecursionlimit(10**7)

readline = sys.stdin.buffer.readline
def readstr():return readline().rstrip().decode()
def readstrs():return list(readline().decode().split())
def readint():return int(readline())
def readints():return list(map(int,readline().split()))
def printrows(x):print('\n'.join(map(str,x)))
def printline(x):print(' '.join(map(str,x)))

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

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

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

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 = sys.stdin.readline

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):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, cos, radians, pi, sin
from operator import mul
from functools import reduce
from operator import mul

mod = 10 ** 9 + 7
INF = 10 ** 13
sys.setrecursionlimit(2147483647)
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]

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

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

def input():
    return sys.stdin.readline().strip()


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]


def get_all_int():
    return map(int, open(0).read().split())

def rangeI(it, l, r):
    for i, e in enumerate(it):
        if l <= i < r:
            yield e
        elif l >= r:
            break

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

INF = 999999999999999999999999
MOD = 10**9+7

a,b = get_nums_l()

print(a*b)

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

Solution (Python):
import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline



def geta(fn=lambda s: s.decode()):
    return map(fn, readline().split())


def gete(fn=lambda s: s.decode()):
    return fn(readline().rstrip())


def main():
    a, b = geta(int)
    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=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):
a, b = map(int, input().split())

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

if __name__ == '__main__':
    main()

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

print(a*b)

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

"""

"""

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

Solution (Python):
import sys
from math import log2,floor,ceil,sqrt






















Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
 
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7

a,b = Ri()
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):
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()
print(a*b)

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

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

main()

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):
N, M = [int(i) for i in 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):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)
    A, B = [int(x) for x in input().strip().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):
def main():
    import sys
    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):
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):
a,b=map(int,input().split())
print(a*b)

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

Solution (Python):


import sys
import math
from collections import Counter
import itertools
import fractions




def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())

def LI(): return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")


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

Solution (Python):
"""    Arnab Chanda    """

from collections import defaultdict, deque
from itertools import permutations
from sys import stdin,stdout
from bisect import bisect_left, bisect_right
from copy import deepcopy
import heapq

int_input=lambda : int(stdin.readline())
string_input=lambda : stdin.readline().split()
multi_int_input =lambda : map(int, stdin.readline().split())
multi_input = lambda : stdin.readline().split()
list_input=lambda : list(map(int,stdin.readline().split()))
string_list_input=lambda: list(string_input())
MOD = pow(10,9)+7

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

Solution (Python):
import sys

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


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


if __name__ == '__main__':
    solve()

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):
def examA():
    A, B = LI()
    ans = A*B
    print(ans)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 1<<60
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examA()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

Solution (Python):
import math

import queue
from collections import deque,defaultdict
import heapq
from sys import stdin,setrecursionlimit


ipt = stdin.readline
setrecursionlimit(10**7)

a,b = map(int,ipt().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) = [int(n) for n in input().split()]
print(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):

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

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

Solution (Python):
import math
from collections import defaultdict
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:list(input())

"""========main code==============="""

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

Solution (Python):



def main():
    a, b = map(int, input().split())
    return a*b


print(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):
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
import math
import itertools
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
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

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

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):
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(num) for num in input().split())
print(a*b)

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

print(a*b)

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline


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




print(a*b)

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

Solution (Python):



import sys
from collections import defaultdict, deque
from heapq import heappush, heappop
import math
import bisect
input = sys.stdin.readline




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

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

A, B = lr()
answer = A * B
print(answer)

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

Solution (Python):
import sys, re
import math
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul	
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd	
from heapq import heappush, heappop

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7



n, m = MAP()
print(n*m)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
mod = 10**9+7

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):
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):
if __name__ == "__main__":
    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):
import sys
input = sys.stdin.readline

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

print(n*m)

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):
import math
from collections import deque
from collections import defaultdict

import time


def readInt():
	return int(input())
def readInts():
	return list(map(int, input().split()))
def readChar():
	return input()
def readChars():
	return input().split()
def factorization(n):
	res = []
	if n%2==0:
		res.append(2)
	for i in range(3,math.floor(n//2)+1,2):
		if n%i==0:
			c = 0
			for j in res:
				if i%j==0:
					c=1
			if c==0:
				res.append(i)
	return res
def fact2(n):
	p = factorization(n)
	res = []
	for i in p:
		c=0
		z=n
		while 1:
			if z%i==0:
				c+=1
				z/=i
			else:
				break
		res.append([i,c])
	return res
def fact(n):
	ans = 1
	m=n
	for _i in range(n-1):
		ans*=m
		m-=1
	return ans
def comb(n,r):
	if n<r:
		return 0
	l = min(r,n-r)
	m=n
	u=1
	for _i in range(l):
		u*=m
		m-=1
	return u//fact(l)
def combmod(n,r,mod):
	return (fact(n)/fact(n-r)*pow(fact(r),mod-2,mod))%mod
def printQueue(q):
	r=copyQueue(q)
	ans=[0]*r.qsize()
	for i in range(r.qsize()-1,-1,-1):
		ans[i] = r.get()
	print(ans)
class UnionFind():
	def __init__(self, n):
		self.n = n
		self.parents = [-1]*n

	def find(self, x): 
		if self.parents[x]<0:
			return x
		else:
			self.parents[x] = self.find(self.parents[x])
			return self.parents[x]

	def union(self,x,y):
		x = self.find(x)
		y = self.find(y)

		if x==y:
			return

		if self.parents[x]>self.parents[y]:
			x,y = y,x

		self.parents[x]+=self.parents[y]
		self.parents[y]=x

	def size(self,x):
		return -1*self.parents[self.find(x)]

	def same(self,x,y):
		return self.find(x)==self.find(y)

	def members(self,x): 
		root = self.find(x)
		return [i for i in range(self.n) if self.find(i)==root]

	def roots(self):
		return [i for i,x in enumerate(self.parents) if x<0]

	def group_count(self):
		return len(self.roots())

	def all_group_members(self):
		return {r: self.members(r) for r in self.roots()} 
def bitArr(n):
	x = 1
	zero = "0"*n
	ans = []
	ans.append([0]*n)
	for i in range(2**n-1):
		ans.append(list(map(lambda x:int(x),list((zero+bin(x)[2:])[-1*n:]))))
		x+=1
	return ans;
def arrsSum(a1,a2):
	for i in range(len(a1)):
		a1[i]+=a2[i]
	return a1
def maxValue(a,b,v):
	v2 = v
	for i in range(v2,-1,-1):
		for j in range(v2//a+1): 
			k = i-a*j
			if k%b==0:
				return i
	return -1
def copyQueue(q):
	nq = queue.Queue()
	n = q.qsize()
	for i in range(n):
		x = q.get()
		q.put(x)
		nq.put(x)
	return nq

a,b = readInts()

print(a*b)

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

Solution (Python):
def main():
    import sys
    sys.setrecursionlimit(10**9)
    input = sys.stdin.readline

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