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
a, b = input().split()
a1 = int(a)
b1 = int(b[0])
b2 = int(b[2])*10 + int(b[3])
if a1*b2 > 100:
    p = a1*b2//100
    print(a1*b1+p)
else:
    print(a1*b1)

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

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

small = str(a*int(b_0[-2:]))


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

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

input = lambda: sys.stdin.readline().rstrip()


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


if __name__ == '__main__':
    solve()

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

line = input().split()
a = Decimal(line[0])
b = Decimal(line[1])
c = a * b

print(math.floor(c))

Solution (Python):


A,B=input().split()
A = int(A)
B = float(B)
if A < 10**2:
    print(int(A*B))
    exit()
Ag = int(A/(10**2))
Bg = round(B*(10**2))
ABg = Ag*Bg
Al = A - Ag*(10**2)
Abl = int(Al*B)
print(ABg+Abl)

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

Solution (Python):
Na, Nb = input().split()
Mb = Nb[:-3] + Nb[-2:]
a = int(Na)
b = int(Mb)
ans = str(a*b)
if len(ans) >= 3:
  print(ans[:-2])
else:
  print(0)

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

a = int(a)



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

answer = a*b

answer = str(answer)

if len(answer) < 3 :
    print('0')
    quit()



print(answer[0:-2])

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

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

res = ""
for ch in range(len(b)):
	if b[ch] != '.':
		res += b[ch]
		
b = int(res)

prod = (a * b) // 100

print(prod)

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

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

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

b *= 1000

a, b = int(a), int(b);

print(a * b // 1000)

Solution (Python):
import sys
import math
from decimal import *
A,B=map(Decimal, sys.stdin.readline().split())
print ((A*B).quantize(Decimal('0'), rounding=ROUND_FLOOR))

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

Solution (Python):
from fractions import Decimal, Fraction
a,b = input().split()
a = Fraction(a)
x = Decimal(b).as_integer_ratio()
b = Fraction(x[0], x[1])
print(int(a*b))

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

Solution (Python):

from decimal import Decimal
import math

a = input().split()
print(math.floor(int(a[0]) * Decimal(a[1])))

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

Solution (Python):
a,b = map(str,input().split())
a = int(a)
if len(b) == 4:
    b = int(b[0] + b[2:])
    
else:
    b = int(b[0] + b[2] +'0')
tmp = str(a*b)
if len(tmp) <=2:
    print(0)
else:
    tmp = str(a*b)[:-2]
    print(int(tmp))

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

Solution (Python):

import math
from decimal import Decimal
a,b = input().split()
a = Decimal(a)
b = Decimal(b)
if a==0 or b==0:
    print(0)
else:
    print(int(math.floor(a*b)))

Solution (Python):
a,b = input().split()
a = int(a)
s = a*int(b[0])
g = a*int(b[2])
d = a*int(b[3])
s = str(s)+'00'
g = str(g)+'0'
d = str(d)

ans = int(s)+int(g)+int(d)
print(ans // 100)

Solution (Python):
from decimal import  Decimal

N=list(input().split())

A=Decimal(N[0])
B=Decimal(N[1])

print(int(A*B))

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

b0=int(b[0])
b2=int(b[2])
if len(b)==4:
    b3=int(b[3])
else:
    b3=0

ans=Decimal(A)*b0+Decimal(A)*b2/10+Decimal(A)*b3/100
print(math.floor(ans))

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

flag = 'b'
b_num = 0

for i in range(len(b)):
    if b[i] == '.':
        continue
    else:
        b_num = b_num*10+int(b[i])




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

Solution (Python):

import sys
import numpy as np


def solve(A: int, B: float):
    B100 = int(B*1000)
    ans = (A*B100)-((A*B100) % 1000)
    print(ans//1000)
    return



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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
import math
A,B=list(map(float,input().split()))
A=int(A)
Bfloat, Bint = math.modf(B)

Bfloat=int(round(Bfloat*100,2))


ABfloat=int(A*Bfloat)
strABfloat=str(ABfloat)
lenABfloat=len(strABfloat)

temp=0
if lenABfloat>=3:
  for i in range(lenABfloat-2):
    temp+=int(strABfloat[i])*10**(lenABfloat-i-3)  
    
print(int(A*Bint)+temp)

Solution (Python):
def main():
    a, b = input().split(' ')
    a = int(a)

    b = b.replace('.', '')
    ans = int(0)
    div = int(1)
    syosu = 0.
    for c in b:
        tmp = int(a) * int(c)
        ans += tmp // int(div)
        syosu += float(tmp % div) / float(div)
        div = int(div * int(10))
    ans += int(syosu // 1)

    print(ans)


if __name__ == '__main__':
    main()

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

line= input().split()
a = int(line[0])
b = Decimal(line[1]).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)

print(math.floor(a * b))

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




from decimal import *

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

print(int(a*b))

Solution (Python):
M,N = input().rstrip().split(" ")
N2 = 0
N2 += int(N[0]) * 100
N2 += int(N[2]) * 10
N2 += int(N[3])

M = int(M) * 100

print((N2 * M) // 10000)

Solution (Python):
import math
A_in, B_in = map(str, input().split())
A = int(A_in)
ans = ( A*int(B_in[0])*100 + A*int(B_in[2])*10 + A*int(B_in[3]) )//100


print(ans)

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

c = a*int(b[0])
d = a*int(b[2])
e = a*int(b[3])

d = str(d)
e = str(e)

if d != '0' and e != '0':
    f = d[0:-1]
    if len(e) >= 2:
        g = e[0:-2]
    else:
        g = 0
    if len(e) >= 2:
        h = 10*int(d[-1]) + int(e[-1]) + 10*int(e[-2]) 
    else:
        h = 10*int(d[-1]) + int(e[-1])
    if h >= 100:
        h = h//100
    else:
        h = 0
elif d == '0':
    f = 0
    if len(e) >= 2:
        g = e[0:-2]
    else:
        g = 0
    if len(e) >= 2:
        h = int(e[-1]) + 10*int(e[-2])
    else:
        h = int(e[-1])
    if h >= 100:
        h = h//100
    else:
        h = 0
else:
    f = d[0:-1]
    g = 0
    h = 10*int(d[-1])
    if h >= 100:
        h = h//100
    else:
        h = 0

ans = c + int(f) + int(g) + h

print(ans)

Solution (Python):
A,B = map(float,input().split())
A = int(A)
buf = 0
bbuf = B - int(B)
for i in range(int(B)) :
    buf += A
bbuf = round(bbuf,4)
cbuf = 0
for i in range(int(bbuf * 100)) :
    cbuf += A
cbuf = cbuf // 100
print(buf + cbuf)

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

Solution (Python):
from decimal import Decimal
import math

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

Solution (Python):
from decimal import *

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

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

Solution (Python):
import math
from decimal import Decimal

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

print(math.floor(a*b))

Solution (Python):
A, B = map(str, input().split())
A = int(A)
b = ''
for i in range(len(B)):
    if i != len(B) - 3:
        b += B[i]
b = int(b)
ret = A * b
ret //= 100
print(ret)

Solution (Python):
a,b=input().split()
A=int(a)
B=float(b)
c=round(100*B)%100
d=int(B)
e=A*c//100

print(int(A*d+e))

Solution (Python):

import numpy as np
from functools import *
from decimal import Decimal
import sys
sys.setrecursionlimit(100000)



def gcd(a, b):
	while b:
		a, b = b, a % b
	return a


def acinput():
    return list(map(Decimal, input().split(" ")))


a,b=acinput()

print(int(a*b))

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

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

print(int(result))

Solution (Python):

import sys
from decimal import *

l = list(map(lambda x: Decimal(x), str(input()).split(" ")))
print(int(l[0] * l[1]))

Solution (Python):
from decimal import *




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

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

Solution (Python):

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

from decimal import *





































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

inf = float('inf')
mod = 1000000007




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

	ans = A * B

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






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

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





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

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




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




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


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

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




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


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

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

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

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



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



if __name__ == "__main__":
	main()

Solution (Python):
from decimal import Decimal

tmp = input().split()
A = int(tmp[0])
B = Decimal(tmp[1])
print(int(A*B))

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

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

    B = int(B[0] + B[2:4])

    print(math.floor((B * A)//100))

if __name__ == '__main__':
    main()

Solution (Python):

import math
str_a, str_b = input().split()
a = int(str_a)
b1 = int(str_b[0])
b01 = int(str_b[2])
b001 = int(str_b[3])

product_1 = a * b1
product_01 =  a * b01
product_001 = a * b001


tmp_result = product_1 * 100 + product_01 * 10 + product_001
str_result = str(tmp_result)
if len(str_result) < 3:
    result = 0
else:
    result = str_result[0:-2]

print(result)

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

print(int(a*b))

Solution (Python):
import sys



import math







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

def main():
    A, B = map(str, stdin.readline().rstrip().split())
    ans = 0
    ans = int(A) * int(B[-1])
    ans += int(A) * int(B[-2]) * 10
    ans = ans // 100
    ans += int(A) * int(B[-4])
    if len(B)==5:
        ans += int(A) * int(B[-5])
    print(ans)

main()

Solution (Python):
a, b = input().split()
a = int(a)
b = int(b.replace('.', ''))
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 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 numpy as np

nums = input().split()
nums = np.array(nums, dtype=np.float128)
ans = np.array([nums[0]*nums[1]], dtype=np.uint64)
print(ans[0])

Solution (Python):
a, b = input().split()
a = int(a)
b0, b12 = b.split(".")
b1 = b12[0]
b2 = b12[1]
b0 = int(b0)
b1 = int(b1)
b2 = int(b2)

ans0 = a * b0
ans1 = str(a * b1)
ans2 = str(a * b2)
if len(ans1) > 1:
    ans1i = int(ans1[:-1])
else:
    ans1i = 0
if len(ans2) > 2:
    ans2i = int(ans2[:-2])
else:
    ans2i = 0

ans1f=int(ans1)%10
ans2f=int(ans2)%100

if ans1f*10+ans2f>=100:
    ans12i=1
else:
    ans12i=0




print(ans0 + ans1i + ans2i+ans12i)

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

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

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

print(math.floor(A * B))

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

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

Solution (Python):
A, B = input().split()
A = int(A)
Bi, Bf = map(int, B.split('.'))
ansi = A*Bi
ansf = A*Bf//100
print(ansi + ansf)

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

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

Solution (Python):
a,b = map(float,input().split())
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
b = Decimal(str(b)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
a = Decimal(a)
ans = a*b
print(math.floor(ans))

Solution (Python):
def main():
  a, b = input().split()
  
  from decimal import Decimal, ROUND_FLOOR
  
  a = Decimal(a)
  b = Decimal(b)
  
  c = a * b
  c = c.quantize(Decimal('1.'), rounding=ROUND_FLOOR)
  
  print(c)
  

    


if __name__ == "__main__":
  main()

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

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

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

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

Solution (Python):
import math
import decimal




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


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

print(int(a*b))

'''
a=int(A)
b=float(B)*100


bb=int(b)

print(math.floor(a*bb//100))
'''

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

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

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

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

Solution (Python):
from decimal import *

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

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

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

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

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

Solution (Python):
import math

ab = input().split()
a, b_f = int(ab[0]), float(ab[1])

b = round(b_f * 100)






a = a * b



print(a // 100)

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

a_1 = int(a)

b_1 = int(b[0])*100
b_10 = int(b[2])*10
b_100 = int(b[3])

ans = a_1 * b_1
ans += (a_1 * b_10)
ans += (a_1 * b_100)

print(ans//100)

Solution (Python):
import decimal

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

Bdecimal = decimal.Decimal(b)



B100 = Bdecimal * 100



ans = int(a) * int(B100)

ans = ans // 100

print(ans)

Solution (Python):
from decimal import Decimal

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

Solution (Python):
from decimal import Decimal
import math
a, b = [x for x in input().split()]
A = int(a)
B = int(b.replace(".", ""))
ans = str(A*B)[:-2]
if len(ans) == 0:
    print(0)
else:
    print(ans)

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


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

Solution (Python):

import numpy as np
from collections import deque
import collections
import heapq
from decimal import Decimal

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

Solution (Python):
import math
from decimal import Decimal

inputs = input().split(' ')
a,b = int(inputs[0]), Decimal(inputs[1])
print(math.floor(a*b))

Solution (Python):




A,B = input().split()
A = int(A)
B = round(float(B)*100)

print((A*B)//100)

Solution (Python):
from decimal import Decimal
import math 

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

print(int(math.floor(A*B)))

Solution (Python):
from decimal import *

sAB = input().split()

ans = int(Decimal(sAB[0]) * Decimal(sAB[1]))

print(ans)

Solution (Python):
import sys
import math

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
   
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

print((a*b)//1000)

Solution (Python):


import sys
import math
import time

import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq
import itertools



sys.setrecursionlimit(10**7)







AB = input().split()
A = int(AB[0])
B = int(AB[1].replace('.',''))

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

Solution (Python):
from decimal import Decimal
import math

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

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

Solution (Python):
A,B = open(0).read().split()
A = int(A)
B = int(B.replace('.',''))
print(A*B//100)

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

Solution (Python):
from decimal import Decimal

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

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

Solution (Python):
import math
a,b_sub = list(input().split())

b_sub = list(b_sub)
b = int(b_sub[0])*(10**2) + int(b_sub[2])*10 + int(b_sub[3])
a = int(a)

ans = a*b
ans = list(str(ans))
n = len(ans)

ans_1 = 0
if n >= 3:
  for i in range(1,n-1):
    ans_1 += int(ans[-2-i])*(10**(i-1))
else:
  ans_1 = 0

print(ans_1)

Solution (Python):
import sys
from decimal import *
def inpl(): return list(map(str, sys.stdin.readline().split()))

ab = inpl()

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

Solution (Python):


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

Solution (Python):
import fractions
import decimal

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

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

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

a, b = input().split()
ans = int(a) * Decimal(b)
print(int(str(ans)[:-3]))

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

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

Solution (Python):
from decimal import Decimal

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

Solution (Python):
from decimal import *

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

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

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):
import math
import decimal

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

print(math.floor(a*b))

Solution (Python):


a, b = input().split()
a = int(a)
b = int(b[0] + b[2:])
s = str(a * b)
if len(s) < 3:
    print(0)
else:
    print(int(s[:len(s) - 2]))

Solution (Python):
import math
a, b = input().split()
a = int(a)
b = int(b.replace(".", ""))
ans = 0
for i in range(4):
    a_sub = a//(10**(4*i))%(10**4)
    
    ans += a_sub*b*(10**(4*i))//100

print(ans)

Solution (Python):
import sys
from decimal import Decimal


def input():
    return sys.stdin.readline().strip()


sys.setrecursionlimit(20000000)

MOD = 10 ** 9 + 7
INF = float("inf")


def main():
    A, B = map(str, input().split())
    A = int(A)
    B = int(Decimal(B) * 100)
    c = str(A * B)
    answer = 0
    for i in range(len(c) - 2):
        answer = answer * 10 + int(c[i])

    print(answer)


if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys
a,b = map(str, input().split()) 
keta=len(b)-b.find('.')

if keta==3:
  print(int(a)*int(b.replace(".",""))//100)
elif keta==2:
  print(int(a)*int(b.replace(".",""))//10)
else:
  print(int(a)*int(b))

Solution (Python):
import math
a, b = input().split()
a = int(a)
bList = b.split('.')
b = int(bList[0]) * 100 + int(bList[1])
print(a*b // 100)

Solution (Python):
import sys
import math
from decimal import Decimal, ROUND_DOWN

if(__name__ == "__main__"):


    AList_Str = input().strip().split()
    """
    A = int(AList_Str[0])
    B = float(AList_Str[1])
    """
    A = int(AList_Str[0])
    B = float(AList_Str[1])
    C = Decimal(AList_Str[1])*A
    Multiply = C.quantize(Decimal('1.'), rounding = ROUND_DOWN)
    print(Multiply)

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

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

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

mul = a * b
mul_floor = math.floor(a * b)

print(mul_floor)

Solution (Python):
import sys
from decimal import *
def inpl(): return list(map(str, sys.stdin.readline().split()))

ab = inpl()

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

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

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

Solution (Python):
from decimal import *
a, b = [ Decimal(f) for f in input().split()]
r = a * b
getcontext().rounding = ROUND_DOWN
print('{:.0f}'.format(r))

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

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

Solution (Python):
S = input().split()
import decimal
x = decimal.Decimal(S[0])
y = decimal.Decimal(S[1])

print(int(x*y))

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