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):
from decimal import Decimal
print((lambda a, b: int(a * b))(*map(Decimal, input().split())))

Solution (Python):
from collections import defaultdict
from math import gcd
import time
import sys
from collections import Counter
import itertools
import math
from decimal import *



input = sys.stdin.readline

temp = input().split(" ")
a = Decimal(temp[0])
b = Decimal(temp[1])
ans = a*b
print(math.floor(ans))

Solution (Python):
import math
A,B=input().split()
A=int(A)
x=int(B[-2:])
y=int(B[:-3])

print(A*y + A*x//100)

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

for i, c in enumerate(b):
    if c == ".":
        break
u = 10**(len(b)-i-1)
b_n = "".join(b.split("."))

print(int(a)*int(b_n)//u)

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

Solution (Python):
S = input()
A, B = S.split(" ")
A = int(A)
b1, b2, b3 = int(B[0]), int(B[2]), int(B[3])

ans = A*b1 + (A*10*b2 + A*b3)//100

print(ans)

Solution (Python):
from decimal import *
N, M = input().strip().split()
N=int(N)
x = Decimal(str(M))
x = x * 100

print(x*N//100)

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

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

Solution (Python):
import sys
import math

sys.setrecursionlimit(10**7)

a, b = input().split()
a = int(a)
b = "".join(b.split("."))
if b == "000":
    b = 0
else:
    i=0
    while b[i] == "0":
        i += 1
    b = int(b[i:])
ans = str(a*b//100)
i=0
while i < len(ans) and ans[i] != ".":
    i += 1
print(ans[:i])

Solution (Python):
import decimal
A, B = input().split()
val_pi_d = decimal.Decimal(A) * decimal.Decimal(B)
val_floor_d = val_pi_d.quantize(decimal.Decimal('1'), rounding=decimal.ROUND_FLOOR)
print(val_floor_d)

Solution (Python):









from decimal import Decimal, getcontext
getcontext().prec = 1000








import math

A,B = input().split()






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

ans = A*B


print(int(ans))

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

Solution (Python):
import sys
import decimal
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())
def debug(*args, sep=" ", end="\n"): print("debug:", *args, file=sys.stderr, sep=sep, end=end) if not __debug__ else None
def exit(*arg): print(*arg); sys.exit()


def main():
    decimal.getcontext().prec = 100
    a, b = input().split()
    a = int(a)
    b = decimal.Decimal(b)
    
    print(int(b*a))
    return

if __name__ == "__main__":
    main()

Solution (Python):
arr = input().split(' ')
a = arr[0]
b = arr[1]
a = int(a)
tpb = b[-2:]
b = b[:-3]
b = int(b)
tpb = int(tpb)
print(int(a*b + int((a*tpb)//100)))

Solution (Python):
nums = input().split()
a = int(nums[0])
b = int((nums[1].replace('.', '')))
result = a * b // 100
print(result)

Solution (Python):
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter

from functools import lru_cache

sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7


def inp():
    '''
    一つの整数
    '''
    return int(input())


def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))


def str_inp():
    '''
    文字列をリストとして読み込む
    '''
    return list(input()[:-1])


a, b = input().split()
a = int(a)
b = list(b)
dot = 0
for i in range(len(b)):
    if b[-i - 1] == ".":
        dot = i
        del b[-1 - i]
        b = int("".join(b))
        break
ans = str(a * b)
if len(ans) <= dot:
    ans = 0
else:
    ans = ans[:-dot]
print(ans)

Solution (Python):
A, B = input().split()
a = int(A)
temp = B[0]+B[2]+B[3]
b = int(temp)

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

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

a = int(a)
b = Decimal(b)
print(math.floor(a*b))

Solution (Python):
from decimal import Decimal
import math


a, b = input().split()

ax = Decimal(a)
bx = Decimal(b)

ans = ax*bx

print(math.floor(ans))

Solution (Python):
from decimal import *
a, b = map(str, input().split())
a = Decimal(a)
b = Decimal(b)
c = a*b
e=c.quantize(Decimal('0'), rounding=ROUND_FLOOR)
print(e)

Solution (Python):
from decimal import *
A,B=map(Decimal,input().split())
ans=A*B
print(ans.quantize(Decimal('1'),rounding=ROUND_FLOOR))

Solution (Python):
import math
a, b = input().split()
A = int(a)
B1 = int(b[0])
B2 = int(b[2])
B3 = int(b[3])
ans = int(A*(B1*100+B2*10+B3))//100
print(ans)

Solution (Python):
import math
data = input().rstrip().split(" ")
if float(data[1]) == 0.0:
    print(0)
else:
    A = int(data[0])
    B = round(float(data[1])*100)
    calc = A*B
    if calc <100:
        print(0)
    else:
        ans = str(calc)
        k = len(ans)-2
        print(ans[0:k])

Solution (Python):
import itertools
import decimal
import math

A,B=input().split()

An=decimal.Decimal(A)
Bn=decimal.Decimal(B)
ans=decimal.Decimal(An*Bn).quantize(decimal.Decimal('0'), rounding=decimal.ROUND_DOWN)
print(ans)

Solution (Python):
from decimal import Decimal

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

Solution (Python):
from decimal import *
import math

a, b = input().split()
c = Decimal(a) * Decimal(b)

print(c.quantize(0, ROUND_FLOOR))

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

Solution (Python):

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

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

Solution (Python):
import math
from decimal import Decimal

L, R = map(Decimal, input().split())
ans = math.floor(L * R)
print(ans)

Solution (Python):
import sys

A, B = sys.stdin.readline().strip().split()
A = int(A)
for i in range(1000):
    if i < 10:
        s = "0.0" + str(i)
    elif i < 100:
        s = "0." + str(i)
    else:
        i = str(i)
        s = i[0] + "." + i[1:]
    if B == s:
        B = int(i)
print(A*B // 100)

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

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

print(A * B // 100)

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

b= decimal.Decimal(b)

print(math.floor(int(a)*b))

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

import math
from decimal import Decimal
print(math.floor(Decimal(a)*Decimal(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
a,b = map(Decimal,input().split())
print(Decimal(a*b)//1)

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

from decimal import Decimal

a,b=input().rstrip().split(" ")
u=Decimal(a)*Decimal(b)

print(int(u))
'''a=int(a)
b=float(b)

u=int(100*b)

print(int(a*b))

Solution (Python):
a, b = input().split()
a = int(a)
b = int(b[0]+b[2]+b[3])

print(a*b//100)

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

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

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

Solution (Python):
from decimal import *

line= input().split(' ')
a= Decimal(int(line[0]))
b= Decimal((line[1]))

x= Decimal(a)*Decimal(b)
x= Decimal(x)-Decimal(x)%1
print(int(x))

Solution (Python):
import numpy as np
A, B = input().split()
A = np.array(A).astype(np.int64)

n = len(B)
Bs = []
for i in range(n):
  if i !=  1:
    Bs.append(np.array(B[i]).astype(np.int64))
Bs

if n == 4:
  sums = A*Bs[0]*100 + A*Bs[1]*10 + A*Bs[2]
elif n ==3:
  sums = A*Bs[0]*100 + A*Bs[1]*10
else:
  sums = A*Bs[0]*100

print(sums//100)

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

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

A = Decimal(a)
B = Decimal(b)

print(math.floor(A*B))

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

Solution (Python):
from decimal import *
a,b = input().split()
ans = Decimal(a) * Decimal(b)
print(ans.quantize(Decimal("1"),rounding=ROUND_DOWN))

Solution (Python):
a,s=[x for x in input().split()]
for i in range(len(s)):
    if s[i]=='.':
        ans=s[0:i]+s[i+1:]
        break
p=str(int(a)*int(ans))
if len(p)<3:
    print(0)
else:
    print(p[0:len(p)-2])

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

Solution (Python):
import math
from decimal import Decimal

A, B = input().split()

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

C = A*B
C = int(C)

print(C)

Solution (Python):

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

A_num = int(A)
if B == "10.00":
    print(A_num * 10)
else:
    B_num = int(B[0]) * 100 + int(B[2]) * 10 + int(B[3])
    print(int((A_num * B_num) // 100))

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

a[0] = int(a[0])
b = int(a[1][0]) * 100 + int(a[1][2]) * 10 + int(a[1][3])
print(a[0] * b // 100)

Solution (Python):
from decimal import *

A, B = input().split()

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

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

Solution (Python):
import math
from decimal import *

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

Solution (Python):
from decimal import Decimal

A,B = input().split()
A = int(A)
B = int(Decimal(B) * 100)

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

Solution (Python):
import math
A, B = input().split()
A = int(A)
B = int(B.replace(".",""))

result = str(A * B)[:-2]

print(result if result != "" else 0)

Solution (Python):
import math

a, b = map(str, input().split())
a = int(a)
b = int(b.replace('.', ''))
ans = str(a * b)

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

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

ans = (A*B)//1000
ans = int(ans)
print(ans)

Solution (Python):
a, b = input().split()
A = int(a)
Bn,Bs = map(int, b.split('.'))

C1 = A * Bn

abs = str(A * Bs)
if A * Bs > 99:
    C2 = int(abs[:-2])
else:
    C2 = 0
print(C1+C2)

Solution (Python):
from decimal import Decimal
s=[input().split()]

a=int(s[0][0])
b=Decimal(s[0][1])
print(int(a*b))

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

print((a*b)//100)

Solution (Python):
import re
A, B, C = map(int, re.split(r'[ \.]', input()))
print(A * (100 * B + C) // 100)

Solution (Python):
a, b = input().split()
a = int(a)
b = int(b[0] + b[2] + b[3])
ans = int(a * b // 100)
print(ans)

Solution (Python):
from decimal import Decimal
a, b = input().split()
c = int(a) * Decimal(b)
cl = list(str(c))
s = ""
for i in range(len(cl)):
    if cl[i] == '.':
        break
    else:
        s += cl[i]
print(s)

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

def main():
    a, b = input().split()
    A = int(a)
    B = int(b[0] + b[2:])
    x = A * B
    print(x // 100)


if __name__ == "__main__":
    main()

Solution (Python):
import math
S=list(map(str, input().split()))
a=S[0]
b=S[1]
c=b[0]+b[2]+b[3]
print(math.floor(int(a)*(int(c))//100))

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

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

B_i = int(B[:-3])
B_f = int(B[-2:])


f = str(A*B_f)
if (len(f) >= 3):
    f_i = int(f[:-2])
else:
    f_i = 0

print(A*B_i + f_i)

Solution (Python):
from decimal import Decimal

if __name__ == "__main__":
    a, b = list(input().split())
    a = Decimal(a)
    b = Decimal(b)

    print(int(a*b))

Solution (Python):
from decimal import Decimal

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

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

Solution (Python):
a, b = input().split()
print(int(a) * int(b[:-3] + b[-2:]) // 100)

Solution (Python):
from decimal import Decimal

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

Solution (Python):
import numpy as np

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

c = b * 100 
 
if (c % 1) >= 0.5:
    c = int(c) + 1

ans = int(a) * int(c) // 100

print(int(ans))

Solution (Python):
from decimal import Decimal

inlist = input().split()
num1 = int(inlist[0])
num2 = Decimal(inlist[1])

print(int(num1*num2))

Solution (Python):
from decimal import *
a,b=[_ for _ in input().split()]
c=Decimal(a)*Decimal(b)
print(c.quantize(Decimal("1"),rounding=ROUND_DOWN))

Solution (Python):
from decimal import *


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

    print(str(a*b).split(".")[0])


if __name__ == "__main__":
    main()

Solution (Python):
A, B = map(str, input().split())
b = int(B[0])*100 + int(B[2:4])

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

Solution (Python):
tmp = [i for i in input().split()]

a = int(tmp[0])
b = int(float(tmp[1]) * 1000)

result = a*b//1000
print(result)

Solution (Python):
import decimal

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

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

res = A * B
res = int(res)

print(res)

Solution (Python):
import sys
import math

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60


def main():
    A, B = readline().split()
    A = int(A)
    B1, B2 = B.split('.')
    B1 = int(B1)
    B2 = int(B2)

    ans = A * B1 + int(A * B2 // 100)
    print(ans)

    return


if __name__ == '__main__':
    main()

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

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

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

a = int(a)
c = b[0] + b[2] + b[3]
c = int(c)

ans = a*c //100

print(ans)

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

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

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

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

ans = int(a*b)

print(ans)

Solution (Python):
import math
a,b=map(lambda x:x,input().split())
a=int(a)
for i in range(len(b)):
    if b[i]==".": b=int(b[:i]+b[i+1:]);break

print(a*b//100)

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

Solution (Python):
from decimal import Decimal, getcontext
getcontext().prec = 20
A, B = input().split()
A = int(A)
num = Decimal(A) * Decimal(B)
print(int(num))

Solution (Python):
a, b = input().split()
a = int(a)
b = int(b[0]+b[2]+b[3])
ans = a*b
print(ans//100)

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




ab = Decimal(a) * Decimal(b)


print(math.floor(ab))

Solution (Python):
s = list(input().split())
a = int(s[0])
b = int(s[1].replace('.',''))*100
ans = str(a*b//100)
n = len(ans)
if n <= 3:
    print(0)
else:
    print(ans[:n-2])

Solution (Python):
from decimal import Decimal

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

print(int(a*b))

Solution (Python):
from decimal import Decimal

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

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

Solution (Python):
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math

MOD = 10 ** 9 + 7


a, b = input().split()
a = int(a)
b = "".join(b.split("."))
b = b + "0"*(3 - len(b))
b = int(b)
ans = a*b
print(ans//100)

Solution (Python):
from decimal import Decimal

A, B = [n for n in input().split()]
print(int(Decimal(A) * Decimal(B)))

Solution (Python):
import numpy as np
import sys
sys.setrecursionlimit(10 ** 9)
from decimal import Decimal
def main():
    a, b = map(Decimal, input().split())
    a = int(a)
    ans = a * b
    print(int(ans))


if __name__ == '__main__':
    main()

Solution (Python):
inpl = lambda: list(map(int,input().split()))
A, B = input().split()
A = int(A)
B1, B2 = list(map(int,B.split('.')))
C = int(100*B1+B2)
print(A*C//100)

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

b = int(b*100+0.1)
c = a*b
c = c//100

print(c)

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

C = ""

for i in range(len(B)):
    if B[i]!=".":
        C+=B[i]
if C[0]=="0" and len(C)>1:
    C = int(C[1:])
else:
    C = int(C)

print((A*C)//100)

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

Solution (Python):
from decimal import Decimal, ROUND_FLOOR

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

Solution (Python):
import math
import decimal

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

print(math.floor(a*b))

Solution (Python):








import decimal
A, B = [decimal.Decimal(i) for i in input().split()]

C =A*B

ans = int(C)
print(ans)

Solution (Python):
import sys
import math
from functools import reduce
from operator import mul
sys.setrecursionlimit(10**6)

def InMap(): return list(map(int, sys.stdin.readline().split(' ')))
def In(): return int(sys.stdin.readline())
def InS(): return sys.stdin.readline()

S = InS()
A = int(S.split(' ')[0])
B = S.split(' ')[1]
B = B[0] + B[2] + B[3]

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

Solution (Python):
from decimal import *
import math

a, b = input().split()

ans = Decimal(a) * Decimal(b)

print(math.floor(ans))

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

Solution (Python):
from decimal import Decimal

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

Solution (Python):
from decimal import *

a, b = input().split()

result = Decimal(a) * Decimal(b)

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

Solution (Python):


A, B = list(input().split())
A = int(A)
B = int(B.replace('.', ''))
res = A * B
res = res // 100
print(res)

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

Solution (Python):
sr=input().split( )
a=int(sr[0])
ans=0
ans+=int(sr[1][0])*100
ans+=int(sr[1][2])*10
ans+=int(sr[1][3])
t=a*ans//100
print(t)

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

Solution (Python):
import sys

stdin = sys.stdin
inf = 1 << 60
mod = 1000000007

sys.setrecursionlimit(10**7)

ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

from decimal import Decimal

a, b = nas()

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

print(int(a * b))

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

Solution (Python):






import sys
input = sys.stdin.readline

import math

import bisect
from collections import defaultdict
from collections import deque
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]


def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()


def DD(arg): return defaultdict(arg)



def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
  arr = []
  temp = n
  for i in range(2, int(-(-n**0.5//1))+1):
    if temp%i==0:
      cnt=0
      while temp%i==0: 
        cnt+=1 
        temp //= i
      arr.append([i, cnt])
  if temp!=1:
    arr.append([temp, 1])
  if arr==[]:
    arr.append([n, 1])
  return arr


def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors


def make_primes(N):
  max = int(math.sqrt(N))
  seachList = [i for i in range(2,N+1)]
  primeNum = []
  while seachList[0] <= max:
    primeNum.append(seachList[0])
    tmp = seachList[0]
    seachList = [i for i in seachList if i % tmp != 0]
  primeNum.extend(seachList)
  return primeNum


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def lcm(a, b):
    return a * b // gcd (a, b)


def count_bit(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count


def base_10_to_n(X, n):
  if X//n:
    return base_10_to_n(X//n, n)+[X%n]
  return [X%n]

def base_n_to_10(X, n):
  return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))


def int_log(n, a):
  count = 0
  while n>=a:
    n //= a
    count += 1
  return count




A,B = SL()
A = int(A)
B = int(B[0]+B[2]+B[3])

print((A*B)//100)

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


s = input().split()
A = Decimal(s[0])
B = Decimal(s[1])
print(int(A*B))

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

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

ad = decimal.Decimal(a)
ab = decimal.Decimal(b)



result = (ab * ad).quantize(decimal.Decimal('0'), rounding=decimal.ROUND_FLOOR)

print(result)

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

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

Solution (Python):


a, b = map(lambda x: int(x.replace(".","")), input().split())

print(a*b//100)

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

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

Solution (Python):
"""
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 = input().split()
a = int(a)
b = int(round(float(b) * 100))
temp = str(a * b)[:-2]
if temp == "":
    temp = "0"
print(temp)

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

a=int(a)

s=""
for i in range(len(b)):
    if(b[i]!="."):
        s+=b[i]

s=int(s)


print(a*s//100)

Solution (Python):
from decimal import Decimal
import math

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

print(math.floor(A * B))

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, floor
from itertools import accumulate, permutations, combinations, product
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 = Decimal(A)
b = Decimal(B)

print(floor(a * b))
exit()

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]





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

if "." in list(b):
    bi,bf=b.split(".")
    
    ans1=a*int(bi)*100
    
    if len(list(bf))>0:
        cnt=1
        for i in list(bf):
            if cnt==1:
                p=a*int(i)*10
                ans1+=p
                cnt+=1
            elif cnt==2:
                p=a*int(i)
                ans1+=p
    print(ans1//100)
else:
    print(a*int(b))

Solution (Python):
def main():
    from decimal import Decimal, ROUND_DOWN
    inStr = input().split()
    A = Decimal(inStr[0])
    B = Decimal(inStr[1])
    ans = (A * B).quantize(Decimal("1"), rounding=ROUND_DOWN)
    print(ans)


main()

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

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

Solution (Python):
import decimal
import math

N = list(map(decimal.Decimal, input().split()))
a, b = N[0], N[1]

print (math.floor(a*b))

Solution (Python):
from decimal import Decimal, getcontext
getcontext().prec = 21

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

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

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

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

print(int(A*B))

Solution (Python):

def q3():
    import math
    from decimal import Decimal
    nums = input().split(" ")
    a = Decimal(nums[0])
    b = Decimal(nums[1])
    print(math.floor(a * b))

q3()

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

def main():

    input = stdin.readline

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

    num_A = Decimal(A)
    num_B = Decimal(B)
    
    ans = int(num_A * num_B)

    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
from decimal import Decimal, ROUND_DOWN

def main():
    A, B = tuple(c for c in input().split(' '))
    A = Decimal(A)
    B = Decimal(B)
    ret = A*B
    print(ret.quantize(Decimal('0'), rounding=ROUND_DOWN))


if __name__ == "__main__":
    main()

Solution (Python):
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy
from decimal import *




def main():
    N,M = input().split()
    getcontext().prec = 20
    getcontext().rounding = ROUND_DOWN
    N = Decimal(N)
    M = Decimal(M)
    res = N*M
    print(res.quantize(Decimal('1.'), rounding=ROUND_DOWN))


if __name__ == '__main__':
    main()

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


def main():
    getcontext().rounding = ROUND_FLOOR
    getcontext().prec = 30
    A, B = map(Decimal, input().split())
    print((A * B).quantize(Decimal('0')))

main()

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

ans=a*b


import math
print(math.floor(ans))

Solution (Python):
from decimal import Decimal

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

Solution (Python):

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

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

Solution (Python):

from decimal import Decimal
def main():
    A, B = input().split()
    A = Decimal(A)
    B = Decimal(B)

    ans = A*B
    ans = int(ans)

    print(ans)



if __name__ == '__main__':
    main()

Solution (Python):
import math
import os
import random
import re
import sys
str=input().split()
a=int(str[0])
b=float(str[1])
b=round(b*100)
ans=a*b
print(ans//100)

Solution (Python):
s = input().split()
a = int(s[0])
x = int(s[1][:-3])
p = int(s[1][-2])
q = int(s[1][-1])
y = a * (100 * x + 10 * p + q)
y = str(y)
if len(y) <= 2:
    print(0)
else :
    print(y[:-2])

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