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
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
MOD = 10**9 + 7

A, B = MAP()
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 bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b = M()
print(a*b)

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

print(a*b)

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

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

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

Solution (Python):
import math

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

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

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

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

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

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 sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60


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


if __name__ == '__main__':
    main()

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

print(A * B)

Solution (Python):
import sys
import math
def I():return int(sys.stdin.readline().replace("\n",""))
def I2():return map(int,sys.stdin.readline().replace("\n","").split())
def S():return str(sys.stdin.readline().replace("\n",""))
def L():return list(sys.stdin.readline().replace("\n",""))
def Intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace("\n","").split()))

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

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.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    A, B = map(int, readline().split())
    print(A*B)
if __name__ == '__main__':
    main()

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

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

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

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)
f_inf = float('inf')
mod = 10 ** 9 + 7


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


if __name__ == '__main__':
    main()

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

import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def divisor(n):
        res = []
        i = 1
        for i in range(1, int(n ** 0.5) + 1):
            if n % i == 0:
                res.append(i)
                if i != n // i:
                    res.append(n // i)
        return res

    @staticmethod
    def round_up(a, b):
        return -(-a // b)

    @staticmethod
    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


MOD = int(1e09) + 7
INF = int(1e15)


def solve():
    A, B = Scanner.map_int()
    print(A * B)


def main():
    
    
    solve()


if __name__ == "__main__":
    main()

Solution (Python):


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

print(a * b)

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

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

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

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

Solution (Python):
from math import gcd

from math import factorial as f

from math import ceil,floor,sqrt
import math

import bisect
import re
import heapq


from copy import deepcopy
import itertools
from itertools import permutations

from sys import exit

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


yes = "Yes"
no = "No"


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

Solution (Python):
import sys; input = sys.stdin.buffer.readline
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

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


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

if __name__ == '__main__':
	main()

Solution (Python):
import sys











stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18

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

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] = [int(i) for i 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(int(a*b))

Solution (Python):

import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline

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

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

Solution (Python):


import re
import math
from collections import defaultdict
from collections import deque
import collections
from fractions import Fraction
from queue import PriorityQueue
import itertools
from copy import deepcopy
import random
import time
import os
import sys
import datetime
from functools import lru_cache
from functools import reduce
readline=sys.stdin.readline
sys.setrecursionlimit(2000000)
alphabet="abcdefghijklmnopqrstuvwxyz"
numbers="0123456789"
mod=int(10**9+7)
inf=int(10**19)
class Edge():
    def __init__(self,x,y,val=1):
        self.x=x
        self.y=y
        self.val=val
class unionfind():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(n)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):
            self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def yn(b):
    if b:print("yes")
    else:print("no")
def Yn(b):
    if b:print("Yes")
    else:print("No")
def YN(b):
    if b:print("YES")
    else:print("NO")
def ispow(a,b):
    now=b
    while now<a:
        now*=b
    return now==a
def getbin(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def getfacs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod_>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def nextcomb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:return num
def getprimes(n):
    if n==0:return []
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    ret=[]
    for a in range(n+1):
        if(A[a]):ret.append(a)
    return ret
def isprime(num):
    if(num<=1):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(bbool,ret1,ret2):
    if bbool:return ret1
    else:return  ret2
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
def factorize(n):
    b = 2
    ret=defaultdict(int)
    while b * b <= n:
        while n % b == 0:
            n //= b
            ret[b]+=1
        b+=1
    if n > 1:ret[n]+=1
    return ret
def pm(x):
    return x//abs(x)
def inputintlist(): 
    return list(map(int,input().split()))
def istanchouzouka(A):
    f=True
    prev=min(A)-1
    for a in A:
        if prev>=a:
            f=False
        prev=a
    return f
def istanchouhigensyou(A):
    f=True
    prev=min(A)-1
    for a in A:
        if prev>a:
            f=False
        prev=a
    return f
def getallsum(A):
    s=sum(A)
    dp=defaultdict(int)
    dp[0]=1
    for a in range(0,len(A)):
        for b in range(s,-1,-1):
            if b-A[a]>=0:
                dp[b]+=dp[b-A[a]]
    return dp
def yuukoutomukou(edges):
    ret=deepcopy(edges)
    for edge in edges:
        if not edge.x==edge.y:
            ret.append(Edge(edge.y,edge.x,edge.val))
    return ret
def dijkstra(edges,V,start):
    mincost=[inf]*V
    G=[[] for a in range(V)]
    for edge in edges:
        G[edge.x].append([edge.val,edge.y])
    Q=PriorityQueue()
    Q.put([0,start])
    while not Q.empty():
        nowcost,nowx=Q.get()
        if mincost[nowx]==inf:
            mincost[nowx]=nowcost
            for cost,y in G[nowx]:
                newcost=nowcost+cost
                Q.put([newcost,y])
    return mincost
def warshallfloyd(edges,V):
    mincost=[[inf for b in range(V)] for a in range(V)]
    for a in range(V):mincost[a][a]=0
    for edge in edges:
        mincost[edge.x][edge.y]=min(mincost[edge.x][edge.y],edge.val)
    for k in range(V):
        for s in range(V):
            for t in range(V):
                if mincost[s][k]==inf or mincost[k][t]==inf:continue
                mincost[s][t]=min(mincost[s][t],mincost[s][k]+mincost[k][t])
    return mincost
def bellemanford(edges,V,start):
    mincost=[inf]*V
    mincost[start]=0
    for _ in range(V):
        for edge in edges:
            if mincost[edge.x]==inf:continue
            mincost[edge.y]=min(mincost[edge.y],mincost[edge.x]+edge.val)
    return mincost
def ruisekiwa(A):
    ret=[0]*(len(A)+1)
    for a in range(len(A)):
        ret[a+1]=ret[a]+A[a]
    return ret
def getmd(x1,y1,x2,y2):
    return abs(x1-x2)+abs(y1-y2)
def geted(x1,y1,x2,y2):
    return math.sqrt((x1-x2)**2+(y1-y2)**2)
class fordfulkerson():
    def __init__(self,edges,V,s,t):
        self.V=V
        self.used=[False]*V
        self.G=[[] for a in range(V)]
        self.s=s
        self.t=t
        for edge in edges:
            self.G[edge.x].append({"x":edge.x,"y":edge.y,"cap":edge.val,"rev":len(self.G[edge.y])})
            self.G[edge.y].append({"x":edge.y,"y":edge.x,"cap":0,"rev":len(self.G[edge.x])-1})
    def dfs(self,v,t,f=inf):
        if v==t:return f
        self.used[v]=True
        for a in range(len(self.G[v])):
            x=self.G[v][a]["x"]
            y=self.G[v][a]["y"]
            cap=self.G[v][a]["cap"]
            rev=self.G[y][self.G[x][a]["rev"]]
            if self.used[y] or cap==0:continue
            f2=self.dfs(y,t,min(f,cap))
            if f2>0:
                self.G[v][a]["cap"]-=f2
                rev["cap"]+=f2
                return f2
        return 0
    def maxflow(self):
        flow=0
        while True:
            self.used=[False]*V
            zouka=self.dfs(self.s,self.t)
            if zouka==0:break
            flow+=zouka
        return flow










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

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

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

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

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

Solution (Python):


import sys
import math
import collections
import itertools
import bisect
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return x if y == 0 else gcd(y, x%y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")
def YesNo(B) : print("Yes" if B else "No")
def YESNO(B) : print("YES" if B else "NO")

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

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

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

print(a*b)

Solution (Python):
from collections import defaultdict
from collections import deque
from itertools import accumulate
def main():
    a,b=map(int, input().split())
    print(a*b)

if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
INF = 1 << 60
MOD = 10**9 + 7 
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
    a, b = map(int, input().split())
    print(a * b)
resolve()

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):
import math as m

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):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]




A, B = mi()

print(A*B)

Solution (Python):
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
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):

def s0():return input()
def s1():return input().split()
def s2(n):return [input() for x in range(n)]
def s3(n):return [input().split() for _ in range(n)]
def s4(n):return [[x for x in s] for s in s2(n)]
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
def t3(n):return [tuple(int(x) for x in input().split()) for _ in range(n)]
def p0(b,yes="Yes",no="No"): print(yes if b else no)








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

Solution (Python):
from sys import stdin
def main():
    
    readline=stdin.readline
    a,b=map(int,readline().split())
    print(a*b)

if __name__=="__main__":
    main()

Solution (Python):
A,B = map(int, open(0).read().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()

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

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

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

Solution (Python):
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 math
import bisect



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

Solution (Python):
import sys

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

    return 0

if __name__ == "__main__":
    solve()

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


if __name__ == '__main__':
    main()

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


print(N * Q)

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

Solution (Python):

import itertools
from collections import defaultdict
import collections
import math
import sys
sys.setrecursionlimit(200000)
mod = 1000000007

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

from collections import Counter 
from collections import defaultdict
from collections import deque
from functools import reduce
import math
import itertools
import heapq
import numpy as np
import bisect
import sys
sys.setrecursionlimit(10**6)


def bfs(s,n,node):
    
    check=[False for _ in range(n)]
    check[s]=True
    
    queue=deque([s])
    visited_num=1

    
    
    color=[-1 for _ in range(n)]
    color[s]=0
    
    while visited_num<n:
        
        if len(queue)==0:
            
            
            return color

        now_vertex=queue.popleft()
        
        for next_vertex in node[now_vertex]:


            if check[next_vertex]==True:
                continue

            queue.append(next_vertex)
            check[next_vertex]=True

            
            color[next_vertex]=color[now_vertex]+1
            visited_num+=1

    return color




ceil=lambda x,y: (x+y-1)//y
input_list = lambda : list(map(int,input().split()))




n,m=input_list()

print(n*m)

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

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

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

Solution (Python):
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):
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy




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):
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):
def mp(): return map(int, input().split())
def lmp(): return list(map(int, input().split()))

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

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

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

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

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 statistics import median


from fractions import gcd
from itertools import combinations 
from collections import deque
from collections import defaultdict
import bisect










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

def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
a,b = readInts()
print(a*b)

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

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

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

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

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

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

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

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

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
from sys import setrecursionlimit
from collections import Counter, deque, defaultdict
from math import floor, ceil
from bisect import bisect_left
from itertools import combinations
setrecursionlimit(100000)

INF = int(1e10)
MOD = int(1e9 + 7)

def main():
    from builtins import int, map
    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):
W, C = map(int, input().split())
print(W*C)

Solution (Python):
import sys

sys.setrecursionlimit(500005)
stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7


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


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


if __name__ == "__main__":
    main()

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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


if __name__ == '__main__':
    main()

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

Solution (Python):
def LI():return list(map(int,input().split()))
def yes():return print("Yes")
def no():return print("No")
from collections import deque, defaultdict, Counter
from heapq import heappop, heappush









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

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

Solution (Python):

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

print(a*b)

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

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

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

Solution (Python):

import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log, floor
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

a, b = MAP()

print(a*b)

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