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

Solution (Python):

import sys
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

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

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

ans = A * B
print(ans)

Solution (Python):
from sys import stdin

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

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

Solution (Python):
try:
    A_s,B_s = input().split(' ')
    A=int(A_s)
    B=int(B_s)
    
    if A>=1 and A<=100 and B>=1 and B<=100:
        print(A*B)
    
    
except Exception as e:
    print(e)

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

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

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

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):
getinput = input()
getinput = getinput.split()
first = int(getinput[0])
second = int(getinput[1])
print(first * second)

Solution (Python):
import sys

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(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):
str = input()

str2 = str.split(" ")

res = 1
for str3 in str2:
    res *= int(str3)

print(res)

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

Solution (Python):

A, B = map(int, 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] = [int(s) for s in 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())
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):

from __future__ import division, print_function
from collections import defaultdict, Counter, deque
from future_builtins import ascii, filter, hex, map, oct, zip
from itertools import imap as map, izip as zip, permutations, combinations, combinations_with_replacement
from __builtin__ import xrange as range
from math import ceil, factorial, log,tan,pi,cos,sin,radians
from _continuation import continulet
from cStringIO import StringIO
from io import IOBase
import __pypy__
from bisect import bisect, insort, bisect_left, bisect_right
from fractions import Fraction
from functools import reduce
from decimal import *
import string
import sys
import os
import re
inf = float('inf')
mod_ = int(1e9) + 7
mod = 998244353

def factors(n):
    from functools import reduce
    return set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))

def sieve(m):
    n=1
    primes = {}
    arr=set([])
    for i in range(2, int(m ** 0.5) + 1):
        a = n // i
        b = m // i
        for k in range(max(2, a), b + 1):
            c = i * k
            primes[c] = 1

    for i in range(max(n, 2), m + 1):
        if i not in primes:
            arr.add(i)

    return arr


class DisjointSetUnion:
    def __init__(self, n):
        self.parent = list(range(n))
        self.size = [1] * n
        self.num_sets = n
 
    def find(self, a):
        acopy = a
        while a != self.parent[a]:
            a = self.parent[a]
        while acopy != a:
            self.parent[acopy], acopy = a, self.parent[acopy]
        return a
 
    def union(self, a, b):
        a, b = self.find(a), self.find(b)
        if a != b:
            if self.size[a] < self.size[b]:
                a, b = b, a
 
            self.num_sets -= 1
            self.parent[b] = a
            self.size[a] += self.size[b]
 
    def set_size(self, a):
        return self.size[self.find(a)]
 
    def __len__(self):
        return self.num_sets



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












    





BUFSIZE = 8192

class FastI(IOBase):
    def __init__(self, file):
        self._fd = file.fileno()
        self._buffer = StringIO()
        self.newlines = 0

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count("\n") + (not b)
            ptr = self._buffer.tell()
            self._buffer.seek(0, 2), self._buffer.write(b), self._buffer.seek(ptr)
        self.newlines -= 1
        return self._buffer.readline()


class FastO(IOBase):
    def __init__(self, file):
        self._fd = file.fileno()
        self._buffer = __pypy__.builders.StringBuilder()
        self.write = lambda s: self._buffer.append(s)

    def flush(self):
        os.write(self._fd, self._buffer.build())
        self._buffer = __pypy__.builders.StringBuilder()


def print(*args, **kwargs):
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

sys.stdin, sys.stdout = FastI(sys.stdin), FastO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

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

print(a*b)

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

ans = A * B

print(ans)

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

Solution (Python):


import math
import re
import numpy as np

S = input().split(" ")
A = int(S[0])
B = int(S[1])

ans = A * B

print(ans)

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):
import sys
import math
from collections import deque
import heapq
import itertools
MAX_INT = int(10e25)
MIN_INT = -MAX_INT
mod = 1000000000+7
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

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

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

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

print(a*b)

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

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

Solution (Python):
Num1, Num2 = map(int,input().split())
print(Num1 * Num2)

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

if __name__ == '__main__':
    main()

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

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


if __name__=='__main__':
    a,b=readinput()
    ans=main(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(str(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())
kotae = a*b
print(kotae)

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

n1, n2 = map(int, input().split())
print(n1 * n2)

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(lambda x: int(x), 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())

res = a * b

print(res)

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

Solution (Python):

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

if __name__ == "__main__":
  resolve()

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().strip().split())
print(A*B)

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp



class UnionFindEx:
    def __init__(self, size):
        
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


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



main()

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

A = int(S[0])
B = int(S[1])

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):
data = input().rstrip().split(" ")
A = int(data[0])
B = int(data[1])
print(A*B)

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


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


BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

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


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        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)
input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

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

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


if __name__ == '__main__':
    main()

Solution (Python):


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




print(N * K)

Solution (Python):


import collections
import itertools
from functools import lru_cache
import sys
import math


MOD = int(1e9)+7


def helper():
	pass


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



t = 1
for _ in range(t):
	solve()

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

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

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

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

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

A = int(A)
B = int(B)

print(A * B)

Solution (Python):
temp1 = input().split(" ")
n = int(temp1[0])
m = int(temp1[1])

print(n * m)

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


MODE = 1


DIMENSION = 1


INT_TYPE = 1

if not (MODE):
    with open("input.txt", "r") as f:
        s = f.read()
else:
    s = sys.stdin.read()

if DIMENSION == 0:
    if INT_TYPE == 1:
        s = int(s)
elif DIMENSION == 1:
    if INT_TYPE == 0:
        s = s.split()
    elif INT_TYPE == 1:
        s = [int(x) for x in s.split()]
elif DIMENSION == 2:
    if INT_TYPE == 0:
        s = [x.split() for x in s.splitlines()]
    elif INT_TYPE == 1:
        s = [[int(y) for y in x.split()] for x in s.splitlines()]

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

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

Solution (Python):
s = str(input())
d = s.split()
a = int(d[0])
b = int(d[1])
c = a * b 
print(c)

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

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

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

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

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

ans = int(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):
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("{}".format(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):
import math
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())
ans = A*B
print(ans)

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

import sys
input = sys.stdin.readline

A,B = (int(x) for x in 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())

c=a*b
print(c)

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

print(x*y)

Solution (Python):


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

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


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

Solution (Python):
from __future__ import division, print_function

''' Hey stalker :) '''
INF = 10 ** 10
TEST_CASES = False
from collections import defaultdict, Counter

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


''' FastIO Footer: PyRival Library, Thanks @c1729 and contributors '''
import os
import sys
from bisect import bisect_left, bisect_right
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

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


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        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")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)



input = lambda: sys.stdin.readline().rstrip("\r\n")
get_int = lambda: int(input())
get_list = lambda: list(map(int, input().split()))
if __name__ == "__main__":
    if TEST_CASES:
        [main() for _ in range(int(input()))]
    else:
        main()

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

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=[int(a) for a 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):
def intMap(): return map(int,input().split())
def intList(): return list(map(int, input().split())) 
def intListVertical(): [int(input()) for _ in range(N)] 




a,b = intMap()



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

x=a*b

print(x)

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

Solution (Python):

A, B = [int(x) for x in input().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):
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):

from collections import deque
from operator import itemgetter
from bisect import bisect_left, bisect
import itertools
import sys
import math
import numpy as np
import time
sys.setrecursionlimit(10**6)
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=map(int,input().split())
print(a*b)

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

print(A*B)

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

print(A * B)

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

Solution (Python):
import sys

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

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):
from sys import stdin
from copy import deepcopy

def S(): return stdin.readline().rstrip()
def I(): return int(stdin.readline().rstrip())
def LS(): return list(stdin.readline().rstrip().split())
def LI(): return list(map(int,stdin.readline().rstrip().split()))
def R(x):
    r = round(x)
    if r+0.5 <= x:
        r += 1
    return r

tmp = LI()

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

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

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

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

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

n = int(a*b)

print(n)

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

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

Solution (Python):
def main():
  A, B = input().split()
  print(int(A)*int(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):
N, K = [int(i) for i in input().split()]
print(N * K)

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