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 sys
from io import StringIO
import unittest
import math
from decimal import Decimal, ROUND_FLOOR

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

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

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

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """198 1.10"""
        output = """217"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """1 0.01"""
        output = """0"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """1000000000000000 9.99"""
        output = """9990000000000000"""
        self.assertIO(input, output)


if __name__ == "__main__":
    
    resolve()

Solution (Python):
import math
from decimal import Decimal


A, B = input().split()

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

result = Decimal(A * B)

print(math.floor(result))

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

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

Solution (Python):
def main():
    from builtins import int, map, list, print
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = (lambda: (sys.stdin.readline()).rstrip())
    input_list = (lambda: input().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

    A, B = input_list()
    a = int(A)
    B = str(B)
    B = B.replace(".", "")
    b = int(B)
    ans = a * b
    ans = str(ans)
    ans = ans[:-2]
    if ans == "":
        print(0)
    else:
        print(ans)



if __name__ == '__main__':
    main()

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

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

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

    a, b = Decimal(a), Decimal(b)

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

if __name__ == '__main__':
    main()

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

Solution (Python):
from decimal import Decimal

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

ans = int(A*B)

print(ans)

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

Solution (Python):
s,ss=input().split()
ss=ss.replace(".","")
i=int(s)
ii=int(ss)
print(i*ii//100)

Solution (Python):
import math
from decimal import Decimal

A = input().split()
result = Decimal(A[0]) * Decimal(A[1]) 
print(math.floor(result))

Solution (Python):
inputlist = input().strip().split(" ")
a = int(inputlist[0])
b = int(inputlist[1][0] + inputlist[1][2:])

print(a*b//100)

Solution (Python):
from decimal import Decimal, ROUND_DOWN

N, K = map(Decimal, input().split())

print(Decimal(N*K).quantize(Decimal('0'), rounding=ROUND_DOWN))

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

from decimal import Decimal

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

Solution (Python):
from decimal import *
a,b=input().split()
a=Decimal(a)
b=Decimal(b)
print(str(a*b)[:-3])

Solution (Python):
A,B = map(str,input().split())
A = int(A)
if B[-2] == ".":
    B = B[:-2] + B[-1] + "0"
elif B[-3] == ".":
    B = B[:-3] + B[-2:]
else:
    B = B + "00"

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

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

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

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

Solution (Python):
import math
a, b = input().split()
a = int(a)
for i in range(1000):
    s = '{:4.2f}'.format(i / 100)
    
    if s == b:
        x = i
        break
print(a * x // 100)

Solution (Python):
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()

A,B=input().split()
A=int(A)
if not "." in B:
    print(A*int(B))
else:

    if B[-2]==".":
        Z=""
        for b in B:
            if not b==".":
                Z+=b
        B=int(Z)
        C=A*int(B)
        C//=10
        print(C)
    elif B[-3]==".":
        Z=""
        for b in B:
            if not b==".":
                Z+=b
        B=int(Z)
        C=A*int(B)
        C//=100
        print(C)

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

A = int(A)
B = Decimal('{}'.format(B))

print(int(A * B))

Solution (Python):
from decimal import Decimal, ROUND_DOWN

A,B=input().split()
A=Decimal(A).quantize(Decimal('0'), rounding=ROUND_DOWN)
B=Decimal(B).quantize(Decimal('0.01'), rounding=ROUND_DOWN)
C=A*B
C=Decimal(str(C)).quantize(Decimal('0'), rounding=ROUND_DOWN)
print(C)

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

a_ = Decimal(a)
b_ = Decimal(b)
c = a_ * b_
print(c.quantize(Decimal('0'), rounding=ROUND_DOWN))

Solution (Python):
import numpy as np
a,b =list(input().split(" "))
a = np.int(a)
b = np.float128(b)
ret = int(np.floor(a * b))

print(ret)

Solution (Python):
import math
import decimal

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

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

Solution (Python):
a_s, b_s = input().split()

b_s = b_s.replace(".", "")

s = str(int(a_s) * int(b_s))
if len(s) > 2:
    print(str(int(a_s) * int(b_s))[:-2])
else:
    print(0)

Solution (Python):
import sys
import math
import collections
import decimal
from collections import deque
from functools import reduce
import heapq

a, b = map(str, sys.stdin.readline().split())



x = int(a)
y = decimal.Decimal(b)
        
print(math.floor(x*y))

Solution (Python):
from decimal import Decimal
a, b = map(str, input().split())
num = list(str(Decimal(a) * Decimal(b)))
ans = ''
for i in num:
    if i == '.':
        break
    ans += i
print(ans)

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

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

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

Solution (Python):
from fractions import Fraction
import math 
N, M = input().split()
N = Fraction(N)
M = Fraction(M)
ans = N * M

print(int(ans))

Solution (Python):
from decimal import Decimal

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

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

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

print(a * b100 // 100)

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

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

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

Solution (Python):

import math

A, B = input().split()

A = int(A)
if '.' in B:
    B_a = int(B.split('.')[0])
    B_b_size = len(B.split('.')[1])
    B_b =  int(B.split('.')[1])
else:
    B_a = int(B)
    B_b_size = 0
    B_b = 0
if B_b_size == 0:
    ans = A * B_a
elif B_b_size == 1:
    ans_a = A * B_a
    ans_b = A * B_b 
    ans_b = ans_b // 10
    ans = ans_a + ans_b
else:
    ans_a = A * B_a
    ans_b = A * B_b 
    ans_b = ans_b // 100
    ans = ans_a + ans_b
print(ans)

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

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

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

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

from decimal import Decimal

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

Solution (Python):
a, b = 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.replace(".", ""))
print((a * b) // 100)

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

Solution (Python):
import decimal
A,B=input().split()
A=int(A)
B=decimal.Decimal(B)
c=A*B
c=c.quantize(decimal.Decimal('1'), rounding=decimal.ROUND_FLOOR)
print(c)

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

Solution (Python):
import sys                                                            
import decimal                                                        
a,b = [decimal.Decimal(x) for x in sys.stdin.readline().split(" ")]   
c = a * b                                                             
print(c.quantize(decimal.Decimal('1.'), rounding=decimal.ROUND_DOWN))

Solution (Python):
def main():
    import decimal
    A , B = map(decimal.Decimal, input().split())
    C = decimal.Decimal(A) * decimal.Decimal(B)
    
    D = str(C)
    D = D.split(".")[0]
    
    E = int(D)
    print(E)



if __name__ == '__main__':
    main()

Solution (Python):
a,b = map(float,input().split())
b = round(b,2)
c = b - b // 1
c = round(c,2)
b = int(b)

c *= 100

a = round(a,0)
a =int(a)

ans = a * b
p = 0
c = int(c)
for i in range(c):
    p += a

ans += round(a * c // 100 ,3)

ans = int(ans)
print(ans)

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

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

print(int(a * b))

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

print(ans)

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

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

Solution (Python):
from sys import stdin
from copy import deepcopy
from functools import reduce
from fractions import gcd
import math
import itertools
from collections import Counter
from itertools import chain  
from heapq import heappush, heappop
import bisect
from decimal import Decimal

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

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

print(ans)

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

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

Solution (Python):
from math import floor as f
a,b=input().split()
b=int(str(b).replace(".",""))
print(int(a)*b//100)

Solution (Python):
import sys
import decimal

a,b = input().split()
Da = decimal.Decimal(a)
Db = decimal.Decimal(b)
res = Da*Db

print(int(res))

Solution (Python):

def main():
    a,b = input().split()
    a = int(a)
    answer = 0
    b_big,b_small = map(int,b.split("."))

    answer += b_big * a
    answer += b_small * a // 100
    print(answer)

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
a, b = input().split()
a = int(a)
b = b.replace('.', '')
c = 0
for i, n in enumerate(map(int, reversed(b))):
    c += n * 10 ** i

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

Solution (Python):
def mp(): return map(int, input().split())
def lmp(): return list(map(int, input().split()))

import math
a,b = map(str,input().split())
a = int(a)
b = b[0]+b[2]+b[3]
b = int(b)
print(a*b//100)

Solution (Python):
from fractions import Fraction
a,b=input().split()
a=Fraction(int(a),1)
b=Fraction(int(b[0]+b[2:]),100)
print(int(a*b))

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

Solution (Python):
A,B=map(str,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)
B = int(B.replace(".", ""))
print(A * B // 100)

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp



class UnionFindEx:
    def __init__(self, size):
        
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


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






main()

Solution (Python):
from decimal import Decimal
import math

A,B = map(float,input().split())
tmp_A = str(A)
tmp_B = str(B)
f1 = Decimal(tmp_A)
f2 = Decimal(tmp_B)
print(math.floor(f1*f2))

Solution (Python):
A, B = input().split()
A = int(A)
B_1, B_2 = B.split(".")
B_10 = int(B_1)*100 + int(B_2)

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

Solution (Python):
from math import floor
import decimal

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

Solution (Python):


a, b = map(str, input().split(' '))
a = int(a)
x = ""
for i in b:
    if i == '.':
        continue
    x += i
b = int(x)


ans = a * b
ans = str(ans)

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

Solution (Python):
import math
import decimal

list1 = input().split()
N = decimal.Decimal(list1[0])
M = decimal.Decimal(list1[1])
a = N*M

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

Solution (Python):
import decimal

A,B = input().split()

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

ans = decimal.Decimal(a*b)

print(int(ans))

Solution (Python):
from decimal import *

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

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

Solution (Python):
from decimal import Decimal,getcontext
import math
getcontext().prec = 100

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

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

Solution (Python):
from decimal import *
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b=STRM()
    a=Decimal(int(a))
    b=b[0]+b[2:4]
    b=Decimal(int(b))
    print(a*b//Decimal(100))
    
if __name__ == '__main__':
    do()

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



a2 = round(int(a),len(a))
b2 = b.replace('.','')
b3 = round(int(b2),len(b2))


c = a2 * b3
c2 = str(c)

if len(c2)<3:
    print(0)
else:
    print(c2[0:-2])

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

  
print(int(ans))

Solution (Python):
import math

a, b = map(float, input().split())
b = (b+10**(-6))*100
ab = str(int(a)*int(b))
if len(ab) <= 2:
    print(0)
else:
    ans = int(ab[:-2])
    print(ans)

Solution (Python):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))

i=input()

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

Solution (Python):
a, b = map(str, input().split(' '))
a = int(a)
x = ""
for i in b:
    if i == '.':
        continue
    x += i
b = int(x)


ans = a * b
ans = str(ans)

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

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

Solution (Python):
from decimal import *
d1 = Decimal("0.01")
A, B = input().split()
a = Decimal(A)
b = Decimal(B)

print(str(a*b).split('.')[0])

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())
import math
import decimal
a = decimal.Decimal(a)
b = decimal.Decimal(str(b))
ans = a*b
print(int(ans))

Solution (Python):






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


print(Decimal(ans).quantize(Decimal("0"), rounding=ROUND_DOWN))

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

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

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

Solution (Python):
from decimal import Decimal

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

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

Solution (Python):

import sys
input = sys.stdin.readline


class Solution:
    def main(self):
        a, b = input().split()
        a = int(a)
        b1,b2 = b.split(".")

        ans = a * int(b1)
        c = ((a * int(b2[0]) * 10) + (a * int(b2[1])) )// 100

        print(ans + c)


if __name__ == '__main__':
    Solution().main()

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

from decimal import Decimal
a = Decimal(a)
b = Decimal(b)
ans = a*b

import math
print(math.floor(ans))

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

Solution (Python):
from decimal import Decimal

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

Solution (Python):
import math
import string
import collections
from collections import Counter
from collections import deque
from decimal import Decimal


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
ab = list(input().split())


ans = Decimal(ab[0]) * Decimal(ab[1])
print(math.floor(ans))

Solution (Python):
temp = input().split(" ")
A = int(temp[0])

i = int(temp[1].split(".")[0])
j = int(temp[1].split(".")[1])

x = A * i
y = A * j // 100

print(x+y)

Solution (Python):
A, B = input().split()
A = int(A)
if B[0] == "0":
    B = int(B[2:])
else:
    B = int(B.replace(".", ""))

print(A*B//100)

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

Solution (Python):

import sys


def solve(A: int, B: str):
    b=int(B[0])*100+int(B[2:])
    print(b*A//100)
    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 = str(next(tokens))  
    solve(A, B)

if __name__ == '__main__':
    main()

Solution (Python):
A, B = input().split()
A = int(A)
if B == '0':
    print(0)
    exit()
B = int(B[0]+B[2:])

print((A * B) // 100)

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

a = int(a)
nb = int(b[0])

sb = int(b[2:4])

p = a * sb
p = p//100

print(p + a * nb)

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

Solution (Python):

import math
from decimal import Decimal
ab = list(map(str,input().split()))
a=Decimal(ab[0])
b=Decimal(ab[1])

print(math.floor(a*b))

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

Solution (Python):

def parse():
  splited = input().split(" ")
  A = int(splited[0])
  B_n = splited[1].split(".")[0]
  B_d = splited[1].split(".")[1]
  B = int(B_n) * 100 + int(B_d)
  return A, B

def main():
  A, B = parse()
  print(int(A * B // 100))

if __name__ == "__main__":
  main()

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

if __name__ == '__main__':
    main()

Solution (Python):
import math
import decimal

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

print(math.floor(A * B))

Solution (Python):
a,b = input().split()
a = int(a)
b0 = int(b[0])
b1 = int(b[2])
b2 = int(b[3])
r = str(a*100*b0 + a*10*b1 + a*b2)
if len(r) < 3:
    print(0)
else:
    print(r[:-2])

Solution (Python):
import sys

sys.setrecursionlimit(10000000)
import os
import math
import bisect
import collections
import itertools
import heapq
import re
import queue
from decimal import Decimal


ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
dl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)


MOD = 10 ** 9 + 7
MAX = float('inf')


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

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


if __name__ == '__main__':
    main()

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

a = int(a)
nb = int(b[0])

sb = int(b[2:4])

p = a * sb
p = p//100

print(p + a * nb)

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

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

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

Solution (Python):
EPS=10**-8
A,B=input().split()
A=int(A)
B=int(float(B)*100+EPS)
print(A*B//100)

Solution (Python):
import decimal

A_B = input().split(" ")

a = decimal.Decimal(str(A_B[0]))
b = decimal.Decimal(str(A_B[1]))

print(int(a*b))

Solution (Python):

import sys

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

A, B = sr().split()
A = int(A)
B = int(float(B) * 1000)
answer = int(A*B)//1000
print(answer)

Solution (Python):

from decimal import Decimal

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

print(int(A*B))

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

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

x = a // 1000 * (1000 *b)
y = a % 1000

ans = int(x) + int(y*b)
print(ans)

Solution (Python):
from decimal import Decimal, ROUND_DOWN
import heapq
from fractions import gcd
from functools import reduce
from collections import deque

import itertools
import collections
import math
import sys
sys.setrecursionlimit(2000000)








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






ans = (Decimal(str(a)) * Decimal(str(b))
       ).quantize(Decimal('0'),  rounding=ROUND_DOWN)
print(ans)

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

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

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

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    A, B = rl().split()
    ans = Decimal(A) * Decimal(B)
    ans = ans.quantize(Decimal('0'), rounding=decimal.ROUND_FLOOR)
    print(ans)


if __name__ == '__main__':
    solve()

Solution (Python):
import math
import decimal

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

c = decimal.Decimal(a)
d = decimal.Decimal(b)

e = c * d

print(math.floor(e))

Solution (Python):

from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict, Counter
from itertools import combinations, permutations, combinations_with_replacement
from itertools import accumulate
from math import ceil, sqrt, pi, radians, sin, cos
import decimal

MOD = 10 ** 9 + 7
INF = 10 ** 18

A, B = input().split()

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

print(int(A * B))

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

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

a = int(a)
nb = int(b[0])

sb = int(b[2:4])

p = a * sb
p = p//100

print(p + a * nb)

Solution (Python):
a,b=map(str,input().split())
a=int(a)
c,d=map(int,b.split("."))
print(a*c+int(a*d//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):
line = input()
nums = line.split(" ")
a = int(nums[0])
b = int(nums[1].replace(".", ""))
print(str(a*b)[:-2] or 0)

Solution (Python):
A, B = input().split()
li = []
for i in range(len(B)):
    if B[i] != ".":
        li.append(B[i])
li.reverse()
num = 1
num2 = 0
for i in range(len(li)):
    num2 += num * int(li[i])
    num *= 10
A = int(A)
B = num2
C = A * B
D = C % 100
C = C - D
C = C // 100
print(C)

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

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

    ans = int(ans)
    print(ans)
resolve()

Solution (Python):
import math
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,b = int(a),int(b[0] + b[-2:])
print(a * b // 100)

Solution (Python):
from decimal import *

tmp = input().split()

A = Decimal(tmp[0]).quantize(Decimal("0"), rounding=ROUND_HALF_UP)
B = Decimal(tmp[1]).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)

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

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

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

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

Solution (Python):
from decimal import Decimal
import math

a,b=[float(x) for x in input().rstrip().split()]
a = Decimal(str(a))
b = Decimal(str(b))
print(math.floor(a*b))

Solution (Python):
import math
from decimal import Decimal
a = list(map(str,input().split()))
a[0]=int(a[0])
a[1]=Decimal(a[1])
ans=a[0]*a[1]
print(math.floor(ans))

Solution (Python):
import math
from decimal import Decimal

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

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

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

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

print(int(A*B))

Solution (Python):
from decimal import Decimal
import math

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

c = a * b
d = math.floor(c)
print(d)

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

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


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

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

Solution (Python):

import numpy as np;
from numba import jit
from decimal import Decimal


if __name__ == '__main__':
  A, B = map(Decimal, input().split())
  ans = A * B
  print("%d" %ans)

Solution (Python):
from math import floor
a,b = input().split()
c = ""
for i in b:
    if i!=".":
        c+=i

c = int(c)

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

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

Solution (Python):
s_in=input().split()
A=int(s_in[0])
B=float(s_in[1])
Bi =int(B*100+0.5)
c=A*Bi
print(c//100)

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