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):
if __name__ == "__main__":
    a, b = input().split()
    a = int(a)
    b = round(float(b)*100)
    print((a*b)//100)

Solution (Python):
from decimal import Decimal


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


if __name__ == '__main__':
    main()

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

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

Solution (Python):


import sys
import math
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

A, B = readline().decode().rstrip().split()
A = int(A)
B = 100 * int(B[0]) + 10 * int(B[2]) + int(B[3])

ans = A * B // 100

print(ans)

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

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


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



A=int(A)
B=round(B*100)
c=A*B
c=str(c//100)
print(c)

Solution (Python):
import math

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
from decimal import Decimal

sys.setrecursionlimit(10**6)
readline = sys.stdin.readline


def main():
    N1 = list(readline().split())
    N = int(N1[0]); M = Decimal(N1[1])
    ans = int(N*M)
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    A, B = (str(i) for i in input().split())
    a = int(A)
    b = int("".join(b for b in B if b != "."))
    ans = a*b
    print(ans//100)


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
ab = list(input().split())
a = int(ab[0])
b = int(float(ab[1]) * 1000)

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

Solution (Python):

import sys
input = sys.stdin.readline
a, b = input().split()
a = int(a)
b_ = b[0]+b[2]+b[3]
b100 = int(b_)

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

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]=list(map(float,input().split()))
import math
a=int(a)
b=int(b*100)
ans=a*b
ans=ans/100
ans=math.floor(ans)
print(ans)
"""
[a,b]=list(input().split())
a=int(a)
b12=list(b.split('.'))
bkai=int(int(b12[0])*100+int(b12[1]))
ans=a*bkai
ans=ans//100
print(ans)

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

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

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

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

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

a,b = input().split()
a,b = int(a), float(b)
b += 0.00001
b = int(b*100)

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

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

Solution (Python):
from decimal import Decimal

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

Solution (Python):

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

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

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

print(int(ans))

Solution (Python):
a,b=input().split()
bb=""
for i in range(len(b)):
    if b[i]!=".":
        bb+=b[i]
print(int(a)*int(bb)//100)

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

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

print(int(a*b))

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

Solution (Python):

"""
Created on Sun May 31 21:07:49 2020

@author: NEC-PCuser
"""

A, B = map(str, input().split())
A = int(A)
B = float(B) * 1000 // 1

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

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

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

Solution (Python):
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

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

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  a,b=LS()
  a=int(a)
  b=b.replace('.','')
  b=int(b)
  
  ans=a*b
  return ans//100


print(main())

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

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

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

Solution (Python):
from decimal import Decimal as de
a,b=input().split()
print(int(de(a)*de(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)*1000)

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

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

b = b*100
b = round(b)

ans = a*b


print(ans//100)

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

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

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

A = int(A)
B = float(B)
if A==0:
    print('0')
    exit()

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

Solution (Python):

import sys


input = sys.stdin.readline
def IS(cb): return cb(input().strip())
def IL(cb): return [cb(s) for s in input().strip().split()]
def IR(cb, rows): return [IS(cb) for _ in range(rows)]
def ILL(cb, rows): return [IL(cb) for _ in range(rows)]


def solve():
    ss = input().strip().split()
    A = int(ss[0])
    B = float(ss[1])
    print(A * int(B * 1000) // 1000)


solve()

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

Solution (Python):
from decimal import Decimal

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

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

if __name__ == "__main__":
    main()

Solution (Python):
import math


def main():
    a, b = input().split()
    A = int(a)
    
    B = int(b.replace('.', ''))
    print(int(A * B // 100))


if __name__ == '__main__':
    main()

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

Solution (Python):


import collections
import itertools
from functools import lru_cache
import sys
import math
from decimal import Decimal


MOD = int(1e9)+7




def helper():
	pass




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




t = 1
for _ in range(t):
	solve()

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

sys.maxsize = 1_000_000_000_000_000_000_0

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

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

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

if __name__ == '__main__':
    solve()

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

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

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

print( m )

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

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

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

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

print(A * B // 100)

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

x = int(a)
y = round(100*float(b))

print(x * y // 100)

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

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

a = int(A)
b = round(B * 100)

print(a * b // 100)

Solution (Python):
import decimal

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

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

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

a = int(a)
b = int(b.replace(".", ""))

ans = a * b // 100

print(ans)

Solution (Python):



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

    a = int(a)
    b = str(b)
    
    if len(b) == 1:
        b = b[0] + "00"
    elif len(b) == 3:
        b = b[0] + b[2] + "0"
    else:
        b = b[0] + b[2] + b[3]
    
    b = int(b)
    
    
    
    return a*b // 100


print(main())

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 = round(100*float(b))
print(a*b//100)

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

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

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

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

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

Solution (Python):
import math
a,b=input().split()
tmp = float(b)*1000

ans = int(a) * int(math.floor(tmp))


ans = str(ans)
l = len(ans)

if l < 3:
    print(int(0))
else:
    print(int(ans[:l-3]))

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

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())
a=int(a)
bb=""
for i in b:
  if i!=".":
    bb+=i

bb=int(bb)
print((a*bb)//100)

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


def main():
    a = list( map( float, input().split()))
    a1 = int(a[0])
    a2 = Decimal(str(a[1])).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN)
    s = a1*a2
    print(math.floor(s))
    
if __name__ == '__main__':
    main()

Solution (Python):

import sys

def solve(A: int, B: float):
    
    
    
    
    
    

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

    return



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

if __name__ == '__main__':
    main()

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

Solution (Python):
import sys

 
from fractions import Fraction
 
"""
 
"""
 
a, b = map(Fraction, input().split())
print(int(a*b))

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

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

c = b.split(".")


l = int(a)
m = int(c[0])
n = int(c[1])

ans = ( l * ( m*100 + n ) )// 100
print(ans)

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

Solution (Python):
from decimal import *
from math import *

getcontext().prec = 10000
a, b = map(Decimal, input().split())
print(floor(a * b))

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

Solution (Python):
a,b=map(float,input().split())
a=int(a//1)
bigb=int((b*1000)//1)
a_front=a//1000
a_back=a-a_front*1000

 
ans_front=a_front*bigb
ans_back=a_back*b
ans_back=int(ans_back//1)
print(int(ans_front+ans_back))

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

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

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

Solution (Python):
A,B=input().split(' ')
A = int(A)
if '.' in B:
    B_int,B_float = B.split('.')
    if len(B_float) == 1:
        print(A*int(B_int)+(A*int(B_float))//10)
        print(B_int,B_float)
    else:
        print(A*int(B_int)+(A*int(B_float)//100))

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

import math, decimal
print(int(A) * int(B.replace('.', '')) // 100)

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

Solution (Python):

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

print(int(A * B))

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


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

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

Solution (Python):
from math import floor

a, b = input().split()
a = int(a)
b = int(float(b)*100+0.0001)

print(a*b//100)

Solution (Python):
from decimal import Decimal
import math


aaa = list(map(float, input().split()))

'''
aaa = [1000000000000000, 0.09]
A = 1000000000000000
B = 0.09
'''


'''
print(B)
print(A)
1000000000000000 0.09
999999999999999
'''



print(int(Decimal("{}".format(aaa[0])) * Decimal("{}".format(aaa[1]))))

Solution (Python):









import sys,collections,math
sys.setrecursionlimit(100000)
a,b = sys.stdin.readline().split()
a = int(a)
b = float(b)
b = int(b*1000)
print(a*b//1000)

Solution (Python):
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

r = list(map(float,input().split()))

x = Decimal(str(r[0])).quantize(Decimal('0'),rounding=ROUND_HALF_UP)
y = Decimal(str(r[1])).quantize(Decimal('0.01'),rounding=ROUND_HALF_UP)

z = x * y

z = math.floor(z)

print(z)

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

a = int(A)
b = round(B * 100)

print(a * b // 100)

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

Solution (Python):
a = input().split()
s1 = a[0]
s2 = a[1]
num1 = int(s1)
num2 = int(s2[0])*100 + int(s2[2]+s2[3])

print((num1*num2)//100)

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

Solution (Python):
import numpy as np
from decimal import *
input = input().split(" ")
a, b = Decimal(input[0]), Decimal(input[1])
print(np.floor(a*b))

Solution (Python):

 
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
 
a, b = input().split()
a = int(a)
b = int(float(b)*1000)
ans = a * b
print(ans // 1000)

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

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *













































def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007




def main():
	getcontext().prec = 1000
	A,B  = map(Decimal, input().split())

	ans = A * B

	s = str(ans)
	S = s.split(".")
	print(S[0])





def bisect_left_reverse(a, x):
    if a[0] <= x:
        return 0
    if x < a[-1]:
        return len(a)
    
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] <= x:
            ok = mid
        else:
            ng = mid
    return ok

def bisect_right_reverse(a, x):
    if a[0] < x:
        return 0
    if x <= a[-1]:
        return len(a)
    
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] < x:
            ok = mid
        else:
            ng = mid
    return ok





def binary_search(list, item):
    low = 0
    high = len(list) - 1

    while low <= high:
        mid = (low + high) //2
        guess = list[mid]
        if guess == item:
            return mid
        if guess > item:
            high = mid -1
        else:
            low = mid + 1
    return None




def sunuke(N, K, mod=10**9+7):
	if N < K or K-1 < 0:
		return 0
	else:
		return combination(N-1, K-1, mod)




def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y




def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)


class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv



def dfs(graph,parent,counter,edge):
    stk = []
    stk.append(edge)
    while len(stk) > 0:
        p = stk.pop()
        for e in graph[p]:
            if parent[p] == e:
                continue
            else:
                parent[e] = p
                counter[e] += counter[p]
                stk.append(e)



if __name__ == "__main__":
	main()

Solution (Python):

import sys, re
from decimal import *
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, floor, trunc
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

i = Decimal(a)*Decimal(b)

print(int(i))

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

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

Solution (Python):
from decimal import Decimal, ROUND_FLOOR

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

ans = a * b

val_floor_d = ans.quantize(Decimal('0'), rounding=ROUND_FLOOR)

print(val_floor_d)

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

tmpA = int(A)
tmpB = int(float(B)*100.0+0.5)

ans = str(tmpA*tmpB)

ans=ans[:len(ans)-2]

if len(ans)==0:
    ans=0

print(ans)

Solution (Python):
import decimal

a, b = input().split()

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

Solution (Python):
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

a,b=input().split()

b=float(b)*100

b=Decimal(str(b)).quantize(Decimal('0'), rounding=ROUND_HALF_UP)


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

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

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 Decimal
A,B=input().split()
print(int(Decimal(A)*Decimal(B)))

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *





































def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007




def main():
	getcontext().prec = 100
	A,B  = map(Decimal, input().split())

	ans = A * B

	s = str(ans)
	S = s.split(".")
	print(S[0])





def bisect_left_reverse(a, x):
    if a[0] <= x:
        return 0
    if x < a[-1]:
        return len(a)
    
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] <= x:
            ok = mid
        else:
            ng = mid
    return ok

def bisect_right_reverse(a, x):
    if a[0] < x:
        return 0
    if x <= a[-1]:
        return len(a)
    
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] < x:
            ok = mid
        else:
            ng = mid
    return ok





def binary_search(list, item):
    low = 0
    high = len(list) - 1

    while low <= high:
        mid = (low + high) //2
        guess = list[mid]
        if guess == item:
            return mid
        if guess > item:
            high = mid -1
        else:
            low = mid + 1
    return None




def sunuke(N, K, mod=10**9+7):
	if N < K or K-1 < 0:
		return 0
	else:
		return combination(N-1, K-1, mod)




def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y




def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)


class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv



def dfs(graph,parent,counter,edge):
    stk = []
    stk.append(edge)
    while len(stk) > 0:
        p = stk.pop()
        for e in graph[p]:
            if parent[p] == e:
                continue
            else:
                parent[e] = p
                counter[e] += counter[p]
                stk.append(e)



if __name__ == "__main__":
	main()

Solution (Python):
a, b = input().split()
A = int(a)
B = float(b)
B100 = round(100*B)

C=A*B100
print(str(C//100))

Solution (Python):
A,B = [float(i) for i in input().split()]
A = int(A)
B *= 1000
B = int(B)
C = A*B
C = C//1000
print(C)

Solution (Python):


import sys
import math
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

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

ans = int(A) * int(B * 1000000) // 1000000

print(int(ans))

Solution (Python):
from decimal import Decimal

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

print(int(a*b))

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

Solution (Python):
import math

line = input().rstrip()
line = line.split(' ')
A = int(line[0])
B = line[1].split('.')
if len(B) == 1:
    B = int(B[0]) * 100
elif len(B[1]) == 1:
    B = int(B[0]) * 100 + int(B[1]) * 10
else:
    B = int(B[0]) * 100 + int(B[1])

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

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

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

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














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

Solution (Python):
from decimal import Decimal


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


print(int(x*y))

Solution (Python):
from decimal import *

input_line = input()
Line = input_line.split()
print(int(Decimal(Line[0]) * Decimal(Line[1])))

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


b2=int(b*100)


ans=a*b2


ans=int(ans//100)

print(ans)

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

Solution (Python):
from decimal import *

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

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

Solution (Python):
from decimal import Decimal

a,b = (Decimal(str(x)) for x in input().split())

c = a*b

print(int(c))

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

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

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

Solution (Python):

import math
from decimal import *

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

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

Solution (Python):
import math
import decimal
a, b = input().split()
a = decimal.Decimal(a)
b = decimal.Decimal(b)
print(int(math.floor(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

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

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

print(int(a*b))

Solution (Python):
from decimal import *
getcontext().prec = 32

a,b= input().split()
d = Decimal(a)*Decimal(b)
print(Decimal(d).quantize(Decimal('0'), rounding=ROUND_DOWN))

Solution (Python):
import re
N, M = input().split()

N = int(N)
M = M.replace(".","")
M = M + "00"
M = int(M[:3])

print((N*M)//100)

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

Solution (Python):
import sys
from decimal import *


A, B = sys.stdin.readline().rstrip().split()

root2 = Decimal(A) * Decimal(B)
y = Decimal(str(root2)).quantize(Decimal(str(1)), rounding=ROUND_DOWN)
print(y)

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

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

Solution (Python):
a, b = map(str, input().split())
b = b[:-3] + b[-2:]
a = int(a)
b = int(b)
c = str(a*b)
c = '000' + c
c = c[:-2]
print(int(c))

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