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

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


main()

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

Solution (Python):
import sys
input = sys.stdin.readline
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 = [int(i) for i in input().split()]
print(a*b)

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

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

readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip() 
ni = lambda: int(readline().rstrip()) 
nm = lambda: map(int, readline().split()) 
nl = lambda: list(map(int, readline().split())) 

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

def intinp():
    return int(input())

A, B = mapint_inp()

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 = list(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().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 = 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):
import sys


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


sys.setrecursionlimit(20000000)

MOD = 10 ** 9 + 7
INF = float("inf")


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 bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub


import sys


buff_readline = sys.stdin.readline
readline = sys.stdin.readline

INF = 2**62-1


def read_int():
    return int(buff_readline())


def read_int_n():
    return list(map(int, buff_readline().split()))


def read_float():
    return float(buff_readline())


def read_float_n():
    return list(map(float, buff_readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()

def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(A, B):
    return A * B


def main():
    A, B = read_int_n()
    print(slv(A, B))


if __name__ == '__main__':
    main()

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, end="")

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
input = sys.stdin.readline
sys.setrecursionlimit(200000)


def read():
    A, B = map(int, input().strip().split())
    return A, B


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


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))

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


def main():
    input = sys.stdin.buffer.readline
    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











 
sys.setrecursionlimit(10**9)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod1=998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]








 
def MI(): return map(int, inp().strip().split())
def LI(): return list(map(int, inp().strip().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]
def LI_(): return [int(x)-1 for x in inp().strip().split()] 
def LF(): return [float(x) for x in inp().strip().split()] 
def LS(): return inp().strip().split() 
def I(): return int(inp().strip()) 
def F(): return float(inp().strip()) 
def S(): return inp().strip() 
def pf(s): return out(s+'\n')
def JA(a, sep): return sep.join(map(str, a)) 
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def modinv(n,p):return pow(n,p-2,p)
def ncr(n,r,p):                      
    t=((fact[n])*((ifact[r]*ifact[n-r])%p))%p
    return t


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

def main():
    solve()


py2 = round(0.5)
if py2:
    from future_builtins import ascii, filter, hex, map, oct, zip
    range = xrange

import os, sys
from io import IOBase, BytesIO

BUFSIZE = 8192
class FastIO(BytesIO):
    newlines = 0
    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.writable = "x" in file.mode or "w" in file.mode
        self.write = super(FastIO, self).write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
        return s
    def read(self):
        while self._fill(): pass
        return super(FastIO,self).read()

    def readline(self):
        while self.newlines == 0:
            s = self._fill(); self.newlines = s.count(b"\n") + (not s)
        self.newlines -= 1
        return super(FastIO, self).readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.getvalue())
            self.truncate(0), self.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        if py2:
            self.write = self.buffer.write
            self.read = self.buffer.read
            self.readline = self.buffer.readline
        else:
            self.write = lambda s:self.buffer.write(s.encode('ascii'))
            self.read = lambda:self.buffer.read().decode('ascii')
            self.readline = lambda:self.buffer.readline().decode('ascii')

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

inp = lambda: sys.stdin.readline().rstrip('\r\n')
out = lambda x: sys.stdout.write(x)
flsh= lambda: sys.stdout.flush()

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


iim = lambda: map(int, input().rstrip().split())

def resolve():
    A, B = iim()
    print(A*B)

if __name__ == "__main__":
    resolve()

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

A,B = LI()
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):
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=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):
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):
print(eval(input().replace(" ","*")))

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 = [int(n) for n 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 = [int(n) for n 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):
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**7) 
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque 


from collections import Counter

from itertools import accumulate

from heapq import heapify,heappop,heappush


from functools import lru_cache


def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 10**9+7
    

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

    print(N*K)




if __name__ == "__main__":
    main()

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

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

Solution (Python):

def main():
    
    
    n, m = map(int, input().split())
    print(n*m)

if __name__ == "__main__":
    main()

Solution (Python):
from math import gcd, sqrt, cos, radians, pi
from collections import defaultdict as d
from itertools import combinations as c


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

    print(A * B)


resolve()

Solution (Python):

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

print(A* B)

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

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

Solution (Python):
import sys



S,T = map(int, input().split())













print(S*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):
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 













mod = int(1e9+7)

INF = 1<<29
lINF = 1<<35

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

def main():
    a,b = readInt()
    print(a*b)
    return

if __name__=='__main__':
    main()

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

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

print(N*K)

Solution (Python):
import sys 
input = lambda : sys.stdin.readline().strip()
a,b = map(int,input().split())
print(a*b)

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


'''
A=[]
B=[]
for i in range():
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)'''

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

Solution (Python):
import sys
from io import StringIO
import unittest


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


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """2 5"""
        output = """10"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """100 100"""
        output = """10000"""
        self.assertIO(input, output)


if __name__ == "__main__":
    
    resolve()

Solution (Python):
from collections import defaultdict, deque
import sys
import heapq
import bisect
import itertools
import queue
import copy
import time
import math
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7

def inp(): return int(sys.stdin.readline())

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

def inpl_str(): return list(sys.stdin.readline().split())

a,b = inpl()
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 = (int(i) for i 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())
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 = list(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(10**8)
INF = float("inf")


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


if __name__ == '__main__':
    main()

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

print(n*k)

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

print(A*B)

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

a,b=MI()
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):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


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 -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 __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



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

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

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

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

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

import math

import logging

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)


def resolve():
    
    
    A, B = [int(x) for x in sys.stdin.readline().split()]  
    

    
    
    
    

    logger.debug('{}'.format([]))
    print(A * B)


if __name__ == "__main__":
    resolve()





import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """2 5"""
        output = """10"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """100 100"""
        output = """10000"""
        self.assertIO(input, output)

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

Solution (Python):
import sys


RS = lambda: sys.stdin.readline()[:-1]
RI = lambda x=int: x(RS())
RA = lambda x=int: map(x, RS().split())
RSS = lambda: RS().split()


def solve():
    print(a*b)
    return


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

Solution (Python):
from math import *

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

def cins(): 
    return input.split()

def cino(test=False): 
    if not test:
        return int(input())
    else: 
        return input()

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

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

def printlist(l): 
    for i in l:
        print(i,end=" ")

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


if __name__ == '__main__':
    main()

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

Solution (Python):
temp = input()
[a, b] = [int(comp) for comp in temp.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):

MOD = 10 ** 9 + 7
INFI = 10**10

import math
from collections import deque
import itertools
import heapq

from fractions import Fraction
import copy
from functools import lru_cache



def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default




def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)



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 = input('')
a = int(ab.split(' ')[0])
b = int(ab.split(' ')[1])

print(a*b)

Solution (Python):
[a, b] = list(map(int, input().split()))
print(int(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):
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

INF = float("inf")











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

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

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):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce, lru_cache  
from fractions import gcd
import sys
def input(): return sys.stdin.readline().rstrip()
def I(): return int(input())
def Is(): return (int(x) for x in input().split())
def LI(): return list(Is())
def TI(): return tuple(Is())
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()
def LS(): return list(S())
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(10**6)
MOD = 10**9+7
INF = 10**18


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

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

print(A*B)

Solution (Python):
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
   
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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):
    return A * B



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

def test():
    import doctest
    doctest.testmod()

if __name__ == '__main__':
    
    main()

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

Solution (Python):
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction



mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]








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

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

print(a*b)