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:
from decimal import Decimal
import math
A,B = input().split()
A=Decimal(A)
B=Decimal(B)
AB=math.floor(A*B)
print(AB)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
numA, numB = map(int, input().split())
print(numA * numB)

Submission status: Accepted

Solution code:
[a,b] = [int(x) for x in 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())
print(A*B)

Submission status: Accepted

Solution code:
import math

A, B = map(float, input().split(' '))

if A*B > 0:
  print(math.floor(A*B))
else:
  print(int(A*B))

Submission status: Accepted

Solution code:
input = input()
inputArr = input.split()
x = int(inputArr[0])
y = int(inputArr[1])
if x in range(1, 101):
  if y in range(1, 101):
    print(x*y)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print( str(a*b)  )

Submission status: Accepted

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

Submission status: Accepted

Solution code:

a = list(map(int, input().split()))
c = 1
for b in a:
    c = c * b
print(c)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
i = list(map(int, input().split())) #i_1 i_2を取得し、iに値を入れる
c = i[0]*i[1]
print(c)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B = input().split()
import math
A=int(A)
B=float(B)
print(math.floor(A*B))

Submission status: Accepted

Solution code:

import numpy as np
from functools import *
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline



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

a,b=acinput()

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

Submission status: Accepted

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

Submission status: Accepted

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

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
import math
# n = int(input())
# a = list(map(int,input().split()))

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = input()
a = int(x.split(' ')[0])
b = float(x.split(' ')[1])
  
b = 100*b

ans = a*b/100
  
print ((int(ans)))

Submission status: Accepted

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

a = A*B
print(a)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    inputline = input()
    parsed_input = inputline.split(" ")
    print(int(parsed_input[0]) * int(parsed_input[1]))

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

Submission status: Accepted

Solution code:
#!/usr/bin/python3

#標準出力からの読み込み
input_1 = input()
a = int(input_1.split(" ")[0])
b = int(input_1.split(" ")[1])

#計算ロジック
print(a*b)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b = map(float,input().split())
from fractions import Fraction
import math
print(math.floor(Fraction(a)*Fraction(b)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
a,b=pin()
print(a*b)

Submission status: Accepted

Solution code:
import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


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


if __name__ == "__main__":
    main()

Submission status: Accepted

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


##########
if __name__ == "__main__":
    a()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *

##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)

##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力

# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと

##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順

# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順

##### 累乗 #####
# pow(x, y, z) -> x**y % z

##### 割り算の切り上げ #####
# tmp = -(-4 // 3)

##### dict の for文 #####
# for k, v in d.items():
#     print(k, v)

##### 進数の変換 #####
# bin_str = bin(i)[2:]
# oct_str = oct(i)[2:]
# hex_str = hex(i)[2:]

def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

def main():
	A,B = inputMap()

	print(A*B)



#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索のリバース
def bisect_left_reverse(a, x):
    if a[0] <= x:
        return 0
    if x < a[-1]:
        return len(a)
    # 二分探索
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] <= x:
            ok = mid
        else:
            ng = mid
    return ok

def bisect_right_reverse(a, x):
    if a[0] < x:
        return 0
    if x <= a[-1]:
        return len(a)
    # 二分探索
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] < x:
            ok = mid
        else:
            ng = mid
    return ok

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索
# 存在しない場合: None 存在する場合: その値
def binary_search(list, item):
    low = 0
    high = len(list) - 1

    while low <= high:
        mid = (low + high) //2
        guess = list[mid]
        if guess == item:
            return mid
        if guess > item:
            high = mid -1
        else:
            low = mid + 1
    return None

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# N 個のボールを K グループに分ける場合のパターン数
def sunuke(N, K, mod=10**9+7):
	if N < K or K-1 < 0:
		return 0
	else:
		return combination(N-1, K-1, mod)

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res

# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
	# comb = Combination(n+r-1, mod)
	# return comb(n+r-1, r)
    return combination(n+r-1, r, mod)


class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  # 10
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        # 階乗のリストと階乗のmod逆元のリストを返す O(n)
        # self.make_modinv_list()が先に実行されている必要がある
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        # 0からnまでのmod逆元のリストを返す O(n)
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# dfs のサンプル
def dfs(graph,parent,counter,edge):
    stk = []
    stk.append(edge)
    while len(stk) > 0:
        p = stk.pop()
        for e in graph[p]:
            if parent[p] == e:
                continue
            else:
                parent[e] = p
                counter[e] += counter[p]
                stk.append(e)

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
	main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))

from collections import defaultdict, deque
from sys import exit
import math
import copy
from bisect import bisect_left, bisect_right
from heapq import *
import sys
# sys.setrecursionlimit(1000000)
INF = 10 ** 17
MOD = 1000000007

from fractions import *
def inverse(f):
    # return Fraction(f.denominator,f.numerator)
    return 1/f


def combmod(n, k, mod=MOD):
    ret = 1
    for i in range(n - k + 1, n + 1):
        ret *= i
        ret %= mod

    for i in range(1, k + 1):
        ret *= pow(i, mod - 2, mod)
        ret %= mod

    return ret
def bunsu(n):
    ret = []
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            tmp = 0
            while(True):
                if n % i == 0:
                    tmp += 1
                    n //= i
                else:
                    break
            ret.append((i, tmp))

    ret.append((n, 1))
    return ret

def solve():
    a,b = getList()
    print(a*b)
def main():
    # n = getN()
    # for _ in range(n):
    solve()
if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
X = str(input())
em = 0
Return = []
for spam in range(len(X)):
    if X[spam] == " ":
        Return.append(int(X[em:spam]))
        em = spam+1
Return.append(int(X[em:]))
x = 1
for a in Return:
    x = x * a

print(x)

Submission status: Accepted

Solution code:
import bisect, collections, copy, heapq, itertools, math, numpy, string
import sys
from bisect import bisect_left, bisect_right, insort
from collections import deque
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def MS(): return map(str, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
# N = I()
# A = [LI() for _ in range(N)]

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

Submission status: Accepted

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

print(int(A)*int(B))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math


def main():
    A, B = map(int, input().split())
    print(A*B)
 
 
if __name__ == '__main__':
    import sys
    sys.setrecursionlimit(10000)
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
def C():
    a, b = input().split()
    a = int(a)
    b = float(b)
    print(math.floor(a*b))
C()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと


def read_a_int(): return int(read())


def read_ints(): return list(map(int, read().split()))


def read_col(H):
    '''H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) #一列の場合'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_tuple(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_matrix(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    # return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため


MOD = 10**9 + 7
INF = 2**31  # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  # , insort_left, insort_right

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(300000)

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B=input().strip().split()
A,B=[int(A),int(B)]    
if A>=1 and A<=100:
    if B>=1 and B<=100:
        print(A*B)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

x=a*b
print(x)

Submission status: Accepted

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

if __name__=="__main__":
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
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

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

Submission status: Accepted

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

import sys
from collections import deque as deq

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

print(A * B)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 8)
ni = lambda: int(sys.stdin.readline())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
ns = lambda: sys.stdin.readline().rstrip()

A, B = nm()


def solve():
    return A * B


print(solve())

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(A * B)

Submission status: Accepted

Solution code:
il = [int(k) for k in input().split()]
A = il[0]
B = il[1]

print(A*B)

Submission status: Accepted

Solution code:
one, two = map(int, input().split())
print(one * two)

Submission status: Accepted

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

import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)



def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1             # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a, b = mi()
    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:
a,b=(int(x) for x in input().split())

result = a * b
print(result)

Submission status: Accepted

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

print(n * m)

Submission status: Accepted

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

print(A*B)

Submission status: Accepted

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

Submission status: Accepted

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

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:
i = input()
sp = i.split(' ')

if int(sp[0]) < 0 and int(sp[0]) > 100:
  pass
if int(sp[1]) < 0 and int(sp[1]) > 100:
  pass
else:
  print(int(sp[0]) * int(sp[1]))

Submission status: Accepted

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

s = a * b

print(s)

Submission status: Accepted

Solution code:
# coding: utf-8
# このファイルはutf-8で書かれているため、日本語を書く場合は上の記述が必要


text = input()



num_data = text.split(' ')


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

def main():
    a, b = map(int, sys.stdin.readline().split())
    print(a * b)
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
Left, Right = map(int,input().split())
Answer = Left * Right
print(Answer)

Submission status: Accepted

Solution code:
import math
n, m = map(str, input().split())
answer = int(n) * float(m)
print(math.floor(answer))

Submission status: Accepted

Solution code:
line=input().split()
line=[int(i) for i in line]

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

Submission status: Accepted

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



if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
C, D = map(int, input().split())


print(C*D)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
a, b = [int(x) for x in sys.stdin.readline().split(" ")]
print(a * b)

Submission status: Accepted

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

if 1 <= int(N[0]) <= 100 and 1 <= int(N[1]) <= 100:
    S = int(N[0]) * int(N[1])
    print(S)
else:
    print("choose value between 1 to 100")

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A = list(map(int, input().split()))
B=A[0]
C=A[1]
print(B*C)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read

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

print(A * B)

Submission status: Accepted

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

print(a*b)

Submission status: Accepted

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

print(int(C))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l=input().rstrip().rsplit(" ")
print(int(l[0])*int(l[1]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def LI():
    return list(map(int, input().split()))

a, b = LI()

def main():
    print(a * b)

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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

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

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

Submission status: Accepted

Solution code:
#!python3

LI = lambda: list(map(int, input().split()))

# input
A, B = LI()


def main():
    ans = A * B
    print(ans)


if __name__ == "__main__":
    main()

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())
    ans = A*B
    print(ans)
resolve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def solve(A, B):
    print(A * B)


if __name__ == '__main__':
    A, B = map(int, input().split())
    solve(A, B)

Submission status: Accepted

Solution code:
#n = int(input())

p = 1

flag = False
n = input().split()
for i in n:
    x = int(i)
    p = p * x
    if p > 1000000000000000000:
        flag = True
        p = 1

if flag:
    print(-1)
else:
    print(p)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
a = list(map(int, input().split()))
print(a[0] * a[1])

Submission status: Accepted

Solution code:

import sys, io, os, re
import bisect
from pprint import pprint
from math import sin, cos, pi, radians, sqrt
from copy import copy, deepcopy
from collections import deque
from fractions import gcd

def array1(n): return [0] * n
def array2(n, m): return [[0] * m for x in range(n)]
def array3(n, m, l): return [[[0] * l for y in xrange(m)] for x in xrange(n)]



a, b = map(int, sys.stdin.readline().strip().split())

print(a*b)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#intの場合
L,R = map(int,input().split())

ans = L*R
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

mult = a * b

print(mult)

Submission status: Accepted

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

print("{}".format(a*b))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(x*y)

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    #n = int(input())
    a = list( map( int, input().split()))
    sum = 1
    print(a[0]*a[1])
    
if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin

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

Submission status: Accepted

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

ans = 1

for num in arr:
	ans *= num
	
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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