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

Solution (Python):
A,B=input().split()
A=int(A)
Bi=int(B[:len(B)-3])
Bf=int(B[len(B)-2:])
res=(100*Bi+Bf)*A//100
print(res)

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]




import math
from decimal import Decimal
'''
A, B = map(str, sys.stdin.readline().split())
A = Decimal(A)
B = Decimal(B)
print(A * B//1)
'''
A, B = map(str, sys.stdin.readline().split())
A = int(A)
B = int(float(B)*100+0.1)
print(A*B//100)

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

print((A*B)//100)

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]




import math
from decimal import Decimal
'''
A, B = map(str, sys.stdin.readline().split())
A = Decimal(A)
B = Decimal(B)
print(A * B//1)
'''
A, B = map(str, sys.stdin.readline().split())
A = int(A)
B = int(float(B)*100+0.5)
print(A*B//100)

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

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


print(a*b//100)

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

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

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

print(ab)

Solution (Python):
from decimal import *

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

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

print(ans)

Solution (Python):
import decimal

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

print(int(A*B))

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

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

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

a=int(a)

bi=int(b[0])*100+int(b[2])*10+int(b[3])

print(a*bi//100)

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

Solution (Python):

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

print(math.floor(a * b))

Solution (Python):
s = input().split()
A = int(s[0])
B100 = int(s[1].replace(".",""))
print(A * B100 // 100)

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

b1, b2 = map(str, b.split("."))
d = len(b2)

ans = int(a) * int(b1 + b2) // 10**d
print(ans)

Solution (Python):
a, b = input().strip().split()
a = int(a)
b100 = int(float(b) * 100. + 0.5)
ans = int(a * b100//100)

print(ans)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd, floor
from itertools import permutations, combinations, product, accumulate, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from decimal import *

def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True

t = input().split()
a, b = int(t[0]), Decimal(t[1])
ans = int(a * b)
print(ans)

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()
a,b=Decimal(a),Decimal(b)
print(int(a*b))

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):
A,B = input().split()
A = int(A)
B = B.replace('.','')
B = int(B)
 
print(A*B//100)

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 *

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

res = a * b

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

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

Solution (Python):
import math
import pprint
import fractions
import collections
import itertools
from decimal import *
A,B=map(str,input().split())
A=int(A)
B=str(B)
num=int(B[0])*100+int(B[2])*10+int(B[3])

print((A*num)//100)

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

if __name__ == '__main__':
    main()

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()
from decimal import Decimal,ROUND_DOWN
A = Decimal(A)
B = Decimal(B)
N = A*B
print(N.quantize(Decimal('1'),rounding=ROUND_DOWN))

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

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

Solution (Python):

import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

A, B = sr().split()
A = int(A)
B = B.replace('.', '')
B = int(B)
answer = A*B // 100
print(answer)

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

Solution (Python):
import decimal

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

r = a*int(b[0])

if a >= 10 and len(b) > 1:
    r += decimal.Decimal(a * int(b[1])/10)

if a >= 100 and len(b) > 2:
    r += decimal.Decimal(a * int(b[2])/100)

print(int(r))

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

    n = int(N)
    m = int(M.replace('.', ''))

    return n * m // 100


def main():
    print(solve())


if __name__ == "__main__":
    main()

Solution (Python):

import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

A, B = sr().split()
A = int(A)
B = int(float(B)*100 + 0.5)
answer = A*B // 100
print(answer)

Solution (Python):
from decimal import Decimal

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

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

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

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

    a = int(a)
    b = b.replace('.', '')
    b100 = int(b[0])*100 + int(b[1])*10 + int(b[2])

    print(a*b100//100)
    return


if __name__ == "__main__" :
    solve()

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

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

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

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

Solution (Python):



from decimal import *
import math

getcontext().prec = 50
A = Decimal(0)
B= Decimal(0)
A,B = list(map(Decimal,input().split()))


print(math.floor(A*B))

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

print(ans)

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

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

print(int(A) * int(float(B) * 100 + 0.5) // 100)

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 = map(str,input().split())
d = int(b[0]+b[2:])
c = int(a)
print(c*d//100)

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

c = int(a)
d = int(float(b) * 1000)

e = c * d

ans = e // 1000
print(ans)

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

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

from decimal import Decimal

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

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

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

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

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

Solution (Python):
from decimal import Decimal

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

c = (a)*(b*100)//100

print(c)

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

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

Solution (Python):
from decimal import Decimal

a,b = map(float,input().split())
b = round(b*100)
c = int(a)*int(b)//100

print(c)

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

Solution (Python):

from decimal import Decimal
A,B=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)*100+0.1)
print(a*b//100)

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

ans = A*B//100
print (ans)

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

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

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

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

Solution (Python):
from decimal import Decimal

a,b = input().split()
b = b.replace(".","")
c = int(a)*int(b)//100

print(c)

Solution (Python):
"""
import decimal
import math
decimal.getcontext().prec = 100
a, b = map(str, input().split())
c = decimal.Decimal(str(int((int(a) * float(b).as_integer_ratio()[1] * float(b).as_integer_ratio()[0]))))
d = decimal.Decimal(str(float(b).as_integer_ratio()[1] ** 2))
print(math.floor(c/d))
"""
import decimal
import math
decimal.getcontext().prec = 100
a, b = map(str, input().split())
a = decimal.Decimal(a)
b = decimal.Decimal(b)
print(math.floor(a*b))

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

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

hoge=str(A  * B)
if int(hoge) >= 100:

    print(int(str(A  * B)[:-2]))
else:
    print(0)

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

Solution (Python):
import sys
import math
a, b = input().split()
a = int(a)
ans = 0

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

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
a, b= input().split()
a = int(a)

if '.' in b[-2:]: 
    b = int(b.replace(".", "")) * 10
else:
    b = int(b.replace(".", ""))
output = a * b // 100

print(output)

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

Solution (Python):



a,b=input().split()


a = int(a)
b = int(float(b)*1000)

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

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

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

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

a = int(a)
b = int(float(b)*100+0.5)

print(a*b//100)

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

Solution (Python):
import math
a,b = map(str,input().split())
a = int(a)
b_ =str()
for i in b:
    if(i != "."):
        b_ = b_ +i

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

Solution (Python):
import math

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

print(math.floor((a*b)//1000))

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

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

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

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

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

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

    A = int(A)
    B = float(B)

    B100 = int(B * 100 + 0.001)

    print(A * B100 // 100)


if __name__ == '__main__':
    main()

Solution (Python):
import sys

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)
    B = int(B.replace('.', ''))
    print(A * B // 100)

    return


if __name__ == '__main__':
    main()

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

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

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

def int1(x): return int(x) - 1
def II(): return int(input())

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

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

def SI(): return input().split()

def printlist(lst, k='\n'): print(k.join(list(map(str, lst))))
INF = float('inf')

from math import ceil, floor, log2
from collections import deque
from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product
from heapq import heapify, heappop, heappush
from decimal import Decimal

def solve():
    a, b = input().split()
    a = int(a)
    b = int(b.replace('.', ''))

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


if __name__ == '__main__':
    solve()

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

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

Solution (Python):
from decimal import Decimal

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


if __name__ == "__main__":
  main()

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

Solution (Python):
import sys
from decimal import Decimal

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


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

    return


if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
A,B=stdin.readline().rstrip().split()
print(int(A)*int(B.replace(".", ""))//100)

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

print(ans//1000)

Solution (Python):
from decimal import *

s,t =input().split()
a = int(s)
b = int(float(t)*1000)
ans = Decimal(0)
for si in s:
    ai = int(si)
    ans = ans * 10 + ai*b
print(ans//1000)

Solution (Python):


import sys
input = sys.stdin.readline

def main():
  a, b = input().strip().split()
  a, b = int(a), round(float(b)*100)
  result = a * b //100
  print(result)

main()

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
a, b= input().split()
a = int(a)
b = int(b.replace(".", ""))

output = a * b // 100

print(output)

Solution (Python):
a,b=input().split()
a=int(a)
b=int(b[0]+b[2:])
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
import re
a=input().split()

ia=int(a[0])

c=re.sub(r'\D','',a[1])


ib=int(c)

b=ia*ib//100

print(b)

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

def int1(x): return int(x) - 1
def II(): return int(input())

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

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

def SI(): return input().split()

def printlist(lst, k='\n'): print(k.join(list(map(str, lst))))
INF = float('inf')

from math import ceil, floor, log2
from collections import deque
from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product
from heapq import heapify, heappop, heappush
from decimal import Decimal

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

    print(int(a * b))


if __name__ == '__main__':
    solve()

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

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


if __name__ == "__main__":
  main()

Solution (Python):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline

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

a = int(a)
b = int(float(b) * 100 + .5)

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

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


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


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

Solution (Python):
import decimal

AB = input().split()
A = int(AB[0])
B = decimal.Decimal(AB[1])

print(int(A * B))

Solution (Python):
A, B = map(float, input().split())
print("{}".format(int(A) * (int(B * 1000)) // 1000))

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

def int1(x): return int(x) - 1
def II(): return int(input())

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

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

def SI(): return input().split()

def printlist(lst, k='\n'): print(k.join(list(map(str, lst))))
INF = float('inf')

from math import ceil, floor, log2
from collections import deque
from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product
from heapq import heapify, heappop, heappush
from decimal import Decimal

def solve():
    a, b = input().split()

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


if __name__ == '__main__':
    solve()

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

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

Solution (Python):
from decimal import Decimal

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

print(int(a * b))

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

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

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

print(A*B//100)

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

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

Solution (Python):
import math
from decimal import Decimal

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

print(math.floor(a*b))

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

print(p * q // 100)

Solution (Python):
from decimal import Decimal
import math


def main():
    a, b = input().split()
    a = int(a)
    b = Decimal(b) 
    ans = math.floor(a * b)
    print(f'{ans}')


if __name__ == '__main__':
    main()

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

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

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

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

ans = A * int(B)

print(ans // 100)

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

Solution (Python):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))
def getArray(intn):
    return [int(input()) for i in range(intn)]
def input():
    return sys.stdin.readline().rstrip()

from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import copy
from itertools import permutations
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right

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

from itertools import permutations
from math import factorial, hypot





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

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

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

B100 = int(B100)

ans = A * B100 // 100

print(ans)

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

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

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

print (int(c))

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(float, input().split())
b = float(b)*1000
b = int(b)
c = int(a)*b//1000

print (int(c))

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()
a = int(a)
b = Decimal(b)
print(int(a*b))

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
from decimal import Decimal
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())


A,B = LS()
print(int(Decimal(A)*Decimal(B)))

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

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

Solution (Python):
A, B = input().split()
A = int(A)
B = B.split('.')
B = int(B[0])*100 + int(B[1])
res = '{:d}'.format(A*B)[:-2]
if res == '':
	print('0')
else:
	print(res)

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

Solution (Python):
import math
A,B = map(str,input().split())
A = int(A)
B = B.split('.')
if not len(B[1])==2:
    B[1].append('0')
B = int(''.join(B))
C = str(A*B)
C = C[:-2]
if C == '':
    C = 0
print(C)

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

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

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

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

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

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

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

a=int(a)

bi=int(b[0])*100+int(b[2])*10+int(b[3])

print(a*bi//100)

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

print (int(c))

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

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

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

ans = (int(a) * int(1000*b))//1000

print(ans)

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

print(a*b//100)

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

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

print (c)

Solution (Python):
a,b=map(str,input().split())
A=int(a)
B=""
for i in range(len(b)):
  if b[i]!=".":
    B+=b[i]
  else:
    pass
B=int(B)
ans=A*B//100
print(ans)

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

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

c = int(a)*int(b * 1000)//1000

print (c)

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)