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):
from __future__ import print_function

import sys
sys.setrecursionlimit(500000)

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


















def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


mod=1000000007
def combinations_count_mod(n, r):
    r = min(r, n - r)
    numer = reduce(lambda x,y: x*y%mod, range(n, n - r, -1), 1)
    denom = pow( reduce(lambda x,y: x*y%mod, range(1, r + 1), 1) , mod-2, mod)
    return numer * denom % mod


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

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

print(A*B)

Solution (Python):
import numpy as np
import math
import collections

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

print(A * B)

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

Solution (Python):
import math
import fractions
import collections
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):
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()
ans = int(a) * int(b)
print(ans)

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

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

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

Solution (Python):

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


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
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)

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):
n, k = list(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(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):

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

if __name__ == '__main__':

    ABC_169_A()

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

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

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

print(a*b)

Solution (Python):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))
def getArray(intn):
    return [int(input()) for i in range(intn)]
def input():
    return sys.stdin.readline().rstrip()

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

import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7

N, M = getNM()
print(N * M)

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

print(int(a*b))

Solution (Python):
import bisect
import heapq
import math
import random
import sys
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, or_

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())

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

def read_float():
    return float(input())

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

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

def read_str_n():
    return list(map(str, input().split()))

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



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

if __name__ == '__main__':
    main()

Solution (Python):

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

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

Solution (Python):
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,queue,math,copy,itertools,bisect,collections,heapq

def main():
    INF = 10**18
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()

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


if __name__ == '__main__':
    main()

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

print(a * b)

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

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

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

print(a*b)

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

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

Solution (Python):
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, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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 deque

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

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

Solution (Python):
import sys
import numpy as np
import math
import random
import itertools
import re
from collections import deque, Counter
from functools import lru_cache

sys.setrecursionlimit(2147483647)
INF = 10**13
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)]
mod = 1000000007

def binary_search(list,target):
	left = 0
	right = len(list)-1
	middle = 0
	while left+1 < right:
		middle = (right + left) // 2
		if list[middle] >= target:
			right = middle
		elif list[middle] < target:
			left = middle
	if list[left] >= target:
		return left
	else:
		return right

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




if __name__ == '__main__':
    main()

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

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

print(a * b)

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

Solution (Python):
N, K = input().split(" ")
print(int(N) * int(K))

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


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):
a, b = [int(i) for i in input().split()]
print(int(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):
from collections import Counter
import sys

sys.setrecursionlimit(10 ** 6)

mod = 1000000007
inf = int(1e18)

dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]


def inverse(a):
    return pow(a, mod - 2, mod)


def usearch(x, a):
    lft = 0
    rgt = len(a) + 1
    while rgt - lft > 1:
        mid = (rgt + lft) // 2
        if a[mid] <= x:
            lft = mid
        else:
            rgt = mid
    return lft


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

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

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


if __name__ == "__main__":
    main()
    sys.exit(0)

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

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

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

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
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):
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):

def q1():
    a, b = [int(i) for i in input().split(" ")]
    print(a * b)

q1()

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

print(A * B)

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


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



def f(N):
    return

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

if __name__ == '__main__':
    b, c = map(int, input().split())
    print(b*c)

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

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



def main():
    b, c = [int(i) for i in input().strip().split()]

    return b*c


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

Solution (Python):
N, M = input().strip().split()
N, M = [int(N), int(M)]
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 = 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):
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 = [int(v) for v 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(int(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):
from sys import stdin

a = stdin.readline().split()

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

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

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

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

Solution (Python):
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 math import sqrt
input = sys.stdin.readline

def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
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):
input = raw_input

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

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

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

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

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

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

sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline

""" Input
S = input().rstrip()
N = int(input())
A = list(map(int, input().split()))
A = np.array(input().split(), dtype=np.float64)
D = [int(input()) for _ in range(N)]
AB = [[int(x) for x in input().split()] for _ in range(N)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
"""
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 = list(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= 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):
a,b = map(int,input().split())
print(a*b)

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

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


print(n*m)

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

def main():
    x,y = map(int, readline().split())

    print(x * y)


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

print(a * b)

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()

def resolve():
    A, B = LI()

    print(A*B)

if __name__ == '__main__':
    resolve()

Solution (Python):
import sys
def LI(): return list(map(int,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):
a,b=map(int,input().split())
print(a*b)

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

print(a * b)

Solution (Python):

W, H = map(int, input().split())
print(W*H)

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

def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))

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

if __name__ == '__main__':
    main()

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

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

print(int(A*B))

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

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

if __name__ == '__main__':
    main()

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

ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]

a,b = ip()
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):
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math
MOD = 10**9+7


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

print(a*b)

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

x = a * b
print(x)

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

h, n = map(int, input().split())
print(h*n)

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

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

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

print(a*b)

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

print(a*b)

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

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

Solution (Python):

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

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

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(int(A*B))
main()

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

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

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

print(A*B)

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

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

print(a*b)