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
sys.setrecursionlimit(10000000)
import numpy as np
from heapq import heapify, heappop, heappush
import copy
from math import gcd, ceil
from collections import deque

from bisect import bisect_left, bisect_right









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


if __name__ == '__main__':
    main()

Solution (Python):




import sys
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

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

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

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

Solution (Python):
from sys import stdin, stdout

int_in = lambda: int(stdin.readline())
arr_in = lambda: [int(x) for x in stdin.readline().split()]
mat_in = lambda rows: [arr_in() for y in range(rows)]
str_in = lambda: stdin.readline().strip()
out = lambda o: stdout.write("{}\n".format(o))
arr_out = lambda o: out(" ".join(map(str, o)))
bool_out = lambda o: out("YES" if o else "NO")
tests = lambda: range(1, int_in() + 1)
case_out = lambda i, o: out("Case 

if __name__ == "__main__":
    a, b = arr_in()
    out(a*b)

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

Solution (Python):

import sys


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



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(A, B)

if __name__ == '__main__':
    main()

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

print(A * B)

Solution (Python):

import bisect
import collections
import sys

sys.setrecursionlimit(1000000)
ACMOD = 1000000007
INF = 1 << 62



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


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    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

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

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

print(A*B)

Solution (Python):
A, B = map(int, 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):
def main():
    x,y = tuple([int(t)for t in input().split()])

    print(x*y)

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):
"""
~~ Author : Bhaskar
~~ Dated : 31~05~2020
"""

import sys
from bisect import *
from math import floor,sqrt,ceil,factorial as F,gcd,pi
from itertools import chain,combinations,permutations,accumulate
from collections import Counter,defaultdict,OrderedDict,deque
from array import array
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize)-1
mod = 1000000007
lcm = lambda a,b : (a*b)//gcd(a,b)
setbit = lambda x : bin(x)[2:].count("1")

def solve():
    a,b = map(int,sys.stdin.readline().split())
    print(a*b)

if __name__ == "__main__":
    solve()

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

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

Solution (Python):
import io,sys
sys.setrecursionlimit(10**6)

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

Solution (Python):
a, b = [int(tmp) for tmp 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=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(A*B)

Solution (Python):
A,B=map(int,input().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 = [int(_) for _ in input().split(' ')]
print(a * b)

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

Solution (Python):
def task(a, b):
    print(a * b)


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

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

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

Solution (Python):
print(eval(input().replace(' ','*')))

Solution (Python):
n,m=list(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):
import collections


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


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


if __name__ == '__main__':
    main()

Solution (Python):

import numpy as np

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

print(a * b)

Solution (Python):
inf = 10 ** 15
mod = 10 ** 9 + 7
am,b = map(int, input().split())
print(am*b)

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

Solution (Python):
date0=input().rstrip().split(" ")
print(int(date0[0])*int(date0[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):
import sys

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

import collections
import itertools as it
import math

 


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





print(a * b)

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

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

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

print(a*b)

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
def IS(cb): return cb(input().strip())
def IL(cb): return [cb(s) for s in input().strip().split()]
def IR(cb, rows): return [IS(cb) for _ in range(rows)]
def ILL(cb, rows): return [IL(cb) for _ in range(rows)]


def solve():
    N, M = IL(int)
    print(N * M)

solve()

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

Solution (Python):
def main():
    a, b = [int(e) for e in 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):
def get_input(data_type=int, container_type=list):
    return container_type(data_type(x) for x in input().split())



A, B = get_input()

print(A*B)

Solution (Python):


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

print(a*b)

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

print(a*b)

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

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

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

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

Solution (Python):
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())
d=n*m
print(d)

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

print(a*b)

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

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

print(A*B)

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

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

print(A*B)

Solution (Python):
import sys
sys.setrecursionlimit(10**6)


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


if __name__ == '__main__':
    main(sys.stdin.readline, print)

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

print(A*B)

Solution (Python):
import sys
from functools import lru_cache
 

readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def read():
  return int(readline())
def reads():
  return map(int, readline().split())
def mp(arg):
  return map(int,arg.split())
a,b=reads()
print(a*b)

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









import os
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())

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

Solution (Python):
import sys
import math
def get_array(): return list(map(int,sys.stdin.readline().strip().split()))
def get_ints(): return map(int,sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
a,b=get_ints()
print(a*b)

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

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

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

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

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

print(a*b)

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):
import numpy as np
a = np.array(list(map(int, input().split())))

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

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

s = a*b

print(s)

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

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

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

print(A*B)

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

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

print(a*b)

Solution (Python):

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

Solution (Python):
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush
from math import ceil, floor, sqrt, gcd
from copy import deepcopy

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

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

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

print(int(n[0])*int(n[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=input().split()
a=int(A)
b=int(B)
x=a*b
print(x)

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

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

print(A * B)

Solution (Python):



import sys


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


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

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

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 itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue

Mod = 1000000007
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

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

Solution (Python):


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

print(a*b)

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

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

print(A*B)

Solution (Python):
def resolve():
    '''
    code here
    '''
    A, B = [int(item) for item in input().split()]

    print(A*B)

if __name__ == "__main__":
    resolve()

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

Solution (Python):


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

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

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

print(a*b)

Solution (Python):






"""Module docstring
"""

import functools
import heapq
import itertools
import logging
import math
import os
import random
import string
import sys
from argparse import ArgumentParser
from collections import defaultdict, deque
from copy import deepcopy
from io import BytesIO, IOBase
from typing import Dict, List, Optional, Set, Tuple


def solve(values: List[int], nb: int) -> int:
    for _v in values:
        pass
    return nb


def do_job(stdin, stdout):
    "Do the work"
    LOG.debug("Start working")
    
    a, b = map(int, stdin.readline().split())
    
    
    
    print(a * b, file=stdout)


def print_output(testcase: int, result, stdout) -> None:
    "Formats and print result"
    if result is None:
        result = "IMPOSSIBLE"
    print("Case 
    
    


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 configure_log() -> None:
    "Configure the log output"
    log_formatter = logging.Formatter("L%(lineno)d - " "%(message)s")
    handler = logging.StreamHandler(IOWrapper(sys.stderr))
    handler.setFormatter(log_formatter)
    LOG.addHandler(handler)


LOG = None

if not LOG:
    LOG = logging.getLogger("template")
    configure_log()


def main(argv=None):
    "Program wrapper."
    if argv is None:
        argv = sys.argv[1:]
    parser = ArgumentParser()
    parser.add_argument(
        "-v",
        "--verbose",
        dest="verbose",
        action="store_true",
        default=False,
        help="run as verbose mode",
    )
    args = parser.parse_args(argv)
    if args.verbose:
        LOG.setLevel(logging.DEBUG)
    stdin = IOWrapper(sys.stdin)
    stdout = IOWrapper(sys.stdout)
    do_job(stdin, stdout)
    stdout.flush()
    for h in LOG.handlers:
        h.flush()
    return 0


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

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

print(a * b)

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



print(A*B)

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

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



if __name__ == "__main__":
    main()

Solution (Python):
from pprint import pprint
import sys
sys.setrecursionlimit(10**7) 

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

    res = A * B

    print(res)



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):
M,N = map(int,input().rstrip().split(" "))
print(M * N)

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 heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def FLIST(n):
    res = [1]
    for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
    return res
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):
b,c=map(int, input().split())
print(int(c*b))

Solution (Python):




def input_int():
    return int(input())



def int1(x):
    return int(x) - 1



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



def input_to_int_tuple():
    return tuple(map(int, input().split()))



def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


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


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

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



 
import sys
import math



 

fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile


mod=1000000007
 

def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 

t=1
for tt in range(t):
    
    a,b= map(int, sys.stdin.readline().split(' '))
    print(a*b)
    
    
    

if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

Solution (Python):
a, b = map(int, 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):
import itertools
import math

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

print(A*B)

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

print(A*B)

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

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

print(a * b)

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

Solution (Python):






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

print(a*b)

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

print(A*B)

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

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

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

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

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

print(a*b)

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

import bisect
import math
import collections
import heapq


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


if __name__ == "__main__":
    A, B = tuple(map(int, input().split(" ")))

    print(solve(A, B))

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

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

print(A*B)

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

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

print(A*B)

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

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):
def resolve():
    import sys
    input = sys.stdin.readline
    
    
    
    a, b = map(int, input().split())
    
    
    
    
    
    



    print(a*b)


resolve()

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

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

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

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

Solution (Python):



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


def main():
    a, b = (int(z) for z in input().split())
    res = compute(a, b)
    print(res)


if __name__ == '__main__':
    main()

Solution (Python):
"""
N = list(map(int,input().split()))
S = [str(input()) for _ in range(N)]
S = [list(map(int,list(input()))) for _ in range(h)] 
print(*S,sep="")
"""

import sys
sys.setrecursionlimit(10**6)
input = lambda: sys.stdin.readline().rstrip()
inf = float("inf") 

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

Solution (Python):
def N(): return int(input())
def NM():return map(int,input().split())
def L():return list(NM())
def LN(n):return [N() for i in range(n)]
def LL(n):return [L() for i in range(n)]
a,b=NM()
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):
a, b = map(int, input().split())
print(a*b)

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

print(str(a*b))

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

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

Solution (Python):



def solve(*args: str) -> str:
    a, b = map(int, args[0].split())
    return str(a*b)


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

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

print(A*B)

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=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 time

import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq
import itertools



sys.setrecursionlimit(10**7)






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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

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

main()