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

Solution (Python):
import math
from decimal import Decimal

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

print(math.floor(A*B))

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

Solution (Python):
a,b=input().split()
a=int(a)
l=len(b)
B=0
c=1
for i in b:
	if i!='.':
		B+=int(i)*10**(l-c)
		c+=1
print(a*B//10**(l-1))

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

A,B = input().split()

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

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

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

Solution (Python):
def cc():
    a, b = map(str, input().split())
    a2 = int(a)
    b2 = int(b.replace('.', ''))
    c = a2 * b2
    ans = str(c)[0:-2] if len(str(c)) > 2 else 0
    print(ans)
if __name__ == "__main__":
    cc()

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

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

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

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

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

Solution (Python):
from decimal import Decimal
import math
 
A = list(input().split())
 
for i in range(2):
    if i == 0:
        A[i] = int(A[i])
    elif i == 1:
        A[i] = Decimal(A[i])
 
ans = A[0] * A[1]
 
print(math.floor(ans))

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

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

print(floor(a*b))

Solution (Python):
import math
from decimal import Decimal

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

Solution (Python):
from decimal import *

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





if __name__ == "__main__":
    main()

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

Solution (Python):

import math
from decimal import Decimal
def f(x):
    return Decimal(x)
def main():
    a, b = map(f, input().split())
    c = a * b
    print(math.floor(c))
if __name__ == '__main__':
    main()

Solution (Python):
from decimal import Decimal
import math
A,B = [Decimal("{}".format(i)) for i in input().split()]
print(math.floor(int(A)*B))

Solution (Python):
import math
X = input().split()
A = int(X[0])
B_i, B_s = X[1].split(".")
B = int(B_i) * 100 + int(B_s)

print( (A *B) // 100)

Solution (Python):
from decimal import Decimal
import math

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

ans = math.floor(c*d)

print(ans)

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

n = 1
if '.' in b:
    if b[-2] == '.':
        n = 10
    elif b[-3] == '.':
        n = 100
    b = b.replace('.', '')
b = int(b)
print(math.floor(a*b//n))

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


print(math.floor(a*b))

Solution (Python):
import math

def main():
    a, b = map(str, input().split())
    a = int(a)
    b = list(b)
    del b[1]
    bb = ""
    for i in b:
        bb += i
    b = int(bb)
    ans = str(a * b)
    if len(ans) <= 2:
        print(0)
        exit()
    ans = ans[: -2]
    ans = int(ans)
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
from fractions import Fraction

A,B = input().split()



from decimal import *

a = Decimal(A)
b = Decimal(B)
getcontext().prec = 28
ans = a * b
print(int(ans))

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")


def solve():
    a, b = LS()
    a = int(a)
    b = float(b)
    b *= 1000
    b = int(b)
    print(a * b // 1000)
    return



if __name__ == '__main__':
    solve()

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

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

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

Solution (Python):

import math
from decimal import Decimal

def f(x):
    return Decimal(x)


def main():
    a, b = map(f, input().split())
    
    c = a * b
    
    print(math.floor(c))


if __name__ == '__main__':
    main()

Solution (Python):
from decimal import *

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

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

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

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

b_str = nums[1]

b100sub = int(b_str[-1]) + 10*int(b_str[-2]) + 100*int(b_str[-4])

ans_str = str(a*b100sub)
ans = ans_str[0:-2]
if ans == '':
    ans = '0'

print(int(ans))

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

Solution (Python):
import math
a,b = list(map(str,input().split()))
a = int(a)
b = int(''.join(b.split('.')))
ans = (a*b)//100
print(int(ans))

Solution (Python):
A, B = input().split()
A = int(A)
b,c = map(int, B.split('.'))
ab = A * b
ac = A * c

print(ab + ac // 100)

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

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 = 30
	A,B  = map(Decimal, input().split())

	ans = A * B

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

def factorize(n):
    fct = []  
    b, e = 2, 0  
    while b * b <= n:
        while n % b == 0:
            n = n // b
            e = e + 1
        if e > 0:
            fct.append((b, e))
        b, e = b + 1, 0
    if n > 1:
        fct.append((n, 1))
    return fct





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 math


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


b_1 = int(B[0])
b_2 = int(B[2])
b_3 = int(B[3])
tmp_1 = A * b_1 * 100
tmp_2 = A * b_2 * 10
tmp_3 = A * b_3
ans = math.floor((tmp_1 + tmp_2 + tmp_3) // 100)


print(ans)

Solution (Python):
a,b=input().split()
a=int(a)
seisu=int(b[0])
syosu=int(b[2:4])

print(a*seisu+(a*syosu)//100)

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

a = Decimal(a)

b = Decimal(b)

ans = b*a

print(int(ans))

Solution (Python):
import decimal

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

A = str(A)
B = str(B)
ans = decimal.Decimal(A) * decimal.Decimal(B)
print(int(ans))

Solution (Python):

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

print(math.floor(a*b))

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

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

Solution (Python):
def main():
    A,B=map(str, input().split(" "))
    A = int(A)
    B = int(B.split(".")[0] + B.split(".")[1])
    mul_AB = A * B
    if mul_AB < 100:
        print(0)
    else:
        print(str(mul_AB)[:-2])

    
if __name__ == "__main__":
    main()

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

Solution (Python):
a,b=map(str,input().split())
a=int(a)
B=0
if b[0]=='0':
    pass
else:
    B+=int(b[0])*100

if b[2]=='0':
    pass
else:
    B+=int(b[2])*10

if b[3]=='0':
    pass
else:
    B+=int(b[3])

print((a*B)//100)

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

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

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





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

print(int(ans))

Solution (Python):
from math import floor
from decimal import Decimal
a,b = [e for e in input().split(" ")]
a = int(a)
b = Decimal(b)
r = a*b
print(floor(r))

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

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

Solution (Python):
import math
from decimal import Decimal

input_a = input().split()
a = Decimal(input_a[0])
b = Decimal(input_a[1])
ans = a*b



print(int(ans))

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

Solution (Python):
import math
from decimal import Decimal

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

if __name__ == "__main__":
  main()

Solution (Python):
import decimal

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

res = a*int(split_b[0])
f = decimal.Decimal(a) * (decimal.Decimal(split_b[1]) * decimal.Decimal('.01'))

print(res + int(f))

Solution (Python):
from decimal import *
A,B = map(str,input().split())
num = str(Decimal(A)*Decimal(B))
ans = ''
 
for i in range(len(num)):
  if num[i] == '.':
    break
  ans += num[i]
print(int(ans))

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

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

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




X = Decimal(A*B)

X = int(X)



print(X)

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

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 = 20
	A,B  = map(Decimal, input().split())

	ans = A * B

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

def factorize(n):
    fct = []  
    b, e = 2, 0  
    while b * b <= n:
        while n % b == 0:
            n = n // b
            e = e + 1
        if e > 0:
            fct.append((b, e))
        b, e = b + 1, 0
    if n > 1:
        fct.append((n, 1))
    return fct





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().strip().split()
a = int(a)

b=b.split(".")
b1=int(b[0])*100 + int(b[1])
print(a*b1//100)

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

Solution (Python):
import math
a,b = map(str, input().split())
a = int(a)
b = b.replace(".","")
if len(b) == 2:
    b = b + '0'
b = int(b)
ans = a*b
if len(str(ans)) <= 2:
    print(math.floor(ans/100))
else:
    print(int(str(ans)[:-2]))

Solution (Python):
import math

A, B = list(input().split())
A = int(A)

B = B.replace('.', '').ljust(3, '0')
B = int(B)

AB = A * B
AB = str(AB)
AB = AB[0:-2]
AB = 0 if AB == '' else AB
print(AB)

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

if __name__ == "__main__":
    main()

Solution (Python):
import math,decimal
arr = list(input().split())

A=int(arr[0])
B=decimal.Decimal(arr[1])
C=A * B
D=math.floor(C)

print(D)

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

A = int(A)
ans = str(A*int(B[0])*10**2+A*int(B[2])*10**1+A*int(B[3]))
if len(ans) <=2:
    print(0)
else:
    print(ans[:-2])

Solution (Python):
import math
from decimal import Decimal

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

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

print(math.floor(ans))

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

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

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

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

Solution (Python):
import math

A, B = list(input().split())
A = int(A)




B = B.replace('.', '').ljust(3, '0')
B = int(B)





AB = A * B
AB = str(AB)
AB = AB[0:-2]
AB = 0 if AB == '' else AB
print(AB)

Solution (Python):
from decimal import Decimal, ROUND_FLOOR

A, B = input().split()
A = int(A)
B = Decimal(B)
ans = Decimal(str(A*B)).quantize(Decimal('0'), rounding=ROUND_FLOOR)

print(ans)

Solution (Python):
from decimal import Decimal, ROUND_DOWN
a,b = input().split()
a = int(a)
b = Decimal(b)
x = Decimal(a*b)
d = Decimal(str(x))
y = d.quantize(Decimal(str(0)), rounding=ROUND_DOWN)
print(y)

Solution (Python):
import sys
import math

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

def main():
    b = B.replace(".", "")
    result = int(A) * int(b)
    return result // 100

ans = main()
print(int(ans))

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

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

sys.setrecursionlimit(10 ** 7)

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

A, B = input().split()

if A == "0":
    print(0)
    exit()

getcontext().prec = 10 ** 10

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

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

Solution (Python):
from decimal import Decimal,ROUND_FLOOR

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

ans = A*B

if ans < 1:
    print(0)
else:
    print(ans.quantize(Decimal("0"), rounding=ROUND_FLOOR))

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

Solution (Python):
A,B=map(str,input().split())
A=int(A)
B=list(B)
if len(B)<=2:
    B.append('0')
    B.append('0')
elif B[-3]=='.':
        B.remove('.')
elif B[-2]=='.' :
    B.remove('.')
    B.append('0')
else:
    B.append('0')
    B.append('0')
n=len(B)
b=sum(10**(n-1-j)*int(B[j]) for j in range(n))
ans=list(str(A*b))
if len(ans)<=2:
    ans='0'
else:
    ans.pop(len(ans)-1)
    ans.pop(len(ans)-1)
n2=len(ans)
trueans=sum(10**(n2-1-j)*int(ans[j]) for j in range(n2))
print(trueans)

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)
    s = b[0]
    t = b[2:4]
    b = int(s+t)
    print(a*b//100)
    return

if __name__=='__main__':
    main()

Solution (Python):
from decimal import Decimal, ROUND_DOWN

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

print(Decimal(c).quantize(1, rounding=ROUND_DOWN))

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

ans = a * b

print(math.floor(ans))

Solution (Python):

import sys
import math

from decimal import *

def solve(A: int, B: float):
    a = Decimal(A)
    b = Decimal(B)
    
    
    if len(str(B)) == 3:
        if str(B)[2] == 0:
            print(math.floor(a*b))
            return
        ans = A * int(str(B)[0])
        ans += Decimal(a * int(str(B)[2]) / 10)
        print(math.floor(ans))
        return

    if len(str(B)) == 4:
        ans = A * int(str(B)[0])
        ans += Decimal(A * int(str(B)[2]) / 10)
        ans += Decimal(A * int(str(B)[3]) / 100)
        print(math.floor(ans))
        return
    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
from decimal import Decimal, ROUND_FLOOR

A, B = input().split()

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

C = A * B

D = C.quantize(Decimal("0"), rounding = ROUND_FLOOR)

print(D)

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

b_=int(b.replace('.',''))
if len(str((a_*b_)))<3:
    print(0)
    exit()
seisu=str((a_*b_))[0:len(str(a_*b_))-2]
print(seisu)

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

Solution (Python):
import math

def main():
  A, B = list(map(str, input().split()))
  A = int(A)
  d, f = B.split('.')
  d = int(d)

  ans = 0

  ans += A * d

  fl = A * int(f)

  print(ans + (fl // 100))



if __name__ == "__main__":
  main()

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

if __name__ == "__main__":
    c()

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

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

print(int(A*B))

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

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

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

ans = Decimal(a * b)

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

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

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

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

Solution (Python):
from decimal import Decimal

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

Solution (Python):
A = input().split()
a = int(A[0])
b = str(A[1])

B = b[0] + b[2] + b[3]
B = int(B)
ans = str(a*B)
if len(ans) > 2:
  print(ans[:-2])
else:
  print(0)

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

print(int(Decimal(s[0]) * Decimal(s[1])))

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

Solution (Python):
from decimal import Decimal


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

c = a*b

print(int(c))

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

b = format(round(b, 2))
ans = Decimal(a) * Decimal(b)

print(int(ans))

Solution (Python):
import numpy as np
a,b=(np.float128(x) for x in input().split())

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

Solution (Python):
from decimal import Decimal

A,B = input().split()

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

c=a*b

print(int(c))

Solution (Python):
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from math import floor
i = input().split()
A = int(i[0])
B = Decimal(i[1])

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

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

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

Solution (Python):
import math
from decimal import Decimal

li = input().split()
x = Decimal(li[0]) * Decimal(li[1])

print(math.floor(x))

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
from collections import deque,defaultdict
import heapq
from itertools import combinations
import bisect
from decimal import Decimal


a,b=map(str,input().split())
b=Decimal(b)
a=int(a)
p=list(str(a*b))
ans=''
for i in p:
    if i=='.':
        break
    ans+=i
print(ans)

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

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

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

Solution (Python):
from decimal import Decimal, ROUND_FLOOR

A, B = input().split()
A = Decimal(A)
B = Decimal(B)
res = A * B
print(res.quantize(Decimal("1"), rounding=ROUND_FLOOR))

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

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
a, b = input().split()
a = int(a)
b = int(b.replace('.', ''))
ab = str(a*b)
print(int(('00' +str(a*b))[:-2]))

Solution (Python):
from decimal import Decimal

a,b = input().split()

res = Decimal(a) * Decimal(b) 

print(int(res))

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

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(b*1000)

	


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

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

a = input()
b = int(re.sub('\s.+$','',a))
c = Decimal(re.sub('^.+\s','',a))
d = Decimal(b * c)
d = math.floor(d)
d = int(d)

print(d)

Solution (Python):
import math
from decimal import *
getcontext().prec = 28
a,b=map(str, input().split())
a_ = Decimal(a)
b_ = Decimal(b)


print(math.floor(a_*b_))

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

Solution (Python):
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

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


def main():
	A, B = list(input().split())
	A = int(A)
	Bint = int(B[0] + B[2] + B[3])
	
	print(int(A * Bint // 100))


if __name__ == '__main__':
	main()

Solution (Python):
a, b = [s for s in input().split(" ")]
a = int(a)
b = int(b.replace(".", ""))
h = b // 100
t = (b - h * 100) // 10
o = (b - h * 100 - t * 10)
ah = a * h
at = a * t
ao = a * o

print((ah * 100 + at * 10 + ao) // 100)

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

x = int(a)
y = int(b[0]) * 100 + int(b[2]) * 10 + int(b[3])

ans = x * y // 100
print(ans)

Solution (Python):
import math
from decimal import *
getcontext().prec = 28
a,b=map(str, input().split())
a_ = Decimal(a)
b_ = Decimal(b)


print(math.floor(a_*b_))