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

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

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

Solution (Python):
from decimal import Decimal, ROUND_DOWN

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

print(int(A * Decimal(B).quantize(Decimal('0.01'), rounding=ROUND_DOWN)))

Solution (Python):
from decimal import *

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

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

n = 2  
b = Decimal(str(b)).quantize(Decimal(str(10**(n*-1))), rounding=ROUND_DOWN)


print(int(a*b))

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

a = int(A)
b = int(B[0])
b_ = int(B[2])
b__ = int(B[3])

c = a * b * 100
c_ = a * b_ * 10
c__ = a * b__

ans = (c + c_ + c__) // 100

print(ans)

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

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue
import numpy as np

Mod = 1000000007
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  
    a, b = input().split()
    b = b.replace(".", "")
    print(int(a)*int(b)//100)   
if __name__ == "__main__":
    main()

Solution (Python):


"""
    Author : thekushalghosh
    Team   : CodeDiggers
 
    I prefer Python language over the C++ language :p :D
        
    Visit my website : thekushalghosh.github.io
"""
import sys,math,cmath,time,decimal
start_time = time.time()


 
def solve():
    a,b = insr().split(" ")
    q = b.index(".")
    qw = b[:q]
    w = int(b[:q] + b[q + 1:])
    qq = len(b) - q - 1
    if len(str(int(a) * w)) <= qq:
        print(0)
        return
    print(str(int(a) * w)[:- q - 1])
                


 
def main():
    global tt
    if not ONLINE_JUDGE:
        sys.stdin = open("input.txt","r")
        sys.stdout = open("output.txt","w")
    t = 1
    for tt in range(t):
        solve()
    if not ONLINE_JUDGE:
        print("Time Elapsed :",time.time() - start_time,"seconds")
    sys.stdout.close()
    

def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    return(input().strip())
def invr():
    return(map(float,input().split()))
 

def counter(a):
    q = [0] * max(a)
    for i in range(len(a)):
        q[a[i] - 1] = q[a[i] - 1] + 1
    return(q)
 
def string_counter(a):
    q = [0] * 26
    for i in range(len(a)):
        q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
    return(q)
 
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
    input = sys.stdin.readline
    
main()

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

print(int(c))

Solution (Python):
import math
from decimal import Decimal
str = input()

str2 = str.split(" ")

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


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

Solution (Python):
from decimal import Decimal
import math

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

print(math.floor(a*b))

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

Solution (Python):
from decimal import Decimal
x,y = map(str,input().split())
import math
x=int(x)
y=Decimal(y)
val_floor = math.floor(x*y)
print(int(val_floor))

Solution (Python):
from math import trunc
a, b = input().split()
a = int(a)
b = list(b)
b.remove(".")
b = "".join(b)
b.lstrip("0")
b = int(b)
answ = list(str(a*b))
answ.insert(-2, ".")
final = ""
for x in answ:
	if x != ".":
		final += x
	else:
		break
if final == "":
	print(0)
else:
	print(final)

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

print((A*B).quantize(Decimal('0'),rounding = ROUND_FLOOR))

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

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

B = B.split(".")
B = int(B[0]) * 100 + int(B[1])

print(A * B // 100)

Solution (Python):
text = input().split()
A = int(text[0])
B = int(text[1].replace(".", ""))
C = B
if(A * C < 100):
    print(0)
else:
    print(str(A * C)[:-2])

Solution (Python):
from decimal import Decimal, getcontext, ROUND_DOWN
A, B = input().split()
dta = Decimal(A)
dtb = Decimal(B)
getcontext().rounding = ROUND_DOWN
print(Decimal(dta * dtb).quantize(Decimal('0')))

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

a, b = input().split()

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

ans = math.floor(a * b)

print(ans)

Solution (Python):
A,B = map(float,input().split( ))
A = int(round(A))
B_0 = B//1
B_1 = B%1
ans_0 = round(A*B_0)
ans_1 = A*round(B_1*100)//100
print(int(round(ans_0 + ans_1)))

Solution (Python):
import math
from decimal import *

sa, sb = input().split()
a = Decimal(sa)
b = Decimal(sb)
lb = Decimal(b * Decimal(100))

ans = Decimal(Decimal(a * lb) // Decimal(100))
print(int(ans))

Solution (Python):

from decimal import Decimal
A,B= map(str,input().split())
A2 = Decimal(A)
B2 = Decimal(B)

print(int(A2*B2))

Solution (Python):
import bisect
import collections
import copy
import functools
import heapq
import math
import sys
from collections import deque
from collections import defaultdict
input = sys.stdin.readline
MOD = 10**9+7

a,b = map(str,(input().split()))
a = int(a)
b = list(b)
c = []
now = float("inf")
for i in range(len(b)):
    if b[i] == ".":
        now = i
    if i > now:
        c.append(b[i])
b = b[:now]

bnew = int("".join(b))
cnew = int("".join(c))

ans = a*bnew
ans += a*cnew//100
print(ans)

Solution (Python):
import math

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

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

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

Solution (Python):
a, b = tuple(input().split())
b_1, b_2 = tuple(map(int, b.split('.')))
a = int(a)

print(a * b_1 + (a * b_2 // 100))

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

Solution (Python):
from decimal import Decimal

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

print(int(Decimal(A)*Decimal(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 decimal import Decimal

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

b = Decimal(x[1])


if a == 0:
    print("0")
else:
    c = a*b
    print(int(c))

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

a *= b

print(math.floor(a))

Solution (Python):
import sys
input = sys.stdin.readline
import math
from decimal import Decimal
def main():
    inp = input().split()
    a = int(inp[0])
    b = Decimal(inp[1])
    ans = a * b
    ans = math.floor(ans)
    print(ans)
if __name__ == "__main__":
    main()

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

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

Solution (Python):
A , B = input().strip().split(" ") ;  
A = int ( A ) ;
B = B.replace ( '.' , '' ) ;
C = pow ( 10 , len(B) -1 ) ;
print ( A * int(B)  // C ) ;

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

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 *
A, B = (i for i in input().split())  

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

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())
from decimal import *
import math
result = Decimal(a) * Decimal(b)
print(math.floor(result))

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

def main():
    getcontext().rounding = ROUND_DOWN
    A, B = input().split()

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

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


if __name__ == '__main__':
    main()

Solution (Python):
from decimal import Decimal

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

Solution (Python):
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  

AB = LS2()

s = 0
for i in range(len(AB)):
    if AB[i] == ' ':
        s = i
        break
a = ''
for i in range(s):
    a += AB[i]
b = AB[s+1]+AB[s+3]+AB[s+4]

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

Solution (Python):
a, b = input().split()
if a == "0" or b == "0.00":
  print(0)
  exit()
  
a = int(a)
b = int(b[0])*100 + int(b[2])*10 + int(b[3])
ans = a*b//100
print(ans)

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

Solution (Python):
import math
A,B = map(float,input().split())
ans = 0










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

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

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

Solution (Python):
from decimal import Decimal

a,b = input().split()

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

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

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

print(int(A * B))

Solution (Python):
import math
from decimal import Decimal

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

print(math.floor(A*B))

Solution (Python):
from decimal import Decimal, ROUND_FLOOR
A = input().split()
answer = Decimal(A[0])*Decimal(A[1])
print(Decimal(str(answer)).quantize(Decimal('0'), rounding=ROUND_FLOOR))

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

from decimal import Decimal, getcontext
from math import floor
getcontext().prec = 30
a = Decimal(str(a))
b = Decimal(str(b))
print(floor(a * b))

Solution (Python):
from decimal import Decimal
one, two = map(Decimal, input().split())
result = Decimal(one) * Decimal(two)

print(int(result))

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
from math import floor,ceil,sqrt,factorial,log
from heapq import heapify, heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from decimal import Decimal
inf = float('inf')
mod = 1000000007

a, b = input().split()

a = int(a)
b = list(b)
for i in range(len(b)):
    if b[i] == '.':
        pos = i

x = len(b) - pos - 1
b.pop(pos)
b = int(''.join(b))

ans = a * b
ans = str(ans)
if len(ans) < 2:
    ans = int(int(ans) * 10**(-2))
else:
    ans = int(ans[:-pos -1])

print(ans)

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

Solution (Python):
import math

a,b = input().split()
a = int(a)
c1 = int(b[0])
c2 = int(b[2])
c3 = int(b[3])
ans = a*(100*c1 + 10*c2 + c3)
print(math.floor(ans//100))

Solution (Python):
from fractions import Fraction

a, b = input().split()
a = int(a)
num = 0
frac = 0
for i in range(len(b)):
    if b[i] == '.':
        num = b[:i]
        j = i + 1
        frac = b[j:]
num = int(num)
num *= 100
frac = int(frac)
val = num + frac
c = a * val
c = c // 100
d = c
d = int(d)
print(d)

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

Solution (Python):
import math
from decimal import Decimal

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

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

Solution (Python):
from decimal import Decimal
import math

a, b = input().split()

c = Decimal(a) * Decimal(b)

print(math.floor(c))

Solution (Python):
from sys import stdin

a, b = stdin.readline().split()
na = int(a)
nbDec, nbFlt = b.split('.')
nb = (int(nbDec)*100) + int(nbFlt)
print(na*nb//100)

Solution (Python):
import math
import decimal
i = list(map(decimal.Decimal, input().split()))
print(math.floor(i[1]*i[0]))

Solution (Python):
q = input().split(" ")
A = int(q[0])
B = q[1].split(".")

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

s = str(A*int(b1)//100)

print(A*int(b0) + int(s))

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

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

Solution (Python):

import sys
import math
from decimal import Decimal

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

if a==0 or b==0.00:
    print(0)
    sys.exit()

ans = int(a*b)

print(ans)

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

def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())

def LF(): return list(map(float,sys.stdin.readline().rstrip().split()))

A,B = LS()






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

Solution (Python):
from sys import stdin, setrecursionlimit


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


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

Solution (Python):
import math
import itertools
import functools
import numpy as np
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_DOWN


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

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

a = int(x[0])
b = Decimal(x[1])

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

Solution (Python):
from decimal import Decimal

A, B = input().split()

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

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

Solution (Python):
import math
a, b = input().split()
a = int(a)
b = int(round(float(b),3)*1000)

print((a*b)//1000)

Solution (Python):
import numpy as np
A,B = map(np.float128,input().split())
print(int(A*B))

Solution (Python):
import math
from decimal import *

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

print(math.floor(ans))

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

a,b = input().split()
a = int(a)
b = list(b)
c = ''
for i in range(4):
    if i != 1:
        c += b[i]
b = int(c)



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

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

answer = Decimal(A) * Decimal(B)

answer = int(answer)
print(answer)

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

a = int(a)
b_unchi = b.split(".")
b_int = int(b_unchi[0])
b_float = int(b_unchi[1])
bbb = b_int * 100 + b_float
s = a * bbb
print(s // 100)

Solution (Python):
def main():
    import sys
    import math
    import numpy as np

    a,b = map(str, input().split())
    a = [int(i) for i in a]
    a += [0]*2
    a = np.array(a)
    b = b.replace('.','')
    b = [int(i) for i in b]
    ans = a*b[0]
    ans[1:] += a[:-1]*b[1]
    ans[2:] += a[:-2]*b[2]
    from functools import reduce
    l = reduce(lambda a,b:10*a+b, ans)
    print(l//100)
    

if __name__ == '__main__':
    main()

Solution (Python):
import math
import numpy as np
a,b=map(np.longdouble,input().split())
c=int(a)*b
print(int(c))

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

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


def floor(a,b):
    return a//b


def main():
    _in = [_.rstrip() for _ in stdin.readlines()]
    A, B = _in[0].split(' ')  
    
    A = Decimal(A)
    B = Decimal(B)
    cnt = A * B
    cnt = int(floor(cnt, 1))
    
    print(cnt)


if __name__ == "__main__":
    main()

Solution (Python):
import decimal

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

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

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

print(math.floor(a*b))

Solution (Python):
from decimal import Decimal

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

ans = a*b

print(int(ans))

Solution (Python):
import math

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

B = sei*100 + syou


ans = (A*B) // 100 




print(ans)

Solution (Python):


from decimal import *


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

if (a == 0) or (b == 0):
    output = 0
else:
    s = str(a*b)
    try:
        output = s[:s.index('.')]
    except:
        output = s

print(output)

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

Solution (Python):
import math
from decimal import Decimal

x = input().split()
a_ = x[0]
b = Decimal(x[1])

if len(a_)<=8:
    a = Decimal(a_)
    print(int(math.floor(a*b)))
else:
    a_div = (Decimal(a_)/(10**9))
    b_mul = b*100
    print(int(math.floor(a_div*b_mul*10**7)))

Solution (Python):
from math import ceil, floor, modf

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

B1 = int(B[:-3])
B2 = int(str(B)[-2:])

ans1 = A * B1
ans2 = A * B2 // 100

ans = ans1 + ans2
print(floor(ans))

Solution (Python):



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


a = int(a)
b = int(b[:1]+b[2:])
ans = (a * b) // 100
print(ans)

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

Solution (Python):
a, b = map(float, input().split())
a = int(a)
b = str(b)
s = int(b[0])*100
s += int(b[2])*10
try:
    s += int(b[3])*1
except:
    pass

ans = a*s
ans = str(ans)
check = len(ans)

if check < 3:
    print(0)
else:
    print(ans[0:-2])

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

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


from decimal import*
A=Decimal(str(a))
AA=A.quantize(Decimal('0'),rounding=ROUND_FLOOR)
B=Decimal(str(b))
BB=B.quantize(Decimal('0.01'),rounding=ROUND_FLOOR)


K=AA*BB
KK=K.quantize(Decimal('0'),rounding=ROUND_FLOOR)
print(KK)

Solution (Python):
import math
a, b = map(str,input().split())
b = b.replace('.','')

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


ans = ans//10000
print(ans)

Solution (Python):
def main():
    N = [str(_) for _ in input().split()]
    A = int(N[0])
    B = N[1]

    BB = B.split('.')
    result = A * int(BB[0])
    s = (A * int(BB[1][0]) * 10) + (A * int(BB[1][1]))
    
    result = result * 100 + s
    r = str(result)
    if len(r) <= 2:
        print(0)
    else:
        print(r[0:len(r)-2])

if __name__ == "__main__":
    main()

Solution (Python):
import decimal
import math

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

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

Solution (Python):
import math
import decimal

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

c=a*b
c=math.floor(c)
c=int(c)

print(c)

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

A = Decimal(A)


B = Decimal(B)

print(int(A * B))

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

from decimal import Decimal

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

Solution (Python):
from sys import stdin

[a, b] = stdin.readline().split()
b = round(float(b) * 100)
print(int(a) * b // 100)

Solution (Python):
import math
from decimal import *
s = input().split()
A = Decimal(s[0])
B = Decimal(s[1])
c = math.floor(A * B)
print(c)

Solution (Python):
import sys
import numpy as np
import math
from collections import deque 
from functools import reduce
from decimal import Decimal


a, b = input().split()

a_d = Decimal(a)
b_d = Decimal(b)
print(int(a_d*b_d))

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

Solution (Python):
from decimal import Decimal

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

Solution (Python):
from decimal import Decimal

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

print(int(a * b))

Solution (Python):
import math
import decimal

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

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

print(int(a*b))

Solution (Python):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
import decimal

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

Solution (Python):
import decimal

a, b = [ v for v in input().split() ]
c = decimal.Decimal(a)
d = decimal.Decimal(b)
ans = c * d
ans = ans.quantize(decimal.Decimal("0"), rounding = decimal.ROUND_DOWN)
print(ans)

Solution (Python):
import math
import decimal

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

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


print(int(a*b))

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

Solution (Python):
import decimal

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



if __name__ == '__main__':
    main()

Solution (Python):
import sys


def _sa(): return sys.stdin.readline().strip().split()


def main():
    a, b = _sa()
    a = int(a)
    b = round(100*float(b))
    return (a * b) // 100


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

Solution (Python):
import decimal
import sys
sys.setrecursionlimit(10**9)

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




if __name__ == "__main__":
  main()

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

print(a*b//100)

Solution (Python):
import os
import sys
from io import BytesIO, IOBase


def main():
    a,b = input().rstrip().split()
    b = int(b[:-3]+b[-2:])
    a = int(a)
    res = str(a* b)
    if len(res) <= 2:
        print(0)
        return
    res = int(res[:-2])
    print(res)






BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

Solution (Python):
import math
a,b = map(str,input().split())
a = int(a)
new_b = ""
for i in b:
    if "." != i:
        new_b += i
ans = a*int(new_b)
s = str(ans)
s_len = len(s)
if s_len >= 3:
    print(s[0:s_len - 2])
else:
    print(0)

Solution (Python):
from math import floor, ceil
import decimal


def main():

    A, B = map(float, input().split())
    B = round(B, 2)
    A = int(A)
    A = decimal.Decimal(str(A))
    B = decimal.Decimal(str(B))
    AB = A*B
    AB = floor(AB)
    print(AB)


if __name__ == '__main__':
    main()

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

Solution (Python):
import math

b=input().split()
b1=int(b[0])

a=b1*(int(b[1][0])*100+int(b[1][2])*10+int(b[1][3]))

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

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

Solution (Python):
import math
import decimal

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




B *= 100

B = int(B)




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

Solution (Python):
import math
a, b = map(str, input().split())
if(b[0] == "0"):
  if b[2] == "0":
    b_m = b[3]
  else:
    b_m = b[2:]
else:
  b_m = b.replace('.', '')

res = int(a) * int(b_m)

if res >= 100:
  res_int = int(str(res)[:-2])
else:
  res_int = 0
print(res_int)

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

main()

Solution (Python):
a,b = map(str,input().split())
c,d = map(str,b.split('.'))
ans = int(a) * int(c)
tmp = str(int(a) * int(d))
ans2 = tmp[:len(tmp)-len(d)]
print(ans if ans2 == '' else ans+int(ans2))

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

Solution (Python):
from decimal import *

a, b = input().split()

ab = Decimal(a) * Decimal(b)
result = Decimal(str(ab)).quantize(Decimal(str(1)), rounding=ROUND_DOWN)

print(int(result))

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

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

input_list = input().split()
A = int(input_list[0])
B = input_list[1]
final_B = Decimal(B)
print(math.floor(final_B * A))

Solution (Python):
import decimal

A = input().split()
a = decimal.Decimal(A[0])
b = decimal.Decimal(A[1])
print(int(a*b))

Solution (Python):
import math
from decimal import Decimal

def abc169_c():
    sin = input().split()
    A = int(sin[0])
    B = math.floor(Decimal(sin[1]) * 100)
    ans = A * B // 100
    print(ans)

abc169_c()

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

Solution (Python):
from decimal import Decimal, ROUND_DOWN, getcontext
a, b = map(str, input().split())
getcontext().prec = 19
getcontext().rounding = ROUND_DOWN
x = Decimal(a)
y = Decimal(b)
print("{:}".format(Decimal(int(x * y)), rounding=ROUND_DOWN))

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

a,b = stdin.readline().rstrip().split()
a = Decimal(a)
b = Decimal(b)

print(math.floor(a*b))

Solution (Python):
a,b = map(float,input().split())
aa = int(a) % 10000000
a = int(a) // 10000000
c = round(b*int(a)*100)
cc = round(b*int(aa)*100)
cc /= 100
cc = int(cc)
print(c*100000 + cc)

Solution (Python):
from decimal import Decimal

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

Solution (Python):
from decimal import *

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

print(int(ans))

Solution (Python):
from decimal import *
A,B = [Decimal(i) for i in input().split()]
print(A*B//1)

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

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

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

A = int(s[0])
B = int(s[1].replace(".", ""))
m = A*B

if m>=100:
  result = int(str(m)[:-2])
else:
  result = 0
  
print(result)

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

ans = A*B

print(math.floor(ans))

Solution (Python):
import decimal

from math import floor

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

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