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
from math import floor

[a, b] = list(map(Decimal, input().split()))

print(floor(a * b))

Solution (Python):
import math
from decimal import *

a,b = input().split()

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

print(math.floor(a * b))

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

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=int(B.replace('.',''))

C=str(A*B)

if len(C)<=2:
    result=0
else:
    result=int(C[:len(C)-2])

print(result)

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

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

A = int(A)
B_i = int(B[0])
B_f = int(B[2:])

ans1 = A*B_i
ans2 = (A*B_f)//100

ans = ans1 + ans2

print(ans)

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

Solution (Python):
import math
from decimal import Decimal

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

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

Solution (Python):
from decimal import *

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

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

Solution (Python):
import sys
input=lambda: sys.stdin.readline().rstrip()
a,b=map(str,input().split())
a=int(a)
bb=""
for bs in b:
  if bs!=".":
    bb+=bs
bb=int(bb)
print((a*bb)//100)

Solution (Python):

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

ans = (a*b)//100

print(ans)

Solution (Python):
from decimal import Decimal
def main():
  A, B = map(float, input().split())
  A = Decimal(str(A))
  B = Decimal(str(B))
  ans = A*B
  print(int(ans))
if __name__ == "__main__":
  main()

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

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

Solution (Python):
import math

A, B = map(lambda x: x, input().split(" "))

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

result = A*B

result = result // 100

print(result)

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

Solution (Python):

import collections
import itertools as it
import math

 


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





print(a * b // 100)

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

Solution (Python):


n = input().split()

a = int(n[0])
b = int(n[1].replace('.',''))


print(a*b//100)

Solution (Python):
import math
from decimal import Decimal


def task(a, b):
    b = b.replace('.', '')
    if b[0] == '0':
        b = b[1:]
    if b[0] == '0':
        b = b[1:]
    b = int(b)
    res = a * b

    if res < 100:
        print(0)
    else:
        print(str(res)[:-2])


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

Solution (Python):
AB = list(input().split())
A = int(AB[0])
B = int(AB[1][0]+AB[1][2]+AB[1][3])
ans = str(A*B)
print(ans[:-2] if ans[:-2] else 0)

Solution (Python):
from decimal import *

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


print(a*b // 1)

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

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

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

Solution (Python):
from decimal import Decimal

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

    ans = a * b

    print (int(ans))
if __name__ == "__main__":
    main()

Solution (Python):
import math

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

Solution (Python):
from decimal import *

A, B = input().split()

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

Solution (Python):
from decimal import *

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

if __name__=='__main__':
    main()

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd, cos, radians, floor
from functools import lru_cache, reduce
from decimal import Decimal
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


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

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



x = input().split()

a = x[0]
b = x[1]
ans = Decimal(a) * Decimal(b)
ans2 = floor(ans)
print(ans2)

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

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

from decimal import Decimal

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

print(int(a*b))

Solution (Python):
import decimal

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

ans = A * B

print(ans.quantize(decimal.Decimal('1'), rounding=decimal.ROUND_DOWN))

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

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

Solution (Python):

a,b = input().split()

from decimal import Decimal
import math

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

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

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

Solution (Python):
A, B = [x for x in input().split()]
A = int(A)
tmp = ""
for x in B:
	if x != '.':
		tmp += x
B = int(tmp)
res = A * B
res //= 100
print(res)

Solution (Python):
from decimal import *

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

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
import bisect



a,b=input().split()
a=int(a)
b=list(b.split("."))
b=''.join(b)
b=int(b)

print(a*b//100)

Solution (Python):



import sys
sys.setrecursionlimit(10**7)
from pprint import pprint as pp
from pprint import pformat as pf



import math

import bisect


if __name__ == '__main__':
    a, b = list(input().split())
    a = int(a)
    b = int(b.replace('.', ''))
    ans = a * b
    if ans < 100:
        print(0)
    else:
        print(str(ans)[:-2])

Solution (Python):
from math import floor

A,B = input().split()
A = int(A)
B = int(B[0]+B[2]+B[3])

print(A*B//100)

Solution (Python):
As,Bs=input().split()
A=int(As)
Bi,Bf=map(int,Bs.split("."))

print(A*Bi+A*Bf//100)

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

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

if B[0] == "0":
    B = B[1:]

if B[0] == "0":
    B = B[1:]

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

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()
ans = 0
a = int(a)
b = list(b.replace('.', ''))
ans += a * int(b[0]) * 100
ans += a * int(b[1]) * 10
ans += a * int(b[2])
print(ans // 100)

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

if A.count("."):
    A_int, A_float = A.split('.')
    if len(A_float) == 1:
        A_float += '0'
    A = 100 * int(A_int) + int(A_float)
else:
    A = int(A) * 100

if B.count("."):
    B_int, B_float = B.split('.')
    if len(B_float) == 1:
        B_float += '0'
    B = 100 * int(B_int) + int(B_float)
else:
    B = int(B) * 100

result = (A * B) // 10**4

print(result)

Solution (Python):


from decimal import Decimal
from sys import stdin
input = lambda: stdin.readline().rstrip()

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

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

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

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

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

Solution (Python):
a, b = input().split()
b1, b2 = b.split('.')
a = int(a)
b1 = int(b1)
b2 = int(b2)
c = int(('{:0=3}'.format(a * b2))[:-2])
print(a * b1 +c)

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

b100=B[0]+B[2]+B[3]

ans=int(A)*int(b100)
if ans < 100:
    print("0")
else:
    ans_str="{0:d}".format(ans)
    print(ans_str[:-2])

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

Solution (Python):
from decimal import Decimal
from math import floor
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

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

    print(floor(A * B))


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    astr, bstr = [e for e in input().split()]

    b = int(bstr.replace('.', ''))
    ans = int(astr) * b // 100
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
L = list(input().split(" "))
A = int(L[0])
B = L[1]
B1 = int(B[0])
B2 = int(B[2])
B3 = int(B[3])
B = B1*100+B2*10+B3
C = A*B
print(C//100)

Solution (Python):

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

from decimal import Decimal
a = Decimal(a)
b = Decimal(b)
print(int(a*b))

Solution (Python):
a,b=input().split()
b1=""
a=int(a)
for i in b :
    if i!=".":
        b1+=i 
b1=int(b1)
x=a*b1
x//=100
print(int(x))

Solution (Python):
from fractions import Fraction
n,k=map(str,input().split())
a=int(n)
b=int(k[len(k)-2:])
c=int(k[:len(k)-3])
ans=a*c
t=Fraction(a*b,100)
ans+=int(t)
print(ans)

Solution (Python):
from decimal import Decimal

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
from decimal import Decimal
def S(): return sys.stdin.readline().rstrip()
def M(): return map(Decimal,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b = M()
ab = a*b
print(math.floor(ab))

Solution (Python):
import sys
import math
import decimal

def input():
    return sys.stdin.readline()[:-1]

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

print(math.floor(A*B))

Solution (Python):
import math
from decimal import *

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

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


print(ans)

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

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

Solution (Python):
import math
from decimal import *

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

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

main()

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

Solution (Python):
from decimal import *

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

print(int(a*b))

Solution (Python):
from decimal import Decimal

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

Solution (Python):

a,b = input().split()

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

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

Solution (Python):
from decimal import *

N, M = input().split()
N = int(N)
M = Decimal(M)

M = (N*M*100)//100
print(M)

Solution (Python):
from decimal import Decimal

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

Solution (Python):

from decimal import *


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








A = Decimal(A)
B = Decimal(B)
C = A*B


print(int(C))
'''
b = int(B[0])
c = int(B[2])
d = int(B[3])

print(b, c, d)
'''

Solution (Python):
from decimal import *

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

Solution (Python):
tmp=input().split()
a=int(tmp[0])
b_bef=tmp[1][0:-3]
b_aft=tmp[1][-2:len(tmp[1])]
b_100=int(b_bef+b_aft)
ans=(a*b_100)//100
print(ans)

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

getcontext().prec = 100
A, B = input().split()
a = int(A)
b = Decimal(B)
print(math.floor(a*b))

Solution (Python):
from decimal import Decimal
import math


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

res=math.floor(a*b)

print(res)

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

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

Solution (Python):
def resolve():
    '''
    code here
    '''
    A, B = [item for item in input().split()]

    B100 = int(B[:-3]+B[-2:])

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


if __name__ == "__main__":
    resolve()

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

def main():
    a,b=SI().split()
    a=int(a)
    b1,b0=map(int,b.split("."))
    print(a*(b1*100+b0)//100)

main()

Solution (Python):
import sys
A, B = sys.stdin.readline().rstrip().split()
import math
A = int(A)
B = B.split(".")
B_y = int(B[0] + B[1])
ans = str(A * B_y)

if len(ans) > len(B[1]):
    print(ans[:-len(B[1])])
else:
    print(0)

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

Solution (Python):

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

ans = A*B
ans = ans // 100
ans = math.floor(ans)

print(ans)

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

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

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

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

Solution (Python):
from decimal import Decimal

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

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

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

b = int(b_str)

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

Solution (Python):
from decimal import Decimal

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

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

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

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

if __name__=='__main__':
    main()

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

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

from decimal import Decimal
num = Decimal(B)

print(int(int(A)*num))

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

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

b = "".join([b[0], b[2], b[3]])

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

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

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

from decimal import *

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

Solution (Python):
from decimal import Decimal

A, B = input().split()

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

print(int(a*b))

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

Solution (Python):
from decimal import Decimal

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


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

Solution (Python):
a, b = input().split()
a = int(a)
a1 = a % 10
a2 = a % 100
b0 = int(b[0])
b1 = int(b[2])
b2 = int(b[3])

c1 = a * b0
c2 = a // 10 * b1
c3 = a1 * b1 * 0.1
c4 = a // 100 * b2
c5 = a2 * b2 * 0.01
c6 = int(c3 + c5)
print(c1 + c2 + c4 + c6)

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

Solution (Python):
def resolve():
    import sys
    input = sys.stdin.readline
    from decimal import Decimal
    
    
    

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

    print(int(a*b))


resolve()

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

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

Solution (Python):


import sys



























import decimal


def main():
    mod = 1000000007                
    inf = float('inf')              
    
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    decimal.getcontext().prec = 128
    a, b = input().split()
    print(int(decimal.Decimal(a) * decimal.Decimal(b)))


if __name__ == "__main__":
    main()

Solution (Python):
from sys import stdin
from decimal import Decimal
def main():
    
    readline=stdin.readline
    li=readline().strip().split()
    a=Decimal(str(li[0]))
    b=Decimal(str(li[1]))
    ans=int(a*b)
    print(ans)

if __name__=="__main__":
    main()

Solution (Python):
from decimal import Decimal

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


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

Solution (Python):
from decimal import Decimal
N,K=map(Decimal,input().split())
print(int((N*K)//1))

Solution (Python):
import decimal

decimal.getcontext().prec = 100

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

print(int(a * b))

Solution (Python):
def main():
    a, b = list(map(float, input().split()))
    round = lambda x: int((x * 2 + 1) // 2)
    a = round(a)
    b = round(100 * b)
    ans = str(a * b)
    if len(ans) >= 3:
        print(ans[:-2])
    else:
        print(0)

if __name__ == '__main__':
    main()

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

print(str(int(a*b)))

Solution (Python):
a, b = map(str, input().split())
a = int(a)
b1 = int(b[0])
b2 = int(b[2])
b3 = int(b[3])

print(int(a*b1*100+a*b2*10+a*b3)//100)

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

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

Solution (Python):
import math

a, b = input().split()

from decimal import Decimal

f1 = Decimal(a)
f2 = Decimal(b)

print(math.floor(f1 * f2))

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

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
import numpy as np
from heapq import heapify, heappop, heappush
import copy
from math import gcd, ceil
from collections import deque

from bisect import bisect_left, bisect_right
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):
A,B = input().split()
A = int(A)
B = int(B[:1]) * 100 + int(B[-2:])
print (A*B//100)

Solution (Python):
from decimal import Decimal

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

Solution (Python):
def resolve():
    import math
    from decimal import Decimal

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

resolve()

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

Solution (Python):
from decimal import Decimal

n,m=(input().split())

print(int(Decimal(str(m))*Decimal(str(n))))

Solution (Python):


from decimal import *

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

print(int(a*b))

Solution (Python):
from fractions import Fraction

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

Solution (Python):
a,b=map(str,input().split())
a=int(a)
c=''
for i in b:
  if i=='.':
    continue
  else:
    c+=i
c=int(c)
print(int(a*c//100))

Solution (Python):
from decimal import *

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

ans = Decimal(str(A)) * Decimal(str(B))
ans = str(ans)
i = ans.find('.')
ans = ans[:i]


print(ans)

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

if(len(res) <= 2): print(0)
else: print(res[:-2])

Solution (Python):
from decimal import Decimal

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

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

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

print(a * b // 100)

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

print(ab)

Solution (Python):
import math

a, b = map(str, input().split())
A = int(a)
bb = b.replace(".","")
B = int(bb)

def Main(A, B):
    return A*B//100
                    
out = Main(A, B)
print(out)

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

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

ai = int(a)


bi = int(b.replace('.', ''))

strans = str(ai*bi)
if len(strans) < 3:
    print(0)
else:
    print(strans[:-2])

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

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

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

Solution (Python):
from decimal import Decimal

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

print(int(a*b))

Solution (Python):

def s0():return input()
def s1():return input().split()
def s2(n):return [input() for x in range(n)]
def s3(n):return [input().split() for _ in range(n)]
def s4(n):return [[x for x in s] for s in s2(n)]
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
def t3(n):return [tuple(int(x) for x in input().split()) for _ in range(n)]
def p0(b,yes="Yes",no="No"): print(yes if b else no)








a,b=s1()

x=int(a)
y=int(b[0]+b[2:])

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

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

Solution (Python):

"""AtCoder Beginner Contest 169: C - Multiplication 3
https://atcoder.jp/contests/abc169/tasks/abc169_c
"""

__author__ = 'bugttle <bugttle@gmail.com>'

from decimal import Decimal

def main():
    inputs = input().split()
    A, B = int(inputs[0]), Decimal(inputs[1])

    print(int(A * B))

if __name__ == '__main__':
    main()

Solution (Python):

from decimal import Decimal


def solve(*args: str) -> str:
    a, b = args[0].split()
    a = int(a)
    b = Decimal(b)

    return str(int(a*b))


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Solution (Python):
from decimal import Decimal

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

print(main())

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

Solution (Python):
s = input().split()
a = int(s[0])
b = int(s[1][0]) * 100
if s[1][1] == '.':
    b += int(s[1][2]) * 10
    if len(s[1]) == 4:
        b += int(s[1][3])
c = str(a*b)
if len(c) < 3:
    print(0)
else:
    print(c[:-2])

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

Solution (Python):
import math
from decimal import Decimal


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




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

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

a,b = int(a),str(b)
b = int(b[0] + b[2:])

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

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

a = int(split_str[0])
b_lis = split_str[1].split('.')

b1 = int(b_lis[0])
b2 = int(b_lis[1])

print(a * (b1 * 100 + b2) // 100)

Solution (Python):
import math
A, B = input().split()
Afrac = A[-2:].zfill(2)
Aint = A[:-2].zfill(1)
Bfrac = B[-2:].zfill(2)
Bint = B[:-3].zfill(1)

ans = int(A) * int(Bint) + int(Aint) * int(Bfrac) + math.floor(int(Afrac) * int(Bfrac) / 100)
print(ans)

Solution (Python):
from decimal import Decimal


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

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

Solution (Python):
from decimal import Decimal

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

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

print(int(a*b))

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

getcontext().prec = 1000
A, B = input().split()
A = Decimal(A)
B = Decimal(B)

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

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


def readstr():
    return input().strip()


def readint():
    return int(input())


def readnums():
    return map(int, input().split())


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


def main():
    A, B = readstrs()
    A = Decimal(A)
    B = Decimal(B)
    print(int(Decimal(A * B)))


if __name__ == "__main__":
    main()

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

Solution (Python):
from decimal import Decimal

A, B = input().split()

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

print(int(A*B))

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