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

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

print(a*b)

Submission status: Accepted

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

Submission status: Accepted

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

print(A*B)

Submission status: Accepted

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

    print(A*B)

if __name__ == "__main__":
    resolve()

Submission status: Accepted

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

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)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# vim: set fileencoding=utf-8

# pylint: disable=unused-import, invalid-name, missing-docstring, bad-continuation


"""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")
    # first line is number of test cases
    a, b = map(int, stdin.readline().split())
    # values = []
    # for _ in range(N):
    #     values.append(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 #{}: {}".format(testcase + 1, result), file=stdout)
    # 6 digits float precision {:.6f} (6 is the default value)
    # print("Case #{}: {:f}".format(testcase + 1, result), file=stdout)


BUFSIZE = 8192


class FastIO(IOBase):
    # pylint: disable=super-init-not-called, expression-not-assigned
    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):
    # pylint: disable=super-init-not-called
    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
# for interactive call: do not add multiple times the handler
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())

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

Submission status: Accepted

Solution code:
# A - Multiplication 1

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

Submission status: Accepted

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



if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

print(A*B)

Submission status: Accepted

Solution code:
# import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)


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

    res = A * B

    print(res)



main()

Submission status: Accepted

Solution code:
M,N = map(int,input().rstrip().split(" "))
print(M * N)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


# 入力を整数に変換して受け取る
def input_int():
    return int(input())


# マイナス1した値を返却
def int1(x):
    return int(x) - 1


# 半角スペース区切り入力をIntに変換してMapで受け取る
def input_to_int_map():
    return map(int, input().split())


# 半角スペース区切り入力をIntに変換して受け取る
def input_to_int_tuple():
    return tuple(map(int, input().split()))


# 半角スペース区切り入力をIntに変換してマイナス1した値を受け取る
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())

Submission status: Accepted

Solution code:
#JMD
#Nagendra Jha-4096

 
import sys
import math

#import fractions
#import numpy
 
###File Operations###
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

###Defines...###
mod=1000000007
 
###FUF's...###
def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 
##### Main ####
t=1
for tt in range(t):
    #n=int(input())
    a,b= map(int, sys.stdin.readline().split(' '))
    print(a*b)
    #a=list(map(int,sys.stdin.readline().split(' ')))
    
    
#####File Operations#####
if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import itertools
import math

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

print(A*B)

Submission status: Accepted

Solution code:
#n, m, q = map(int, input().split())
#List = list(map(int, input().split()))
#req = [list(map(int, input().split())) for _ in range(q)]
#t = t[:-1]
#print(ans[j], end = "") 改行無しで出力
#[0]*n
a, b = map(int, input().split())

print(a*b)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def resolve():
    import sys
    input = sys.stdin.readline
    # 整数 1 つ
    # n = int(input())
    # 整数複数個
    a, b = map(int, input().split())
    # 整数 N 個 (改行区切り)
    # N = [int(input()) for i in range(N)]
    # 整数 N 個 (スペース区切り)
    # N = list(map(int, input().split()))
    # 整数 (縦 H 横 W の行列)
    # A = [list(map(int, input().split())) for i in range(H)]



    print(a*b)


resolve()

Submission status: Accepted

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

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


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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding:utf-8

import sys
import math
import time
#import numpy as np
import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq
import itertools



sys.setrecursionlimit(10**7)
#N, Q = map(int, input().split())
#G = [list(input()) for i in range(H)]
#INF = V * 10001
#A = [int(i) for i in input().split()]
#AB = [list(map(int, input().split())) for _ in range(K)]

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from __future__ import print_function

import sys
sys.setrecursionlimit(500000)

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return

# from fractions import gcd
# from math import gcd

# def lcm(n, m):
#     return int(n * m / gcd(n, m))


# def coprimize(p, q):
#     common = gcd(p, q)
#     return (p // common, q // common)


# def find_gcd(list_l):
#     x = reduce(gcd, list_l)
#     return x


def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


mod=1000000007
def combinations_count_mod(n, r):
    r = min(r, n - r)
    numer = reduce(lambda x,y: x*y%mod, range(n, n - r, -1), 1)
    denom = pow( reduce(lambda x,y: x*y%mod, range(1, r + 1), 1) , mod-2, mod)
    return numer * denom % mod


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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

print(A*B)

Submission status: Accepted

Solution code:
import numpy as np
import math
import collections

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

print(A * B)

Submission status: Accepted

Solution code:
from sys import stdin
A,B = [int(x) for x in stdin.readline().rstrip().split()]
print(A*B)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

ans = a * b

print(ans)

Submission status: Accepted

Solution code:
import math
import string
import collections
from collections import Counter
from collections import deque


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
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)

main()

Submission status: Accepted

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

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

Submission status: Accepted

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

if __name__ == '__main__':

    ABC_169_A()

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()))
def getArray(intn):
    return [int(input()) for i in range(intn)]
def input():
    return sys.stdin.readline().rstrip()

from collections import defaultdict, deque, Counter
from sys import exit
import heapq
import math
import copy
from bisect import bisect_left, bisect_right

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

N, M = getNM()
print(N * M)

Submission status: Accepted

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

print(int(a*b))

Submission status: Accepted

Solution code:
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub, or_

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())

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

def read_float():
    return float(input())

def read_float_n():
    return list(map(float, input().split()))

def read_str():
    return input().strip()

def read_str_n():
    return list(map(str, input().split()))

def error_print(*args):
    print(*args, file=sys.stderr)



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

if __name__ == '__main__':
    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:
A, B = [int(s) for s in input().split()]
print(A * B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    INF = 10**18
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 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:
import sys
from collections import deque

def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())

A,B = LI()

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
import numpy as np
import math
import random
import itertools
import re
from collections import deque, Counter
from functools import lru_cache

sys.setrecursionlimit(2147483647)
INF = 10**13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007

def binary_search(list,target):
	left = 0
	right = len(list)-1
	middle = 0
	while left+1 < right:
		middle = (right + left) // 2
		if list[middle] >= target:
			right = middle
		elif list[middle] < target:
			left = middle
	if list[left] >= target:
		return left
	else:
		return right

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




if __name__ == '__main__':
    main()

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from collections import Counter
import sys

sys.setrecursionlimit(10 ** 6)

mod = 1000000007
inf = int(1e18)

dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]


def inverse(a):
    return pow(a, mod - 2, mod)


def usearch(x, a):
    lft = 0
    rgt = len(a) + 1
    while rgt - lft > 1:
        mid = (rgt + lft) // 2
        if a[mid] <= x:
            lft = mid
        else:
            rgt = mid
    return lft


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

main()

Submission status: Accepted

Solution code:
import sys

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


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

Submission status: Accepted

Solution code:
N, K = map(int, 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= list(map(int, input().split()))

print(A*B)

Submission status: Accepted

Solution code:
a,b = map(int, input().split())			# "5 7" -> ["5", "7"] -> 5, 7 => N=5,K=7

print(a*b)

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:

def q1():
    a, b = [int(i) for i in input().split(" ")]
    print(a * b)

q1()

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

def f(N):
    return

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(100000)


def main():
    b, c = [int(i) for i in input().strip().split()]

    return b*c


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

Submission status: Accepted

Solution code:
N, M = input().strip().split()
N, M = [int(N), int(M)]
print(N*M)

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 = [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 = [int(v) for v in input().split()]
print(a * b)

Submission status: Accepted

Solution code:
from sys import stdin

a = stdin.readline().split()

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

Submission status: Accepted

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

print(A*B)

Submission status: Accepted

Solution code:
#TIME : 
import sys
from math import sqrt
input = sys.stdin.readline

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

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

Submission status: Accepted

Solution code:
input = raw_input

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

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

print(A*B)

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline

""" Input
S = input().rstrip()
N = int(input())
A = list(map(int, input().split()))
A = np.array(input().split(), dtype=np.float64)
D = [int(input()) for _ in range(N)]
AB = [[int(x) for x in input().split()] for _ in range(N)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
"""
A, B = map(int, input().split())
print(A * B)

Submission status: Accepted

Solution code:
#import numpy as np
#from itertools import combinations as comb
#from itertools import combinations_with_replacement as comb_with
#from itertools import permutations as perm


#N = int(input())
#H1,M1,H2,M2,K= map(int,input().split())
A,B = map(int,input().split())
#B = list(map(int,input().split()))
#S= str(input())
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:
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:
N, M = map(int, input().split())

print(int(N*M))

Submission status: Accepted

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

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:
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

def main():
    x,y = map(int, readline().split())

    print(x * y)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

print(A * B)

Submission status: Accepted

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

Submission status: Accepted

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

print (A * B)

Submission status: Accepted

Solution code:
import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()

def resolve():
    A, B = LI()

    print(A*B)

if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
A,B = LI()
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:

W, H = map(int, input().split())
print(W*H)

Submission status: Accepted

Solution code:
import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
#======================================================#
def main():
    a,b = MII()
    print(a*b)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# Problem A - Multiplication 1

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

# output
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
input = lambda: sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#dt = {} for i in x: dt[i] = dt.get(i,0)+1
ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]

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

Submission status: Accepted

Solution code:
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math
MOD = 10**9+7
# MOD = 998244353

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

h, n = map(int, input().split())
print(h*n)

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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