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:
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations, combinations_with_replacement
from heapq import heappop, heappush
from fractions import gcd
# input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

def main():
    a,b = inpm()
    print(a*b)
    
if __name__ == "__main__":
    main()

Submission status: Accepted

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

print(a * b)

Submission status: Accepted

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

import sys
import math


debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        # for line in sys.stdin:
        #     lines.append(line)
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    (a, b) = [int(e) for e in lines[0].split(' ')]

    return (a, b)


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


def main():
    # 出力
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, sep='')
    else:
        print("%s" % result, sep='')

if __name__ == '__main__':

    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
#import numpy as np
import math
#from fractions import Fraction
#import itertools
#from collections import deque
#import heapq
#from fractions  import gcd
input=sys.stdin.readline
a,b=map(int,input().split())
print(a*b)

Submission status: Accepted

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

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:
array=input().split(" ")
A=int(array[0])
B=int(array[1])
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 = map(int, input().split())
S = A * B
print(S)

Submission status: Accepted

Solution code:
#!/usr/bin/env python
"""AtCoder Beginner Contest 169: A - Multiplication 1 
https://atcoder.jp/contests/abc169/tasks/abc169_a
"""

__author__ = 'bugttle <bugttle@gmail.com>'


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

if __name__ == '__main__':
    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:
#-*-coding:utf-8-*-

import sys

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

Submission status: Accepted

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

Submission status: Accepted

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

b = a[0] * a[1]

print(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:
s = input().split(' ')
a = int(s[0])
b = int(s[1])

print(a*b)

Submission status: Accepted

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

Submission status: Accepted

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

A,B =(int(x) for x in input().rstrip('\n').split())
print(A*B)

Submission status: Accepted

Solution code:
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *                    # ll = deepcopy(l)
from heapq import *                    # heappush(hp,x)
from string import *                # alpha = ascii_lowercase
from random import *                # l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *                # bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin                # bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize                # minn = -maxsize
from operator import *                # d = sorted(d.items(), key=itemgetter(1))
from itertools import *                # pre = [0] + list(accumulate(l))
from collections import Counter        # d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''

'''

def solve(l):
	a,b = l
	p = a*b
	return p
	

l = list(map(int, stdin.readline().rstrip().split()))
ans = solve(l)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

print (A*B)

Submission status: Accepted

Solution code:
#ABC169a

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

print(main())

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    A, B = map(int, rl().split())
    print(A * B)


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
AB = [int(x) for x in input().split()]

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

Submission status: Accepted

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

Submission status: Accepted

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

print(x*y)

Submission status: Accepted

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

Submission status: Accepted

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

print(A*B)

Submission status: Accepted

Solution code:
import sys
from collections import deque
import copy
def main():
    A, B = map(int, input().split())
    print(A * B)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
list1 = list(map(int, input().split()))
A = list1[0]
B = list1[1]
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:
import bisect
import copy
import heapq
import math
import sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
sys.setrecursionlimit(500000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

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:
#!/bin/python3

import sys
input = sys.stdin.readline

def main():
  a,b = list(map(int, input().strip().split()))
  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:
inp= list(map(int, input().split()))
a, b = inp[0], inp[1]
print(a*b)

Submission status: Accepted

Solution code:
# import sys
# readline = sys.stdin.readline
# generator = (readline().strip() for _ in range(N))

# N, M = map(int, input().split())
# As = list(map(int, input().split()))
# queries = (input() for _ in range(N))


def solve():
    N, M = map(int, input().split())
    return N * M


def main():
    print(solve())


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

ans=A*B

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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


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


# 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
    print(solve(A, B))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
import bisect

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

Submission status: Accepted

Solution code:
#/usr/bin/python3

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

print(A*B)

Submission status: Accepted

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

ans = a*b
print(ans)

Submission status: Accepted

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

    print(a * b)

Submission status: Accepted

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

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().strip().split())

print(a * b)

Submission status: Accepted

Solution code:
import numpy as np
import math
import scipy as sp
import queue
import collections

MOD = 10 ** 9 + 7
INF = 10 ** 9

def main(kwargs):
    a = kwargs["a"]
    b = kwargs["b"]
    res = a * b
    return res

if __name__ == "__main__":
    kwargs = {}

    cin = input().split()
    kwargs["a"], kwargs["b"] = [int(i) for i in cin]

    cout = main(kwargs)
    print(cout)

Submission status: Accepted

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

b=int(a[0])*int(a[1])

print(b)

Submission status: Accepted

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

re = l[0]*l[1]

print(re)

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
mod = 1000000007
eps = 10**-9


def main():
    import sys
    input = sys.stdin.readline

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np


def main(A, B):

    ans = A*B
    return ans


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

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

print(a * b)

Submission status: Accepted

Solution code:
#include <CodeforcesSolutions.h>
#include <ONLINE_JUDGE <solution.cf(contestID = "1359",problemID = "C",method = "GET")>.h>
"""
    Author : thekushalghosh
    Team   : CodeDiggers
 
    I prefer Python language over the C++ language :p :D
        
    Visit my website : thekushalghosh.github.io
"""
import sys,math,cmath,time
start_time = time.time()
##########################################################################
################# ---- THE ACTUAL CODE STARTS BELOW ---- #################
    
def solve():
    a,b = invr()
    print(a * b)
                
################## ---- THE ACTUAL CODE ENDS ABOVE ---- ##################
##########################################################################
 
def main():
    global tt
    if not ONLINE_JUDGE:
        sys.stdin = open("input.txt","r")
        sys.stdout = open("output.txt","w")
    t = 1
    for tt in range(t):
        solve()
    if not ONLINE_JUDGE:
        print("Time Elapsed :",time.time() - start_time,"seconds")
    sys.stdout.close()
    
#---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    return(input().strip())
def invr():
    return(map(int,input().split()))

#------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
def counter(a):
    q = [0] * max(a)
    for i in range(len(a)):
        q[a[i] - 1] = q[a[i] - 1] + 1
    return(q)
 
def string_counter(a):
    q = [0] * 26
    for i in range(len(a)):
        q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
    return(q)

ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
    input = sys.stdin.readline
    
main()

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:
n,k = input().split(" ")

r = int(n) * int(k)

print(r)

Submission status: Accepted

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

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 = map(int, input("").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:
line= input().split(' ')
a= int(line[0])
b= int(line[1])
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:
a, b = list(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 = (int(x) for x in input().split())
print(A*B)

Submission status: Accepted

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

print(x*y)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# 2つの文字入力
a = input()

# スペースで区切り処理
inputs = a.split(' ')

# A,Bに代入
A = int(inputs[0])
B = int(inputs[1])


# 最終的結果の数字
final = int(0)

final = A * B

print(final)

Submission status: Accepted

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

Submission status: Accepted

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

#a = int(input())
#b = list(map(int, input().split()))
a, b = map(int, input().split())
#s = input()
#s,t = input().split()
#
#readline = sys.stdin.readline
#n,m = [int(i) for i in readline().split()]
#ab = [[int(i) for i in readline().split()] for _ in range(n)]

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 sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0

n,m = map(int,readline().split())
print(n*m)

Submission status: Accepted

Solution code:
import sys

def input():
    return sys.stdin.readline()[:-1]


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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


print(x*y)

Submission status: Accepted

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

Submission status: Accepted

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

print(L*R)

Submission status: Accepted

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

Submission status: Accepted

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

Y = A*B
print(Y)

Submission status: Accepted

Solution code:
import sys
import math

if(__name__ == "__main__"):


    AList_Str = input().strip().split()
    A = int(AList_Str[0])
    B = int(AList_Str[1])
    print(A*B)

Submission status: Accepted

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

c=int(a)
d=int(b)

print(c*d)

Submission status: Accepted

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

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

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

C = A * B

print(C)

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:
# 2101~2101
A,B=map(int,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:
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:
a, b = [int(i)  for i in input().split()]

print(a*b)

Submission status: Accepted

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

input = sys.stdin.readline


def S():
    return input().rstrip()


def I():
    return int(input())


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


a, b = MI()
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:
a,b = map(int,input().split(" "))
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:
A, B = input().split()
A, B = int(A), int(B)

print(A*B)

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:

if __name__ == "__main__":
    A,B = [int(a) for a in input().split()]
    
    print(A * B)

Submission status: Accepted

Solution code:
import sys
# from collections import defaultdict
# from collections import Counter
# from queue import Queue

def main():
    # N = int(input())

    N, M = [int(s) for s in input().split()]
    print(N*M)

    # As = []
    # for i in range(N):
    #     tmp = int(input())
    #     As.append(tmp)

    return 0

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

Submission status: Accepted

Solution code:
A,B = list(map(int,input().split()))
           
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:
# coding: utf-8
# Your code here!
num = []
num = input().split()
print(int(int(num[0]))*(int(num[1])))

Submission status: Accepted

Solution code:
if __name__=="__main__":
    # Problem A
    A, B = map(int, input().split(' '))
    print(int(A*B))

Submission status: Accepted

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

Submission status: Accepted

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

ans = i[0] * i[1]

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
INT_MAX=10**11+7
MOD=10**9+7
def INPUT():return list(int(i) for i in input().split())
def LIST_1D_ARRAY(n):return [0 for _ in range(n)]
def LIST_2D_ARRAY(m,n):return [[0 for _ in range(n)]for _ in range(m)]
#=======================================================================
a,b=INPUT()
print(a*b)

Submission status: Accepted

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

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

Submission status: Accepted

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

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

print("{}".format(A*B))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# 標準入力の取得
A, B = list(map(int, input().split()))

# 求解処理
result = A * B

# 結果出力
print(result)

Submission status: Accepted

Solution code:
# A
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)

Submission status: Accepted

Solution code:
# coding: utf-8
num = input().split(' ')
a = int(num[0])
b = int(num[1])
print (a * b)

Submission status: Accepted

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

Submission status: Accepted

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

############ ---- Input Functions ---- ############
def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return(map(int,input().split()))

def solve(n):
    pass

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

main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

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

print(A * B)

Submission status: Accepted

Solution code:
#! /usr/bin/env python3
import sys
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

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

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

Submission status: Accepted

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

ans = A * B
print(ans)

Submission status: Accepted

Solution code:
from sys import stdin

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

Submission status: Accepted

Solution code:
try:
    A_s,B_s = input().split(' ')
    A=int(A_s)
    B=int(B_s)
    
    if A>=1 and A<=100 and B>=1 and B<=100:
        print(A*B)
    
    
except Exception as e:
    print(e)

Submission status: Accepted

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

Submission status: Accepted

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

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:
getinput = input()
getinput = getinput.split()
first = int(getinput[0])
second = int(getinput[1])
print(first * second)

Submission status: Accepted

Solution code:
import sys

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

Submission status: Accepted

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

print(A*B)

Submission status: Accepted

Solution code:
str = input()

str2 = str.split(" ")

res = 1
for str3 in str2:
    res *= int(str3)

print(res)

Submission status: Accepted

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

Submission status: Accepted

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

print(A*B)

Submission status: Accepted

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


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
[A,B] = [int(s) for s in input().rstrip().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 pypy
from __future__ import division, print_function
from collections import defaultdict, Counter, deque
from future_builtins import ascii, filter, hex, map, oct, zip
from itertools import imap as map, izip as zip, permutations, combinations, combinations_with_replacement
from __builtin__ import xrange as range
from math import ceil, factorial, log,tan,pi,cos,sin,radians
from _continuation import continulet
from cStringIO import StringIO
from io import IOBase
import __pypy__
from bisect import bisect, insort, bisect_left, bisect_right
from fractions import Fraction
from functools import reduce
from decimal import *
import string
import sys
import os
import re
inf = float('inf')
mod_ = int(1e9) + 7
mod = 998244353

def factors(n):
    from functools import reduce
    return set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))

def sieve(m):
    n=1
    primes = {}
    arr=set([])
    for i in range(2, int(m ** 0.5) + 1):
        a = n // i
        b = m // i
        for k in range(max(2, a), b + 1):
            c = i * k
            primes[c] = 1

    for i in range(max(n, 2), m + 1):
        if i not in primes:
            arr.add(i)

    return arr


class DisjointSetUnion:
    def __init__(self, n):
        self.parent = list(range(n))
        self.size = [1] * n
        self.num_sets = n
 
    def find(self, a):
        acopy = a
        while a != self.parent[a]:
            a = self.parent[a]
        while acopy != a:
            self.parent[acopy], acopy = a, self.parent[acopy]
        return a
 
    def union(self, a, b):
        a, b = self.find(a), self.find(b)
        if a != b:
            if self.size[a] < self.size[b]:
                a, b = b, a
 
            self.num_sets -= 1
            self.parent[b] = a
            self.size[a] += self.size[b]
 
    def set_size(self, a):
        return self.size[self.find(a)]
 
    def __len__(self):
        return self.num_sets



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












    



# region fastio

BUFSIZE = 8192

class FastI(IOBase):
    def __init__(self, file):
        self._fd = file.fileno()
        self._buffer = StringIO()
        self.newlines = 0

    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("\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()


class FastO(IOBase):
    def __init__(self, file):
        self._fd = file.fileno()
        self._buffer = __pypy__.builders.StringBuilder()
        self.write = lambda s: self._buffer.append(s)

    def flush(self):
        os.write(self._fd, self._buffer.build())
        self._buffer = __pypy__.builders.StringBuilder()


def print(*args, **kwargs):
    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()

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

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

# endregion

if __name__ == "__main__":
    main()

Submission status: Accepted

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

ans = A * B

print(ans)

Submission status: Accepted

Solution code:
# coding: utf-8

import math
import re
import numpy as np

S = input().split(" ")
A = int(S[0])
B = int(S[1])

ans = A * B

print(ans)

Submission status: Accepted

Solution code:
import sys
import math
from collections import deque
import heapq
import itertools
MAX_INT = int(10e25)
MIN_INT = -MAX_INT
mod = 1000000000+7
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
Num1, Num2 = map(int,input().split())
print(Num1 * Num2)

Submission status: Accepted

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

if __name__ == '__main__':
    main()