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



Sample input:
2 5


Sample output:
10

Submission status: Accepted

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

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


if __name__=='__main__':
    a,b=readinput()
    ans=main(a,b)
    print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

print(A * B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B = map(lambda x: int(x), input().split(" "))

print(A*B)

Submission status: Accepted

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

Submission status: Accepted

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

res = a * b

print(res)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

if __name__ == "__main__":
  resolve()

Submission status: Accepted

Solution code:
import sys

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

Submission status: Accepted

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

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

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

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

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

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

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

#

class UnionFindEx:
    def __init__(self, size):
        #正なら根の番号、負ならグループサイズ
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   #負なら根
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    #サイズ更新
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


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



main()

Submission status: Accepted

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

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

print(A*B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
data = input().rstrip().split(" ")
A = int(data[0])
B = int(data[1])
print(A*B)

Submission status: Accepted

Solution code:
import os
import sys
from io import BytesIO, IOBase


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

#.........................................FAST INPUT OUTPUT.......................................
BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

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

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

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

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


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


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

#....................................END OF FAST I/O............................................

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# スペース区切りの整数の入力
N, K = map(int, input().split())
# 文字列の入力
#s = input()
#開業されたN個要素を受け付ける
#input_list = [list(map(int, input().split())) for i in range(N)]
print(N * K)

Submission status: Accepted

Solution code:
###############################################################################
#Imports
import collections
import itertools
from functools import lru_cache
import sys
import math
###############################################################################
#Constants
MOD = int(1e9)+7
###############################################################################
#Helper
def helper():
	pass
###############################################################################
#Solver
def solve():
	a, b = map(int, input().split(' '))
	print(a*b)

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B = input().split()

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

print(A * B)

Submission status: Accepted

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

print(n * m)

Submission status: Accepted

Solution code:
import sys

# 実行環境(0:vscode, 1:atcoder)
MODE = 1

# 入力の次元
DIMENSION = 1

# int型に変換
INT_TYPE = 1

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
n,m = map(int, input().split())
p = n*m
print(p)

Submission status: Accepted

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

ans = int(A * B)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B = map(int, input().split())
print("{}".format(A*B))

Submission status: Accepted

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

print(A*B)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-


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

print(A*B)

Submission status: Accepted

Solution code:
import math
a,b = map(int,input().split())

print(a*b)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# 初期入力
import sys
input = sys.stdin.readline

A,B = (int(x) for x in input().split())
ans =A *B
print(ans)

Submission status: Accepted

Solution code:

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

c=a*b
print(c)

Submission status: Accepted

Solution code:
# 

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

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

print(a*b)

Submission status: Accepted

Solution code:
n, m = map(int, input(" ").split())
print (n*m)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
sys.setrecursionlimit(300000)


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

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

Submission status: Accepted

Solution code:
a , b = (int(x) for x in input().split())

print(a * b)

Submission status: Accepted

Solution code:
from __future__ import division, print_function

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

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


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

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


class FastIO(IOBase):
    newlines = 0

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

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

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

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


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


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


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

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

Submission status: Accepted

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

print(ans)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
a,b=map(int,input().split())
s=a*b
print(s)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-


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

    print(a*b)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def intMap(): return map(int,input().split())
def intList(): return list(map(int, input().split())) #横並びの場合
def intListVertical(): [int(input()) for _ in range(N)] #縦並びの場合

#s = input()
#n = int(input())
#s,t = input().split()
a,b = intMap()
#a = intList()
#w = intListVertical()

print(a*b)

Submission status: Accepted

Solution code:
a,b=(int(x)for x in input().split())

x=a*b

print(x)

Submission status: Accepted

Solution code:
A,B=input().split()
A=int(A)
B=int(B)
C=A*B
print(C)

Submission status: Accepted

Solution code:
# 別変数の整数複数個
A, B = [int(x) for x in input().strip().split(" ")]
print(A*B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding=UTF-8
from collections import deque
from operator import itemgetter
from bisect import bisect_left, bisect
import itertools
import sys
import math
import numpy as np
import time
sys.setrecursionlimit(10**6)
input = sys.stdin.readline


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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

# output
print(A*B)

Submission status: Accepted

Solution code:
import sys

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

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

Submission status: Accepted

Solution code:

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

print(a*b)

Submission status: Accepted

Solution code:
#!/usr/bin/env python

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from sys import stdin
from copy import deepcopy

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

tmp = LI()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

n = int(a*b)

print(n)

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == "__main__":
  main()

Submission status: Accepted

Solution code:
N, K = [int(i) for i in input().split()]
print(N * K)

Submission status: Accepted

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

Submission status: Accepted

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

print(A*B)

##B
#A,B,C,K = map(int,input().split())

#if A >= K:
#	print(K)
#else:
#	if B >= K - A:
#		print(A)
#	else:
#		print(A - (K - A - B))




##A
#S = input()
#T = input()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
#import time
import copy
#from collections import deque, Counter, defaultdict
#from fractions import gcd
#import bisect
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**20
ri = lambda : int(input())
rs = lambda : input().strip()
rl = lambda : list(map(int, input().split()))
a,b=rl()
print(a*b)

Submission status: Accepted

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

print(int(A*B))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys


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


# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    solve(A, B)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
print(eval(input().replace(" ", "*")))

Submission status: Accepted

Solution code:
ls = list(map(int, input().split()))

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

Submission status: Accepted

Solution code:
def main():
    A, B = map(int, input().split())

    print(A * B)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

print(A * B)

Submission status: Accepted

Solution code:
from sys import stdin


def get_result(data):
    A, B = data
    return A * B


if __name__ == '__main__':
    data = list(map(int, stdin.readline().rstrip().split(' ')))
    result = get_result(data)
    print(result)

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = input().split()

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

Submission status: Accepted

Solution code:
def main():
    A, B = [int(x) for x in input().split()]
    print(A * B)

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:

def main():
    import sys
    import math
    def input():
        return sys.stdin.readline()[:-1]
    A,B=map(int,input().split())
    print(A*B)
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A,B=map(int, raw_input().split())
print A*B

Submission status: Accepted

Solution code:
A,B=input().split(' ')
A=int(A)
B=int(B)
print(A*B)

Submission status: Accepted

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

print(A*B)

Submission status: Accepted

Solution code:

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

print(a*b)

Submission status: Accepted

Solution code:
nums = input().split(" ")
print(int(nums[0]) * int(nums[1]))

Submission status: Accepted

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

print(a*b)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# print('input >>')
A, B = map(int,(input().split()))

# print('-----output-----')
print(A * B)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(a*b)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    nums = list(map(int, input().split()))
    n, k = nums[0], nums[1]
    print(n * k)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline

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

print(a * b)

Submission status: Accepted

Solution code:
import numpy as np

AB=np.array(input().split(" "),dtype=np.int32)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def mul1():
    m,n = map(int,input().split())
    return m*n

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

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from collections import defaultdict
from math import gcd
import time
import sys
from collections import Counter
import itertools
import math
# read = sys.stdin.buffer.read
# readline = sys.stdin.buffer.readline
# readlines = sys.stdin.buffer.readlines
input = sys.stdin.readline

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

print(A*B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
@author: H_Hoshigi
"""
def main():
    A, B = map(int, input().split())
    print(A*B)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys

def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))
def RN(N): return [input().strip() for i in range(N)]


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


if __name__ == "__main__":
	main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# from math import factorial,sqrt,ceil #,gcd
# from itertools import permutations,combinations,combinations_with_replacement
# from collections import deque,Counter
# from bisect import bisect_left
# from heapq import heappush,heappop
# from numba import njit
# from functools import lru_cache # 簡単メモ化 @lru_cache(maxsize=1000)
# from fractions import gcd

# from decimal import Decimal, getcontext
# # getcontext().prec = 1000
# # eps = Decimal(10) ** (-100)

# import numpy as np    # numpy.lcm()
# from scipy.sparse.csgraph import shortest_path, dijkstra, floyd_warshall, bellman_ford, johnson
# from scipy.sparse import csr_matrix
# from scipy.special import comb,perm #permはnPk
# import networkx as nx
# G = Graph()

# slist = "abcdefghijklmnopqrstuvwxyz"
A,B = map(int,input().split())

print(A*B)
# for row in board:
#     print(*row,sep="")    #unpackして間にスペース入れずに出力する
# print("{:.10f}".format(ans))
# print("{:0=10d}".format(ans))

Submission status: Accepted

Solution code:
n, y = map(int, input().split())
print(n*y)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(700000)

def s_in():
    return input()

def n_in():
    return int(input())

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

Submission status: Accepted

Solution code:
inputs = input().split(" ")
print(int(inputs[0])*int(inputs[1]))

Submission status: Accepted

Solution code:

a, b = (int(e) for e in input().split())
print(a*b)

Submission status: Accepted

Solution code:


def main():
    AB = list(map(int,input().split()))
    print(AB[0]*AB[1])




if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a = input().split()
b = int(a[0])
c = int(a[1])
print(b*c)

Submission status: Accepted

Solution code:
a = input().split(" ")
print(int(a[0])*int(a[1]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin

def main():

    input = stdin.readline

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

    ans = A * B

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

Submission status: Accepted

Solution code:

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

print(A*B)

Submission status: Accepted

Solution code:
def main():
    A,B = [int(x) for x in input().split()]
    print(A*B)

if __name__ == '__main__':
    main()

Submission status: Accepted

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


print(a * b)

Submission status: Accepted

Solution code:
n,m = map(int,input().split())
print(n*m)

Submission status: Accepted

Solution code:
def main():
    N = [int(_) for _ in input().split()]
    print(N[0]*N[1])

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
a, b = map(int,input().split())
print(a * b)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = input().split()
s = [int(i) for i in s]
print(s[0] * s[1])

Submission status: Accepted

Solution code:
A, B = [int(x) for x in input().split(" ")]

print(A * B)

Submission status: Accepted

Solution code:
import numpy as np;




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

Submission status: Accepted

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

print(a*b)