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

Solution (Python):
from decimal import *
import math

a, b = input().split()

a = int(a)
b = 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):
A, B = map(float, input().split())
a = int(A)
b = round(100*B)
ans = a * b * 100
print(a*b//100)

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

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

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

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

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

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

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

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

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

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

print((a*b)//1000)

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

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

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

print(A*B//100)

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


if __name__ == '__main__':
    main()

Solution (Python):
a,b=input().split()
a=int(a)
b=float(b)
b=round(100*b)
ans=int(int(a*b)//100)
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=map(float, input().split())
a = int(a)

b = round(float(b) * 100)
print(int(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 math
a,b=input().split()
k=b.find('.')
c=b[:k]
d=b[k+1:]
print((int(a)*int(c+d))//100)

Solution (Python):
def main():
    from sys import setrecursionlimit, stdin
    from os import environ
    from collections import defaultdict, deque, Counter
    from math import ceil, floor, gcd
    from itertools import accumulate, combinations, combinations_with_replacement
    setrecursionlimit(10**6)
    dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in environ else lambda *x: 0
    input = lambda: stdin.readline().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    P = 10**9+7
    INF = 10**9+10

    sa,sb = input().split()
    a = int(sa)
    sb = sb.split('.')
    b100 = int(sb[0])*100
    if len(sb) ==2:
        b100 += int(sb[1])
    print(a*b100//100)
    
    
    
    
main()

Solution (Python):


def main():
    a, b = input().split()
    a = int(a)
    b_1, b_2 = b.split('.')
    print(a * (100 * int(b_1) + int(b_2)) // 100)


if __name__ == '__main__':
    main()

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

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

Solution (Python):
l = input().split()
 
a = l[0]
b = l[1]
 
a = int(a)
b = float(b) * 1000
b = int(b)
ks = a * b 
print(int(ks // 1000))

Solution (Python):
import sys
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
A, B = read().split()
 
A = int(A)
B = int(float(B) * 100 + .1)
 
A *= B
print(A // 100)

Solution (Python):
from decimal import Decimal

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

print(ans)

Solution (Python):
from decimal import *
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 = round(b * 100)

print(a * b // 100)

Solution (Python):
s=input().split()
a=int(s[0])
b=int(float(s[1])*1000) 
ans=a*b
print(ans//1000)

Solution (Python):
def main():
    from decimal import Decimal
    A, B = (Decimal(i) for i in input().split())
    print(int(A*B))


if __name__ == '__main__':
    main()

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

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

Solution (Python):
from decimal import Decimal

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

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

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

print(int(a*b))

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

Solution (Python):
def examA():
    A, B = LI()
    ans = A*B
    print(ans)
    return

def examB():
    N = I()
    A = LI()
    for a in A:
        if a==0:
            print(0)
            return
    ans = 1
    for a in A:
        ans *= a
        if ans>10**18:
            print(-1)
            return
    print(ans)
    return

def examC():
    A, B = list(map(float, input().split()))
    
    if int(A)==0:
        print(0)
        return
    if int(B)==0:
        print(0)
        return
    ans = A*(B+_ep)
    print(int(ans-_ep))
    return


def examC2():
    A, B = list(map(dec, input().split()))
    ans = int(dec(A*B))
    print(ans)
    return

def examD():
    def factorization(n):
        arr = defaultdict(int)
        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[i] = cnt
        if temp != 1:
            arr[temp] = 1
        if arr == []:
            arr[n] = 1
        return arr
    C = [0,1,3,6,10,15,21,28,36,45]
    N = I()
    F = factorization(N)
    ans = 0
    
    for f in F.values():
        for i in range(10):
            if C[i]>f:
                ans += i-1
                break
    print(ans)
    return

def examE():
    N = I()
    A = [0]*N
    B = [0]*N
    for i in range(N):
        A[i],B[i] = LI()
    A.sort()
    B.sort()
    if N%2==0:
        L = (A[N//2-1] + A[N//2])/2
        R = (B[N//2-1] + B[N//2])/2
        ans = int((R-L)*2) +1
    else:
        L = A[N//2]
        R = B[N//2]
        ans = (R-L)+1

    print(ans)
    return

def examF():
    inv = pow(2,mod2-2,mod2)
    N, S = LI()
    A = LI()
    dp = [[0]*(S+1)for _ in range(N+1)]
    dp[0][0] = pow(2,N,mod2)
    for i in range(N):
        a = A[i]
        for s in range(S+1):
            dp[i+1][s] += dp[i][s]
            dp[i+1][s] %= mod2
            if (s+a<=S):
                dp[i+1][s+a] += dp[i][s]*inv%mod2
                dp[i + 1][s+a] %= mod2
   
    ans = dp[-1][-1]%mod2
    print(ans)
    return

from decimal import Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 1<<60
_ep = 10**(-16)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examC2()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

Solution (Python):


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

Solution (Python):
from math import floor
from decimal import Decimal

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

c = floor(A * B)
print(c)

Solution (Python):
a,b = input().split()
A = int(a)
B = round(float(b)*100.0+0.1)
exp = A*B//100
print(exp)

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

Solution (Python):

import sys
from decimal import *


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

    
    
    
    
    
    
    
    
    
    
    
    
    
    return



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

if __name__ == '__main__':
    main()

Solution (Python):

[A,B] = list(input().split())

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

B = 100*B1 + 10*B2 + B3
C = A*B
print(C//100)

Solution (Python):
import math
import decimal
if __name__ == "__main__":
    a, b = input().split()

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

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

Solution (Python):
a,b=map(float,input().split())
import math
c=int(a)
d=round(b,2)*1000
d=int(d)


e=c*d//1000


print(e)

Solution (Python):
import decimal

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

print(int(A*B))

Solution (Python):
from decimal import Decimal

a, b = input().split()

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

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

Solution (Python):
A,B=input().split()
A=int(A)
bb=[str (c) for c in B]
flag=1
bb.remove(".")

b="".join(bb)

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

Solution (Python):

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



print(new)

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

S = a * b

ans = S // 100
print(int(ans))

Solution (Python):
As,Bs=input().split()
A=int(As)
B=float(Bs)
B100=int((B+0.001)*100)
print(A*B100//100)

Solution (Python):
import sys

import copy



from decimal import *
import math
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**20
ri = lambda : int(input())
rs = lambda : input().strip()
rl = lambda : list(map(str, input().split()))
a,b = rl()
a = Decimal(a)
b = Decimal(b)
print(int(a*b))

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

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

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

Solution (Python):

A, B = input().split()




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

AB = A*B//1000

print(AB)

Solution (Python):

A, B = [i for i in input().split()]
A = int(A)
B = int(B.replace(".", ""))
print(A*B//100)

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

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

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

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

Solution (Python):


from decimal import Decimal

a, b = input().split()

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

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

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

Solution (Python):
ab_str = input().split()
a = int(ab_str[0])
b_str = ab_str[1].split('.')
b = int(b_str[0] + b_str[1])
print(a * b // 100)

Solution (Python):
import sys,collections as cl,bisect as bs,math
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
	return list(map(int,input().split()))
def m(): 
	return map(float,input().split())
def onem(): 
	return int(input())
def s(x): 
	a = []
	if len(x) == 0:
		return []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa != x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x): 
	return " ".join(map(str,x))
def max2(x): 
	return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
	ll = 0
	rr = r
	while True:
		mid = (ll+rr)//2

	if rr == mid:
		return ll
	if (ここに評価入れる):
		rr = mid
	else:
		ll = mid+1
"""

a,b = m()

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

	


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

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

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

Solution (Python):

from decimal import Decimal
import sys
input = sys.stdin.readline
A,B = (str(x) for x in input().split())
a =Decimal(A)
b =Decimal(B)
ans =int(a *b)
print(ans)

Solution (Python):
from math import floor
A,B = input().split()
B="".join(B.split("."))
A=int(A)
B=int(B)
print(int(A*B//100))

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

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

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

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

Solution (Python):
a,b = input().split()
a = int(a);
b = list(b.split("."))
b = int(b[0])*100+int(b[1])
print(a*b//100)

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

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

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

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

Solution (Python):

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

Solution (Python):
from decimal import Decimal

a,b=input().split()

aa=Decimal(int(a))
bb=Decimal(b)

print(int(aa*bb))

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

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

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

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

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

Solution (Python):
from decimal import Decimal

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

print(int(A * B))

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

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

print(a*b//1000)

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

    A = int(A)
    bb = round(float(B)*100)
    ans = A*bb

    print(ans//100)

if __name__ == '__main__':
    main()

Solution (Python):
import math
c,d = input().split()

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


print(a * b // 100)

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

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

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

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()

def resolve():
    A, B = LS()

    A = int(A)
    B0 = int(B[0])
    B1 = int(B[2])
    B2 = int(B[3])
    ans = (A*B0*100 + A*B1*10 + A*B2) // 100
    print(ans)

if __name__ == '__main__':
    resolve()

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

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

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

Solution (Python):

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

Solution (Python):
from math import floor
import decimal

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

Solution (Python):

A, B = input().split()
A = int(A)
B = int(float(B) * 1000)
res = A * B
res = res // 1000
print(res)

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

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

A = int(A)
B1, B2 = map(int, B.split('.'))
ans = (A * B1) + int(A * B2 // 100)

print(ans)

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

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

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

Solution (Python):
line=input().split(' ')
A=int(line[0])
B=int(float(line[1])*1000)

if len(str(A*B))<4:
	print(0)
else:
	print(str(A*B)[:-3])

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

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

Solution (Python):
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

import math

c = input().split()
a = int(c[0])
b = int(c[1].replace('.',''))

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

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

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

Solution (Python):
x=input().split()
a = int(x[0])

from decimal import Decimal
from fractions import Fraction
import math
b = Decimal(x[1])

print(math.floor(b*a))

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

Solution (Python):
from math import floor
a, b = [i for i in input().split()]
p = int(b[0] + b[2] + b[3])
print(int(a) * p // 100)

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

A = int(A)

B = float(B)*1000000

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

Solution (Python):
from fractions import Fraction
import math

ab=input().split()
a = int(ab[0])
b = Fraction(ab[1])
calc = a*b
print(math.floor(calc))

Solution (Python):
from decimal import Decimal
N = [Decimal(e) for e in input().split()]
ans = Decimal(N[0]) * Decimal(N[1])
print(int(ans))

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















mod = int(1e9+7)

INF = 1<<29
lINF = 1<<35

def readInt():
    return list(map(int,input().split()))

def main():
    a,b = input().split()
    a = int(a)
    b = int(float(b)*1000)
    print(a*b//1000)
    return

if __name__=='__main__':
    main()

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

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

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

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


ans = A*B

print(math.floor(ans))

Solution (Python):
import math
from decimal import Decimal

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

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

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

Solution (Python):
from decimal import *
def ABC_169_C():
    getcontext().prec=28
    A,B= map(float, input().split())
    k=Decimal(str(A))*Decimal(str(B))
    print(int(k))

if __name__ == '__main__':

    ABC_169_C()

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

Solution (Python):
import re;a,b,c=list(map(int,re.split('[ .]',input())));print(a*(b*100+c)//100)

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

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):
import sys
import decimal
input = lambda: sys.stdin.readline().rstrip()


def solve():
    A, B = input().split()
    A = int(A)
    B = decimal.Decimal(B)
    print(int(A * B))


if __name__ == '__main__':
    solve()

Solution (Python):
a, b =input().split()
a = int(a)
b = int(float(b)*1000)
n = str(a*b)
if len(n) < 4:
    print(0)
else:
    print(n[:-3])

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

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

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

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

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()
print(int(A)*round(float(B)*100)//100)

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

print(ans)

Solution (Python):
from decimal import Decimal

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

c = a * b

print(int(c))

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

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

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import math
from decimal import Decimal
n, m = input().split()
x = Decimal(n)
y = Decimal(m)

ans = math.floor(x*y)
print(ans)

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

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

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

Solution (Python):

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

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

Solution (Python):
import math
x=input().split()
a=int(x[0])
b=int(x[1].replace('.',''))
c = int(a * b)
print(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
import decimal

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

    
    

    

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

    print(ans)

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

Solution (Python):
def main():
    A, B = (float(i) for i in input().split())
    a = int(A)
    b = int(B*1000)
    ans = a*b
    print(ans//1000)


if __name__ == '__main__':
    main()

Solution (Python):
A,B=input().split()
A=int(A)
B=int(B[0])*100+int(B[2:4])
C=A*B
if len(str(C))<3:
  print(0)
else:
  print(int(str(C)[0:len(str(C))-2]))

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

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

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

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

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

print( a * b // 1000)

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

num1 = int(split[0])
num2 = int(float(split[1])*1000)
print(int(num1*num2)//1000)

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

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

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

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

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

Solution (Python):
import os

import sys

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

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


a, b = sys.stdin.buffer.readline().decode().rstrip().split()
a = int(a)
b = round(float(b) * 100)
print(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):
inp = input().split()

A = int(inp[0])
_B = float(inp[1])
B = round(_B * 100)

res = int(A*B // 100)

print(str(res))

Solution (Python):
from decimal import Decimal

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

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

print(int(A*B))

Solution (Python):
from decimal import Decimal

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

print(int(a*b))

Solution (Python):

def main():
    import sys
    imput = sys.stdin.readline
    
    
    
    A, B = map(str, input().split())

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

    print(A * (100*C + 10*D + E) // 100)

    
if __name__ == "__main__":
    main()

Solution (Python):
a, b = input().split()
a = int(a)
x = int(b[0]) * 100
y = int(b[2]) * 10
z = int(b[3])
c = x + y + z

    

print((a * c) // 100)

Solution (Python):
import sys
 
if __name__ == '__main__':
    str = input().strip()
    
    a, b = str.split()
 
    aval = int(a)
    bval = int(float(b) * 1000)
    
    print(aval * bval // 1000)

Solution (Python):
import math
from decimal import Decimal
l = input().split()

A = int(l[0])
B = Decimal(l[1])


print('{}'.format(int(A*B)))

Solution (Python):
X = input().split(" ")
A = int(X[0])
B = int( float(X[1])*1000 )

m = A * B
m = m // 1000

print(m)

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(1000 * float(B))
AB = A * B // 1000
print(AB)

Solution (Python):
from decimal import Decimal

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

print(int(A*B))

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

Solution (Python):
import decimal
N = list(map(decimal.Decimal, input().split()))
a = N[0] * N[1]
print(a.quantize(decimal.Decimal('0'), rounding=decimal.ROUND_FLOOR))

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


b = round(b*100)

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

print(int(ans))

Solution (Python):
from decimal import Decimal
import decimal

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


sum=a*b
val_pi_d = decimal.Decimal(sum)


val_floor_d = val_pi_d.quantize(decimal.Decimal('0.001'), rounding=decimal.ROUND_FLOOR)
print(int(val_floor_d))

Solution (Python):

import sys


def solve(A: int, B: float):
    B *= 1000
    C = int(B)
    print(A * C // 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):
import decimal
import math
A,B=list(map(decimal.Decimal,input().split()))
C=decimal.Decimal(A*B)
print(math.floor(C))

Solution (Python):
import sys
import math
from collections import deque
from collections import defaultdict

def main():
    a,b = list(map(float,sys.stdin.readline().split()))
    a = int(a)
    b100 = round(b * 100)
    
    ans = (a * b100) // 100
    print(str(ans))

if __name__ == "__main__":
    main()

Solution (Python):

from decimal import *


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

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

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