Problem:
 Score : 100 points    Problem Statement Compute A \times B .      Constraints  1 \leq A \leq 100  1 \leq B \leq 100  All values in input are integers.         Input Input is given from Standard Input in the following format:  A  B       Output Print the value A \times B as an integer.        Sample Input 1 2 5      Sample Output 1 10  We have 2 \times 5 = 10 .       Sample Input 2 100 100      Sample Output 2 10000

Solution (Python):

def inputlist(): return [int(j) for j in input().split()]

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

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

Solution (Python):
import os
import sys
from atexit import register
from io import BytesIO
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
raw_input = lambda: sys.stdin.readline().rstrip('\r\n')

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

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

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

a = int(a)
b = int(b)

print(a*b)

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

print(a*b)

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

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

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

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

Solution (Python):
a,b=input().split()
a=int(a)
b=float(b)*100
print(int((a*b)/100))

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

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

Solution (Python):
from sys import stdin

def main():
  read = stdin.readline
  A, B = list(map(int,read().split(" ")))
  print(A*B)
  
  
if __name__ == "__main__":
  main()

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

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

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

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

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

B *= 100
a = A.as_integer_ratio()
b = B.as_integer_ratio()
ans =  a[0] / a[1] * b[0] / b[1]

print(int(ans / 100))

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

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

a = A.as_integer_ratio()
b = B.as_integer_ratio()
ans =  a[0] / a[1] * b[0] / b[1]

print(int(ans))

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

Solution (Python):
import numpy as np
import scipy.sparse as sps
import scipy.misc as spm
import collections as col
import functools as func
import itertools as ite
import fractions as frac
import math as ma
from math import cos,sin,tan
import cmath as cma
import copy as cp
import sys
import re
def sinput(): return sys.stdin.readline().strip()
def iinput(): return int(sinput())
def imap(): return map(int, sinput().split())
def fmap(): return map(float, sinput().split())
def iarr(n=0):
    if n: return [0 for _ in range(n)]
    else: return list(imap())
def farr(): return list(fmap())
def sarr(n=0):
    if n: return ["" for _ in range(n)]
    else: return sinput().split()
def barr(n): return [False for _ in range(n)]
def adj(n): return [[] for _ in range(n)]
sys.setrecursionlimit(10**7)
MOD = 10**9 + 7; EPS = sys.float_info.epsilon
PI = np.pi; EXP = np.e; INF = np.inf

a,b = imap()
ans = a*b
print(ans)

Solution (Python):
import sys
readline = sys.stdin.readline

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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 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 I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


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

    return a*b

print(main())

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

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

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

Solution (Python):
def multiply(A, B):
    return A*B

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

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

Solution (Python):
import sys

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

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

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

print(a*b)

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

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

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


if __name__ == "__main__":
    main()

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

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

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

Solution (Python):

from collections import deque


def read(): return input()
def read_int(): return int(input())
def read_array(type=int): return list(map(type, input().split()))
def read_tupple(type=None):
    tmp = input().split()
    if type is None: return map(int, tmp)
    assert len(tmp) == len(type)
    return [type[i](tmp[i]) for i in range(len(tmp))]


A, B = read_tupple([int,int])
print(A*B)

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

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

tmp = A*B*100
print(int(tmp/100))

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

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

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

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

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

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

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

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

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

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

Solution (Python):

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


print(a*b)

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

Solution (Python):
num1, num2 = map(int, input().split())
print(num1*num2)

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

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

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

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

print(a * b)

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

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

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

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

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

print(a*b)

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

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

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

Solution (Python):
a, b = input().split(' ')
a = float(a)
b = float(b)
c = (a * b * 100)
print(int(c // 100 ))

Solution (Python):


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

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

print(a*b)

Solution (Python):
from decimal import Decimal
import math

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

print(a*b//1)

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

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

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

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

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

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

Solution (Python):

A,B = map(float,input().split())
A = int(A+0.1)
B = int(B*100+0.1)
print(int((A*B)/100))

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

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

Solution (Python):
n1,n2 = input().split()
n1,n2 = int(n1),int(n2)
print(n1*n2)

Solution (Python):

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

    print(a * b)


if __name__ == "__main__":
    main()

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

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

c = a * b

print(c)

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

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

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

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

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

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

Solution (Python):




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


if __name__ == "__main__":
    main()

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

Solution (Python):

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

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

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

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

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

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

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

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

ans = a * b
print(ans)

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

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

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

Solution (Python):
int1 = input() 
input1=int(int1.split(" ")[0]) 
input2=int(int1.split(" ")[1])

print(input1*input2)

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

Solution (Python):
val_1 = input()
nums = val_1.split()
mult = int(nums[0]) * int(nums[1])
print(mult)

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

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

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

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

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

Solution (Python):

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

print(a*b)

Solution (Python):


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

print(b*c)

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

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

print(int(a*b))

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

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

Solution (Python):



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


if __name__ == "__main__":
    main()

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

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

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

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

print(a*b)

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

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

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

Solution (Python):

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

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

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

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

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

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

Solution (Python):
"""
    This template is made by Satwik_Tiwari.
    python programmers can use this template :)) .
"""



from fractions import Fraction
import sys
import bisect
import heapq
from math import *
from collections import Counter as counter  
from itertools import combinations as comb 
from itertools import permutations as permutate
from bisect import bisect_left as bl


from bisect import bisect_right as br
from bisect import bisect






mod = 1000000007
def inp(): return sys.stdin.readline().strip() 
def out(var): sys.stdout.write(str(var))  
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n")  
def testcase(t):
    for p in range(t):
        solve()
def printlist(a) :
    for p in range(0,len(a)):
        out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)





def solve():
    a,b = sep()
    print(a*b)

testcase(1)

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

print(a*b)

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

print(a*b)

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

print(a*b)

Solution (Python):
a = input()
a = a.split()
sum = 1
for i in a:
  sum*=int(i)
print(sum)

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

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

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

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

Solution (Python):
a,b = map(float,input().split())
b = 100*b + 0.0000001
print(round((a*b)/100))

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

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

Solution (Python):
import math

print(math.prod(map(int, input().split())))

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


main()

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

print(A*B)

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
 
def main():
    read = lambda: sys.stdin.readline().rstrip()
    
    b, c = map(int,read().split())
    print(b*c)
 
if __name__ == "__main__":
    main()

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

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

Solution (Python):



 
from math import floor
a,b = map(float,input().split())
a = int(a)
buff = 1000000000000000
b *= buff
s =floor(a*b/buff)
print(s)

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

print(a * b)

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

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

print(a*b)

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

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

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

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

Solution (Python):
from decimal import *
N,M=input().split()
print(Decimal(N)*Decimal(M))

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

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

print(a * b)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    a,b=map(float, input().split())
    b100=int(b*100)
    x=(a * b100) /100
    print(int(x))
resolve()

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    a,b=map(float, input().split())
    b100=b*100
    print(int(a*b100/100))
resolve()

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

Solution (Python):
S=input().split()
print(int(S[0])*int(S[1]))

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

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

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

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

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

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

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

Solution (Python):
a,b=list(map(float,input().split()))
a=1*int(a)
b=int(b*10**3)
print(int(a*b//10**3))

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

Solution (Python):
s = input().split()
A = int(s[0])
B = float(s[1])
B100 = int(B * 128)
print(A * B100 // 128)

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

if (1 <= a <= 100) and (1 <= b <= 100):
    print(a * b)

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

print(math.floor(a*int(float(b)*100)/100))

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

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

print(math.floor(a*int(float(b)*100+0.1)/100))

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

Solution (Python):
from collections import deque
import math

def Next(): return input()
def NextInt(): return int(Next())
def NextInts(): return map(int,input().split())
def Nexts(): return map(str,input().split())
def NextIntList(): return list(map(int,input().split()))
def RowInts(n): return [input() for i in range(n)]

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

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

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

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

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

Solution (Python):

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

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

print(A*B)

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

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

Solution (Python):
a, b = map(str, input().split())
A = int(a)
B = round(float(b) * 100)
print(A * B // 100)

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

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

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

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

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import numpy as np

rl = sys.stdin.readline

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

print(a*b)

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

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

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

print(a*b)

Solution (Python):
A, B = input().split()
A = int(A)
B = float(B)
B = int(B * 1000)
C = A * B
C //= 1000
print(C)

Solution (Python):
A, B = input().split()
A = int(A)
B = int(float(B)*100)
print(int(A*B/100))

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

Solution (Python):
a,b = map(float,input().split())
A = int(a)
B = 100*b
c = int(A*B//100)

print(c)

Solution (Python):

a, b = input().split()
a = int(a)
b = float(b) * 1000
b = int(b)
print(int((a * b) // 1000))

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
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())
def LF(): return list(map(float,sys.stdin.readline().rstrip().split()))

A,B = LF()
A = int(A)
B = int(B*100)
print(int(A*B/100))

Solution (Python):
from decimal import *
A, B = input().split()
C = str(Decimal(A) * Decimal(B))
for i in C:
  if i ==".":
    exit()
  else:
    print(i, end ="")

Solution (Python):
A, B = input().split()
A = int(A)
B = float(B)
B = int(B * 1000)
C = A * B
C //= 1000
print(C)

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

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

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

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

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

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

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

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

Solution (Python):
A,B = input().split()
print(int(A)*int(float(B)*100)//100)

Solution (Python):


import sys
import math
input = sys.stdin.readline
sys.setrecursionlimit(10**6)


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


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

if __name__ == '__main__':
    main()
'''
cd ~/Desktop/Programming/AtCoder/contest/abc169/abc169_a && sh test_py.sh
cd ~/Desktop/Programming/AtCoder/contest/abc169/abc169_a && sh etest_py.sh
cd ~/Desktop/Programming/AtCoder/contest/abc169/abc169_a && sh submit_py.sh
'''

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

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

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

print( a * b )

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

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

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

Solution (Python):
import numpy as np
import scipy as sp
import math

a, b = map(str, input().split())
a = int(a)
b = int(float(b) * 100.001)
ans = int(a * b // 100)
print(ans)

Solution (Python):
import math
a, b = map(str, input().split())
print(math.floor((int(a)*(float(b)*100))/100))

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

print(a*b)

Solution (Python):
import heapq
from sys import stdin
input = stdin.readline







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






     
def main():
    print(a*b)
    
if __name__ == '__main__':
    main()

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

print(a*b)

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

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

Solution (Python):
def main():
    from functools import reduce
    from operator import mul

    print(reduce(mul, map(int, input().split())))


if __name__ == '__main__':
    main()

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

Solution (Python):
A,B = input().split()
print(int(A) * round(float(B)*100)//100)

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

print(a*b)

Solution (Python):
A,B = input().split()
print(round(int(A)*(float(B)*100)//100))

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

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

print(a*b)

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

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

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

Solution (Python):
import math
a,b = map(float,input().split())
b = math.floor(b*100+0.4)
ans = (a*b)/100
print(math.floor(ans))

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

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

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

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

Solution (Python):
import decimal
number = input().split()
A      = int(number[0])
B      = decimal.Decimal(number[1])
print(int(A*B))

Solution (Python):

import sys


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



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

if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))



A,B = LI()

print(A*B)

Solution (Python):
from decimal import Decimal

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

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

Solution (Python):

from decimal import Decimal 
A, B = [s for s in input().split()]
A = int(A)
B = Decimal(float(B) * 100)
 
print(str(A * B // 100))

Solution (Python):
import math
a,b = [float(x) for x in input().split()]
a = int(a)
b = int(b*100)
print(int(math.floor(a*b)//100))

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

Solution (Python):

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

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

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

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

Solution (Python):
import math as m
a,b=list(map(float,input().split()))
print(m.floor(a*(b*10**5)/10**5))

Solution (Python):

[a, b] = list(map(int, input().strip().split()))
print(a*b)

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

Solution (Python):
listed = input().split()
mul = 1
for num in listed:
  num = int(num)
  if num == 0:
    mul = 0
    break
  if mul != -1:
    mul *= num
    if mul > 10**18:
      mul = -1
print(int(mul))

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

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

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

Solution (Python):
from decimal import Decimal
N = list(map(str,input().split()))
A = Decimal(N[0])
B = Decimal(N[1])

print(int(A * B))

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

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

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

print(a*b)

Solution (Python):

A, B = [s for s in input().split()]
A = int(A)
B = round(float(B) * 100)
 
print(A * B // 100)

Solution (Python):
from decimal import Decimal, ROUND_FLOOR
import math
a,b=map(str,input().split())
c=Decimal(int(a))*Decimal(float(b)*100)
d = int(c.quantize(Decimal('0'),  rounding=ROUND_FLOOR))
print(d//100)

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

Solution (Python):
def Multiplication1():

    
    num_a, num_b = map(int, input().split())

    output = num_a*num_b

    print(output)

if __name__ == '__main__':
    Multiplication1()

Solution (Python):
from decimal import Decimal, ROUND_FLOOR
 
a,b = input().split()
a = int(a)
b = Decimal(b)
 
print(int(a*b))

Solution (Python):
ab = input().split()
a = int(ab[0])
b = round(100*float(ab[1]))
print(int((a*b)//100))

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

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

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

Solution (Python):

A,B=map(float,input().split())
C=B*100
D=A*round(C)

print(int(D//100))

Solution (Python):
import math
A, B = map(float, input().split())
B *= 100
mul = math.floor(A * B)
print(int(mul/100))

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

Solution (Python):


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

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

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

Solution (Python):
import math
from decimal import Decimal
A,B = input().split()
A = int(A)
B = Decimal(B)
print(int(A*B))

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

Solution (Python):
import math
a, b = map(str, input().split())
a = int(a)
b = float(b)

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

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

Solution (Python):
import math
import sys

a,b = input().split()
k = int(a) * int(float(b))
answer = math.floor(k)
print(answer)

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

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

intmulti  = int(int(A)*float(B))

print(intmulti)

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

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

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

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

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

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

Solution (Python):
import math
a,b = input().split()
k = int(a) * int(b)
answer = math.floor(k)
print(answer)

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

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

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

Solution (Python):
import math

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

C=math.floor(A*B)
print(C)

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

Solution (Python):
import math
A,B = map(float,input().split())

d = A*B
c = math.floor(d)
print(c)

Solution (Python):
import math

A,B=input().split()







if isinstance(B,int):
    B = int(B)
else:
    B = float(B)

print(math.floor(int(A)*B))

Solution (Python):
import math

t = input().split()
A = int(t[0])
B = float(t[1])
ans = math.floor(A * B)

print(ans)

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

Solution (Python):
w=input().split()
a,b=float(w[0]),float(w[1])
print(int(a*b))

Solution (Python):
a,b=map(float,input().split())
import math
a=int(math.floor(a))
b=int(math.floor(b*100))


c=math.floor(a*b/100)


print(c)

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

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

print(A*B)

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

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

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

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

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

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