Problem:
 Score : 300 points    Problem Statement Compute A \times B , truncate its fractional part, and print the result as an integer.      Constraints  0 \leq A \leq 10^{15}  0 \leq B < 10  A is an integer.  B is a number with two digits after the decimal point.         Input Input is given from Standard Input in the following format:  A  B       Output Print the answer as an integer.        Sample Input 1 198 1.10      Sample Output 1 217  We have 198 \times 1.10 = 217.8 . After truncating the fractional part, we have the answer: 217 .       Sample Input 2 1 0.01      Sample Output 2 0       Sample Input 3 1000000000000000 9.99      Sample Output 3 9990000000000000

Solution (Python):
import math
a,b=input().split()
a=int(a)
L=list(b)
if "." in L and L[0]==0:
  c=L[2]+L[3]
  c=int(c)
  print(c*a//100)
elif  "." in L and L[0]!=0:
  c=L[0]+L[2]+L[3]
  c=int(c)
  print(c*a//100)

Solution (Python):
A,B=input().split()
a=0
A=int(A)
B=B[::-1]
b=0
for i in range(len(B)):
  c=pow(10,b)
  if B[i]!='.':
    b+=1
    a+=(int(B[i])*c*A)
count=0
for j in range(len(B)):
  if B[j]=='.':
    break
  count+=1
a=a//pow(10,count)
a=int(a)
print(a)

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

tmp = b.split('.')
b = ''.join(tmp)
ans = []
for i in reversed(range(len(b))):
   x = 0
   cnt = 0
   for j in reversed(range(len(a))):
      x += int(a[j]) * int(b[i]) * pow(10, cnt)
      cnt += 1
   ans.append(x)

tmp = [ans[i] * pow(10, i) for i in range(len(ans))]
print(sum(tmp)//100)

Solution (Python):
from decimal import Decimal
from fractions import Fraction

import math


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




aa = math.floor(a)

d1 = Decimal(str(a))
d2 = Decimal(str(b))


ans = math.floor(d1*d2)
print(ans)

Solution (Python):
from decimal import *

str = input().split()
A = Decimal(str[0])
B = Decimal(str[1])

print((A*B).quantize(Decimal('0'), rounding=ROUND_DOWN))

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

Solution (Python):
from decimal import Decimal


def main():
    tmp = input().split()
    A = int(tmp[0])
    B = Decimal(tmp[1])
    A = Decimal(A)
    B = Decimal(B)
    print(int(A*B))

    
if __name__ == '__main__':
    main()

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

a = int(a)
b = Decimal(b)
b*=100
ans = a*b
if ans < 100:
    print(0)
else:
    print(ans//100)

Solution (Python):
import decimal
import math
def main():
    A, B = input().split()
    A = decimal.Decimal(A)
    B = decimal.Decimal(B)
    print(math.floor(A*B))

if __name__ == "__main__":
    main()

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

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

Solution (Python):
A, B = input().split()
A = int(A)
B = int(float(B)*100.0+0.5)

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd, floor
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

from decimal import *
 
A, B = MAP()
A = int(A)
b = ""
for x in B:
	if x != ".":
		b += x

b = int(b)
print(A*b//100)

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

Solution (Python):
def main():
    A, B = input().split(" ")
    A = int(A)
    B = int(B.replace(".", ""))

    result = str(A*B)
    
    if len(result) < 2:
        print(0)
    else:
        print(result[:-2])
if __name__=="__main__":
    main()

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

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

if int(b[0])==0:
    if int(b[2])==0:
        b100 = int(b[3])
    else:
        b100 = int(b[2]+b[3])
else:
    b100 = int(b[0]+b[2]+b[3])
    
ab = str(a*b100)

if len(ab)>=3:
    print(ab[:-2])
else:
    print(0)

Solution (Python):
from decimal import Decimal
import math
a, b = map(str, input().split())
print(math.floor(Decimal(a) * Decimal(b)))

Solution (Python):
a,b = map(str,input().split())
a2 = int(a)
b2 = 100*int(b[0:1])+10*int(b[2:3])+int(b[3:4])
if a2 == 0 or b2 == 0:
    ans = 0
else:
    tmp = str(a2*b2)
    l = len(tmp)
    if l <= 2:
        ans = 0
    else:
        ans = int(tmp[0:l-2])
print(ans)

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

A, B = input().split()
B2 = ''

for Bi in B:
    if Bi!='.':
        B2 += Bi
    
C = int(A)*int(B2)

print(C//100)

Solution (Python):
A,B=input().split()
B=B[0]+B[2:]
i=len(B)-1
ans=str(int(A)*int(B))
print(ans[:-i] if ans[:-i]!='' else 0)

Solution (Python):
from decimal import *
import math
input = list(map(Decimal, input().split()))
print(math.floor(input[0]*input[1]))

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

Solution (Python):
from decimal import *

a, b = input().split()

a = str(a)
b = str(b)

c = str(Decimal(a) * Decimal(b))
cc = Decimal(c)//Decimal(1)

print(int(cc))

Solution (Python):
import math

As,Bs=input().split()
if As=="0" or Bs=="0.00":
    print("0")
else:
    A=int(As)
    Bs=Bs.replace('.','')
    B=int(Bs)
    ans=int(A)*int(B)
    anss=str(ans)
    if len(anss)<3:
        print("0")
    else:
        print(anss[:-2])

Solution (Python):
from decimal import *
a = input().split()
print(int(int(a[0]) * Decimal(a[1])))

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

Solution (Python):
import math
import decimal

n,k =input().split()

a=decimal.Decimal(n) * decimal.Decimal(k)

print(math.floor(a))

Solution (Python):
from fractions import Fraction

a,b= map(str, input().split())
c=''
for i in range(len(b)):
    if b[i]!='.':
        c+=b[i]

a = int(a)
c= int(c)


print(int((a * c) // 100))

Solution (Python):
a,b = map(str, input().split())
a = int(a)
b = b[0] + b[2] + b[3]
b = int(b)
ans = a*b
if (ans<100):
    print(0)
else:
    ans = str(ans)
    print(ans[:-2])

Solution (Python):
from decimal import Decimal

a, b = list(input().split())
ans = Decimal(a) * Decimal(b)
ans = str(ans).split('.')[0]
print(int(ans))

Solution (Python):
s = input().split()
ss = s[1].split('.')
s[1] = int(ss[0]) * 100 + int(ss[1])
print(int(s[0]) * s[1] // 100)

Solution (Python):
import decimal

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

print(int(a*b))

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

    a = int(a)
    b = int(round(float(b) * 100, 0))

    res = a * b

    print(int(res // 100))

if __name__ == '__main__':
    main()

Solution (Python):
import math
x,y=input().split()
a=int(x)
y=y.replace('.','')
b=int(y)
z=(a*b)//100
print(z)

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

Solution (Python):
from decimal import Decimal

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

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

print(int(A*B))

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

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

Solution (Python):



import sys
import decimal
import math
"""
def input():
    return sys.stdin.readline()
"""

def resolve():
    input_list = list(input().split())

    for i, n  in enumerate(input_list):
        if i == 0:
            a = int(n)
        else:
            b = float(n)

    dec_a = decimal.Decimal(a)
    dec_b = decimal.Decimal(b)
    dec_b = round(dec_b, 3)
    ans = dec_a * dec_b


    ans = math.floor(ans)
    print(int(ans))

if __name__ == "__main__":
    resolve()

Solution (Python):
A, B = input().split()
A = int(A)
B = int(B[:-3]+B[-2:])

if len(str(A*B)) >= 3:
    print(str(A*B)[:-2])
else:
    print(0)

Solution (Python):
a,b=input().split()
a=int(a)
b=int(b[:1] + b[-2:])
r=a*b
if r < 100:
    print(0)
else:
    print(str(r)[:-2])

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

a = int(A)
b = decimal.Decimal(B)

X = (a * b)//1

print(int(X))

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

Solution (Python):
import math
from decimal import Decimal, ROUND_DOWN
A,B = map(str,input().split())
A = Decimal(A)
B = Decimal(B)

pro = str(A*B)

print(Decimal(str(pro)).quantize(Decimal('0'), rounding=ROUND_DOWN))

Solution (Python):
from decimal import Decimal
L,R=map(str,(input().split()))
L=Decimal(L)
R=Decimal(R)
ans=L*R
print(int(ans))

Solution (Python):
input_list = input().split()

A = int(input_list[0])
B = float(input_list[1])

B_100 = int(round(B * 100))

result = A * B_100 // 100

print(result)

Solution (Python):
from decimal import Decimal

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

A = Decimal(str(A))
B = Decimal(str(B))

print(int(A*B))

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

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

print(a*b//100)

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

Solution (Python):
import decimal
A,B= list(input().split())
a = decimal.Decimal(A)
b = decimal.Decimal(B)
ans =decimal.Decimal(a*b).quantize(decimal.Decimal("0"), rounding=decimal.ROUND_FLOOR)
print(ans)

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

A = int(A)
B = B.replace('.', '')
B = int(B)

C = str(A * B)
if len(C) <= 2:
    print(0)
else:
    print(C[:-2])

Solution (Python):
import math
from decimal import Decimal

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

ans = math.floor(Decimal(A) * Decimal(B))

print(ans)

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

    a = int(a)
    b1, b2 = b.split('.')
    b1 = int(b1)
    b2 = int(b2)

    zajedno = a*b1 + (b2*a)//100
    print(int(zajedno))


if __name__ == '__main__':
    main()

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

va = int(a)
rep = b.replace('.', '')
vb2 = int(rep)
vb = float(b)

print(int((va * vb2) // 100))

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

Solution (Python):
import decimal

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

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

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

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

Solution (Python):

from decimal import Decimal
a, b = map(str, input().split())
print(int(Decimal(a)*Decimal(b)))

Solution (Python):
import decimal

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

print(int(a*b))

Solution (Python):
A, B = input().split()
a = int(A)
C = []
for c in B:
    C.append(c)
del C[1]
b = 0
b += int(C[0]) * 100
b += int(C[1]) * 10
b += int(C[2])

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

Solution (Python):
import sys

input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]

tin=lambda : map(int, input().split())
lin=lambda : list(tin())
mod=1000000007



def main():
	
	
	a, b = input().split()
	a = int(a)
	b = int('1'+b[0]+b[2]+b[3])
	r = a*b-a*1000
	if r <=99:
		return 0
	return int(str(r)[:-2])
	
	
	
	

isTest=False

def pa(v):
	if isTest:
		print(v)
		
def input_clipboard():
	import clipboard
	input_text=clipboard.get()
	input_l=input_text.splitlines()
	for l in input_l:
		yield l

if __name__ == "__main__":
	if sys.platform =='ios':
		if input_method==input_methods[0]:
			ic=input_clipboard()
			input = lambda : ic.__next__()
		elif input_method==input_methods[1]:
			sys.stdin=open('inputFile.txt')
		else:
			pass
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

Solution (Python):
[a, b] = list(input().split())
a = int(a)
newb = ''
for i in b:
    if i == '.':
        continue
    newb += i
newb = int(newb)
print((a*newb)//100)

Solution (Python):
from decimal import *

A, B = input().split()
a = Decimal(A)
b = Decimal(B)

output = Decimal(a*b).quantize(Decimal('0'), rounding=ROUND_FLOOR)
print(output)

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

Solution (Python):
a,b=input().split()
r=''
x=0
for i in b:
  if i=='.':
    r=r
  elif i!='0':
    x=1
    r=r+i
  elif x==1 and i=='0':
    r=r+i
if len(r)==0:
  r='0'
A=int(a)
B=int(r)
print(A*B//100)

Solution (Python):
from decimal import Decimal
s = input().split()
a,b = int(s[0]),Decimal(s[1])
print(int(a*b))

Solution (Python):

a,b = map(str,input().split())
a = int(a)
b = list(b)
ans1 = int(a) * int(b[0])
ans2 = str(((int(b[2]) * 10) + (int(b[3]) * 1))*a)
ans2 = list(ans2)
ans = ''

if len(ans2) >= 3:
  ans2.pop()
  ans2.pop()
  for i in ans2:
    ans += i
else:
  ans = 0
  
  
print(ans1 + int(ans))

Solution (Python):
A, B = input().split()
A = int(A)
Bi, Bf = B.split(".")
Bi = int(Bi)
Bf = int(Bf)
ans = A * Bi + (A * Bf // 100)
print(ans)

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

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

B = list(B)
B.remove(".")

A = int(A)
B = int(B[0]) * 100 + int(B[1]) * 10 + int(B[2])

print(A * B // 100)

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

Solution (Python):
from decimal import Decimal

S = input().split()

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

ans = A*B

print(int(ans))

Solution (Python):
import decimal
A,B = map(decimal.Decimal,input().split())
c = decimal.Decimal(A * B)
d = c.quantize(decimal.Decimal('0'), rounding=decimal.ROUND_FLOOR)
print(d)

Solution (Python):
import math
l=input().split()
a,b=int(l[0]),round(float(l[1])*100)
ans = str(a*b)
if len(ans)<=2:
  print(0)
  exit()
print(ans[:-2])

Solution (Python):
input_ = input().split()
a = int(input_[0])
b = input_[1].split('.')
b = b[0] + b[1][:2]

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

Solution (Python):
A,B = map(str,input().split())
a = int(A)
b = int(B[0])*100 + int(B[2])*10 + int(B[3])
print((a*b)//100)

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

Solution (Python):
A, B = input().split()
a = B.split('.')
a = a[0] + a[1]
A, B = int(A), int(a)
print((A * B) // 100)

Solution (Python):
ab = input().split()
a = int(ab[0])
b = ab[1]
import math
s = a*int(b[0])
ad = None
if len(b) > 2:
  tmp = str(a*int(b[2]))
  if len(str(tmp)) > 1:
    s+=int(str(a*int(b[2]))[:-1])
  ad = int(str(a*int(b[2]))[-1])
if len(b) > 3:
  tmp = str(a*int(b[3]))
  if len(str(tmp)) > 2:
    s+=int(str(a*int(b[3]))[:-2])
  if len(str(a*int(b[3]))) > 1 and ad:
    ad += int(str(a*int(b[3]))[-2])
    if ad > 9:
      s += int(str(ad)[:-1])
  

print(s)

Solution (Python):
from decimal import Decimal

a, b = map(str, input().split())
ans_i = int(a) * int(float(b))
ans_f = int(Decimal(a) * (Decimal(b) - int(float(b))))
print(ans_i + ans_f)

Solution (Python):
import math
from decimal import Decimal

A = input().split()
answer = Decimal(A[0]) * Decimal(A[1])

print(math.floor(answer))

Solution (Python):
import numpy as np
import math
from decimal import Decimal

A,B = (x for x in input().split())

A = Decimal(str(A))

B = Decimal(str(B))

ans = A*B
ans=int(math.floor(ans))

print(ans)

Solution (Python):
from decimal import Decimal

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

print(int(A * B))

Solution (Python):




import math
import sys
import bisect
import heapq  
from collections import deque
inf = 10 ** 18
mod = 10 ** 9 + 7
a,b = input().split()
bpre = []
for c in b:
    if c != '.':
        bpre.append(c)
a100 = int(a)
b100 = int(''.join(bpre))
ans = str(a100*b100)
if len(ans) > 2:
    print(ans[:-2])
else:
    print(0)

Solution (Python):
from decimal import Decimal
from decimal import Decimal, getcontext
import math
a,b = map(float,(input().split()))








a = str(a)
b = str(b)
ans = Decimal(a) * Decimal(b)

ans = math.floor(ans)

print(ans)

Solution (Python):
t = input().split()
a = int(t[0])
b100 = int(t[1].replace('.', ''))
ans = str(a*b100)
if len(ans) <= 2:
    print(0)
else:
    print(ans[:-2])

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

Solution (Python):
import sys
from decimal import Decimal

num_list = input().split()
ans = Decimal(num_list[0]) * Decimal(num_list[1])
print(int(ans))

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

Solution (Python):
import math
from decimal import Decimal

A,B=map(Decimal,input().split())
print(math.floor(A*B))

Solution (Python):
from decimal import Decimal
from math import floor
a, b = map(Decimal, input().split())
print(floor(a*b))

Solution (Python):

import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
import numpy as np
from decimal import *
from collections import deque
from math import gcd
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') 
def lcm(a,b):return (a*b) // gcd(a,b) 
def iin(): return int(sys.stdin.readline()) 
def ifn(): return float(sys.stdin.readline()) 
def isn(): return sys.stdin.readline().split() 
def imn(): return map(int, sys.stdin.readline().split()) 
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) 
def fmn(): return map(float, sys.stdin.readline().split()) 
def iln(): return list(map(int, sys.stdin.readline().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, sys.stdin.readline().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD
def lprint(l): print(*l, sep='\n')

import numpy as np
import decimal

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

print(math.floor(a*b))

Solution (Python):
import math

from decimal import  Decimal
a, b = map(Decimal, input().split())

print(math.floor(a*b))

Solution (Python):
from decimal import Decimal
import math
a, b = input().split()
res = Decimal(a) * Decimal(b)
print(math.floor(res))

Solution (Python):
from decimal import *
A, B = input().split()
a = Decimal(A)
b = Decimal(B)
print(Decimal(a*b).quantize(Decimal('0'), rounding=ROUND_DOWN))

Solution (Python):
A,B = map(str,input().split())
a = int(A)
b0 = int(B[0])
b1 =  int(B[2])
b2 =  int(B[3])
c = a*b0*100 + a*b1*10 + a*b2
print(c//100)

Solution (Python):
from decimal import *


A, B = input().split()

A = Decimal(A)
B = Decimal(B)

ans = Decimal((A*B)//1)
print(int(ans))

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

print((a * b) // 100)

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

Solution (Python):
from decimal import *

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

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

Solution (Python):

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

C=int(A)
D=int(B[0]+B[2]+B[3])

print(C*D//100)

Solution (Python):
import sys
from decimal import *
a,b = map(str, sys.stdin.readline().rstrip("\n").split())
a = Decimal(a)
b = Decimal(b)
c = a*b
c.quantize(Decimal('0'), rounding=ROUND_DOWN)
print(int(c))

Solution (Python):
import numpy as np
import math
import collections
from decimal import *


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


print(int(A * B))

Solution (Python):
import math
from decimal import Decimal, getcontext

getcontext().prec = 128

A, B = input().split()
A = Decimal(A)
B = Decimal(B)
print(math.floor(A * B))

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

Solution (Python):
import math
import pprint
import fractions
import collections
import itertools
from decimal import *
A,B=map(str,input().split())

getcontext().prec=40
A=int(A)


A=str(A)
A=list(map(int,A))
b=list(str(B))
B=[0]*3

N=len(A)                
table=[[0 for _ in range(len(A)+1)] for _ in range(10)]
for i in range(1,10):
    career=0
    for j in range(N,0,-1):
        buf=A[j-1]*i+career
        career=buf//10
        table[i][j]=buf%10
    table[i][0]=career

A=list(A)
A.insert(0,0)
A.insert(len(A),0)
A.insert(len(A),0)


ans=[0]*(len(A))
B=[int(b[0]),int(b[2]),int(b[3])]


for i in range(2,-1,-1):
    piv=B[i]
    buf=[]
    buf = table[piv]
    
    career=0
    for j in range(N,-1,-1):
        num=ans[j+i]+buf[j]+career
        career=num//10
        ans[j+i]=num%10
    
    
ans=map(str,ans)
s="".join(ans)
print(int(s[:len(s)-2]))

Solution (Python):
a,b=input().split()
b=b[0]+b[2]+b[3]
length=len(a)
ans=0
for i in range(length):
    n=int(a[-i-1])*10**(i)
    for j in range(3):
        m=int(b[-j-1])*10**j
        ans+=n*m
print(ans//100)

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

getcontext().prec = 20

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

print(int(a*b))

Solution (Python):
import decimal

A,B = map(decimal.Decimal,input().split())
print((A*B).quantize(0,rounding=decimal.ROUND_FLOOR))

Solution (Python):









def solve():
    N, M = input().split()

    n = int(N)
    f = float(M)
    m = int(f * 100 + 0.1)
    ans = n * m // 100

    return ans


def main():
    print(solve())


if __name__ == "__main__":
    main()

Solution (Python):
import sys
input = sys.stdin.readline
import math 
def main():
    A, B = map(float, input().split())
    A = round(A)
    B = round(B*100)
    ans = round(A*B) 
    ans = ans//100
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
import sys
from decimal import Decimal
A,B= map(str,input().split())

A = Decimal(A)
B = Decimal(B)


print(int(A*B))

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

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

Solution (Python):
from fractions import Fraction
a, b = input().split()
A = int(a)
B = Fraction(b)
ans = A*B
ans = ans // 1
print(int(ans))

Solution (Python):
import math
import decimal

A, B = input().split()
a = decimal.Decimal(A)
b = decimal.Decimal(B)

ans = a*b
print(math.floor(ans))

Solution (Python):
def solve(a,b):  
    a = int(a)
    res = int(b[0]) * 100 * a + int(b[2]) * 10 * a + int(b[3]) * 1 * a 
    return res//100

a,b = input().split()
res = solve(a,b)
print(res)

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

Solution (Python):
a,b = map(float, input().split())
'''b100 = int(b*100)
ab = int(a*b100)
print(int(ab//100))'''
import decimal
print(int(decimal.Decimal(int(a)) * decimal.Decimal(str(b))))

Solution (Python):
import math
import decimal

temp = [i for i in input().split()]
A = int(temp[0])
B = decimal.Decimal(temp[1])

print(int(A*B))

Solution (Python):
from decimal import Decimal
A, B = map(str, input().split())

A = Decimal(A)
B = Decimal(B)

print(int(A*B))

Solution (Python):
A, B = map(str, input().split())
A = int(A)
B = int(B.replace('.', ''))
tmp = str(A * B)
if len(tmp) >= 3:
    print(tmp[:-2])
else:
    print(0)

Solution (Python):
from decimal import Decimal
s = input().split()
a=int(s[0]);b=Decimal(s[1])
print(int(a*b))

Solution (Python):

A,B = input().split()
A = int(A)
B_i, B_d = B.split('.')
B_i = int(B_i)

B_d = list(B_d)
B_100 = 100*B_i + int(B_d[0])*10 + int(B_d[1])

result_100 = A * B_100

if result_100 >= 100:
    print(str(result_100)[:-2])
else:
    print(0)

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

Solution (Python):
from decimal import Decimal as d
a,b=map(str,input().split())
a=d(a)
b=d(b)
c=d(a*b)
c=int(c)
print(c)

Solution (Python):
import math
from decimal import *
exp = Decimal(10**23)
A,B = map(str, input().split())
res = int(A)*Decimal(B)
print(math.floor(res))

Solution (Python):
from sys import stdin
import math
from decimal import Decimal

A, B = input().split(" ")
a = int(A)
b = Decimal(B)
print (math.floor(a*b))

Solution (Python):
from decimal import *

if __name__=="__main__":
    A, B = input().split(' ')
    A = int(A)
    B = Decimal(B)
    print(int(A*B))

Solution (Python):
dat = input().split(' ')
a = int(dat[0])
b_top = int(dat[-1].split('.')[0])
b_bot = int(dat[-1].split('.')[1])
b = b_top*100 + b_bot

ans = a * b
if ans < 100:
    print(0)
else:
    print(str(ans)[:-2])

Solution (Python):
from decimal import *
a,b=map(str,input().split())
da=Decimal(a)
db=Decimal(b)
ans=da*db
print(int(ans))

Solution (Python):
from decimal import Decimal
a, b = map(str, input().split())
ans = Decimal(a) * Decimal(b)
print("%d"%(ans))

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 = B.replace(".", "")
B = int(B)
AB = A*B
AB = str(AB)
AB = "00" + AB
AB = AB[:-2]
print(int(AB))

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

Solution (Python):
a, b = input().split()
a = int(a)
b = int(b[0] + b[2] + b[3])
ans = a*b
if ans < 100:
    print(0)
else:
    print(str(ans)[:-2])

Solution (Python):



import sys
from decimal import Decimal
from collections import defaultdict, deque
from heapq import heappush, heappop
import math
import bisect
input = sys.stdin.readline




a, b = input().split()

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

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

A_int = int(A)

B_int = int(B.split('.')[0])
B_float = int(B.split('.')[1])

import math
import decimal



print(A_int*B_int+A_int*B_float//100)

Solution (Python):
A ,B= map(float,input().split())
A = int(A)
C = str(B)
if B == 10.0:
  D = 1000
elif B == 0.0:
  D = 0
elif len(C) == 4:
  D = int(C[-1]) + int(C[-2])*10 + int(C[-4])*100
elif len(C) == 3:
  D = int(C[-1])*10 + int(C[-3])*100
  
ans = A*D
ans = ans//100
print(ans)

Solution (Python):


import sys
import math
from decimal import Decimal, ROUND_DOWN


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
        
        
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    tokens = lines[0].split(' ')
    a = tokens[0]
    b = tokens[1]

    return (a, b)


def solve(a0, b0):

    a = int(a0)    
    b = float(b0)





    a =  Decimal(a0)
    b =  Decimal(b0)
    
    ab = a * b
    c = int(ab.quantize(Decimal('1.'), rounding=ROUND_DOWN))
    
    if debug:
        print(c)

    return c
    


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

Solution (Python):
from decimal import *
import math

A,B = input().split()
a = Decimal(A)
b = Decimal(B)

result = Decimal(str(a*b)).quantize(Decimal('.01'), rounding=ROUND_DOWN)

print(int(result))

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

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

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

Solution (Python):
from decimal import Decimal
import math

a, b = map(Decimal, input().split())
print(math.floor(a * b))

Solution (Python):
from decimal import Decimal

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

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




C = A*B


print(Decimal(math.floor(C)))

Solution (Python):
import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

A2,B2=map(str, stdin.readline().split())
A=int(A2)
tmp=list(B2)


B1=int(tmp[0])
B2=int(tmp[2])
B3=int(tmp[3])

ans=0
ans+=B1*A
ans+=(A*B2)//10
ans+=(A*B3)//100
if(10<=(((A*B2)%10)+(((A*B3)%100)//10))):
    ans+=1

print(ans)

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

ans = a*int(b[0])
ans2 = a*int(b[2:])


if len(str(ans2))>2:
    ans = ans + int(str(ans2)[:-2])
print(ans)

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

A = int(A)
B = int(B[0] + B[2:])

C = A * B // 100

print(C)

Solution (Python):
from decimal import Decimal

for _ in range(1):
    a = list(input().split(' '))
    A = int(a[0])
    B = Decimal(a[1])

ans = str(A * B)
idx = 0
for i in range(len(ans)):
    if ans[i] == '.':
        idx = i
        break
print(ans[:i])

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

Solution (Python):
from decimal import Decimal, ROUND_DOWN, ROUND_FLOOR
from decimal import getcontext

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

ans = (Decimal(a) * Decimal(b)).quantize(Decimal("0"), rounding=ROUND_FLOOR)

print(ans)

Solution (Python):
import math

import queue
from collections import deque,defaultdict
import heapq
from sys import stdin,setrecursionlimit


ipt = stdin.readline
setrecursionlimit(10**7)

a,b = input().split()
if len(a)>2:
    a1 = int(a[:-2:])
    a2 = int(a[-2::])
    b1 = int(float(b))
    b2 = int(b[2::])
    print(a1*b1*100+a1*b2+a2*b1+a2*b2//100)
else:
    a2 = int(a)
    b1 = int(float(b))
    b2 = int(b[2::])
    print(a2*b1+a2*b2//100)

Solution (Python):
import decimal
n,m = input().split()

a = decimal.Decimal(n)
b = decimal.Decimal(m)
ans = str(a*b).split('.')[0]
print(ans)

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



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







from decimal import *

ans = Decimal(a)*Decimal(b)
ans = int(ans)

print(ans)

Solution (Python):
import sys
import decimal
from decimal import Decimal

sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7


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


def main():
    A, B = input().split()
    A = Decimal(A)
    B = Decimal(B)
    ans = A * B
    ans = ans.quantize(decimal.Decimal("1"), rounding=decimal.ROUND_FLOOR)
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
import math

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

b1 = int(b[0]) * 100
b2 = int(b[2]) * 10
b3 = int(b[3])

ans = a * b1 + a * b2 + a * b3
ans = str(ans)

if len(ans) >= 3:
	print(ans[:-2])
else:
	print(0)