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
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(str, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]




import math
from decimal import Decimal

A, B = mi()
A = Decimal(A)
B = Decimal(B)
print(A * B//1)

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

Solution (Python):

from decimal import *

import math
A, B = map(str, input().split())
ans = Decimal(A) * Decimal(B)
ans = math.floor(ans)
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):
from decimal import Decimal
a, b = map(str, input().split())
a = Decimal(a)
b = Decimal(b)

print(int(a*b))

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

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

Solution (Python):
import decimal
import math


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

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

b_sp = b.split('.')
b_seisu = int(b_sp[0])
b_shosu = 0
if(len(b_sp) > 1):
    b_shosu = int(b_sp[1])



mul = int(a)*(100*b_seisu + b_shosu)
mul_seisu = mul//100
print(mul_seisu)

Solution (Python):
import sys, io, os, re
import bisect
from pprint import pprint
from math import sin, cos, pi, radians, sqrt, floor
from copy import copy, deepcopy
from collections import deque
from fractions import gcd
from functools import reduce

def array1(n): return [0] * n
def array2(n, m): return [[0] * m for x in range(n)]
def array3(n, m, l): return [[[0] * l for y in xrange(m)] for x in xrange(n)]

arr = list(sys.stdin.readline().strip().split())
arr[0] = int(arr[0])
arr[1] = int(arr[1][0])*100+int(arr[1][2])*10+int(arr[1][3])

print((arr[0]*arr[1])//100)

Solution (Python):

import sys
from decimal import Decimal

input = sys.stdin.readline


def S():
    return input().rstrip()


def I():
    return int(input())


def MI():
    return map(float, input().split())


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

print(int(a * b))

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
a,b = map(str,input().split())
a = int(a)
bint,bdec = b.split('.')
bint = int(bint)
bdec = int(bdec)
ans = a*bint+(a*bdec//100)
print(ans)

Solution (Python):
from decimal import Decimal, ROUND_FLOOR

a, b = input().split()
x = Decimal(a)
y = Decimal(b)
seki = x*y
print(seki.quantize(Decimal("0"), rounding=ROUND_FLOOR))

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

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

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

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


a = int(x[0])

b1 = int(x[1][0])
b2 = int(x[1][2:])

ans = a*b1+(a*b2//100)

print(ans)

Solution (Python):

from decimal import Decimal
import math

A, B = input().split()

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

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

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

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


print(floor(a * b))

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

print(math.floor(a*b))

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

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(float(b) * 1000)
 
print((a*b)//1000)

Solution (Python):
from decimal import Decimal

A, B = input().split()

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

print(int(A * B))

Solution (Python):
from decimal import Decimal

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

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

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

Solution (Python):
ab = input()
ablist = ab.split(' ')
a = int(ablist[0])
blist = ablist[1].split('.')
b1 = int(blist[0])
b2 = int(blist[1])
ab1 = a * b1
ab2 = (a*b2) // 100 
result = ab1 + ab2
print(int(result))

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

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

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

Solution (Python):
from decimal import *

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

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

Solution (Python):
from decimal import *
n,m=input().split()
n=Decimal(n)
m=Decimal(m)
n*=m
print(Decimal(n).quantize(Decimal('1.'), rounding=ROUND_DOWN))

Solution (Python):
from decimal import Decimal
Ans = 0
AB = input().split()
A,B = int(AB[0]), Decimal(AB[1])
IB = int(B * 100)


Ans = A * IB // 100
print(Ans)

Solution (Python):
import decimal

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

mul = decimal.Decimal(a) * decimal.Decimal(b)
print(int(mul))

Solution (Python):
import math
S = input().split()
A = int(S[0])
B = S[1]
B = B.rsplit(".")
B0 = B[0]
B1 = B[1]
B = int(B0)*100+int(B1)
ans = "000"+str(A*B)
n = len(ans)



print(int(ans[:n-2]))

Solution (Python):

import math
from decimal import Decimal


def inp():
    return(int(input()))



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



def instr():
    s = input()
    return(list(s[:len(s)]))



def invr():
    return(map(Decimal, input().split()))


a, b = invr()


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

Solution (Python):
l = input().split()
s2 = l[1].split('.')
a = int(l[0])
b = int(s2[0]) * 100 + int(s2[1])
prod = (a * b) // 100

print(prod)

Solution (Python):
import itertools
import math
import fractions
import functools
import copy
from collections import deque
from functools import reduce
from decimal import Decimal

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

Solution (Python):
import sys
from decimal import Decimal

def solve():
    input = sys.stdin.readline
    A, B = map(str, input().split())
    ans = str(Decimal(A) * Decimal(B))
    N = len(ans)
    print(ans[:N-3])

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):
from decimal import *
import math

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

Solution (Python):
import numpy
A, B = input().split()
A = int(A)
B = int(numpy.round(float(B) * 100))
print(A * B // 100)

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

Solution (Python):
import math
from decimal import Decimal

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

Solution (Python):
import sys


MODE = 1


DIMENSION = 1


INT_TYPE = 0

if not (MODE):
    with open("input.txt", "r") as f:
        s = f.read()
else:
    s = sys.stdin.read()

if DIMENSION == 0:
    if INT_TYPE == 1:
        s = int(s)
elif DIMENSION == 1:
    if INT_TYPE == 0:
        s = s.split()
    elif INT_TYPE == 1:
        s = [int(x) for x in s.split()]
elif DIMENSION == 2:
    if INT_TYPE == 0:
        s = [x.split() for x in s.splitlines()]
    elif INT_TYPE == 1:
        s = [[int(y) for y in x.split()] for x in s.splitlines()]

A = int(s[0])
B = s[1].split(".")
if len(B) == 1:
    B_x = int(B[0])
    print(A * B_x)
else:
    B_x = int(B[0])
    B_y = int(B[1])
    print(A * B_x + A * B_y // 100)

Solution (Python):


def readinput():
    
    a,b=input().split()
    a=int(a)
    b=float(b+'000000000000000')
    return a,b

def main(a,b):
    
    b=int(b*1000)
    ans=a*b//1000
    return ans

if __name__=='__main__':
    a,b=readinput()
    ans=main(a,b)
    print(ans)

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

Solution (Python):
import decimal
from decimal import Decimal

a, b = input().split()
a = Decimal(a)
b = Decimal(b)
c = a*b
print(c.quantize(decimal.Decimal("0"), rounding=decimal.ROUND_FLOOR))

Solution (Python):
import decimal

l = [x for x in input().split()]
x = decimal.Decimal(l[0]) * decimal.Decimal(l[1])
val_floor_d = x.quantize(decimal.Decimal('0'), rounding=decimal.ROUND_FLOOR)
print(int(x))

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

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

print(int(A*B))

Solution (Python):
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left
from functools import reduce

def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_list(N): return [s_list() for _ in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
from decimal import *

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

    

    print(floor(a*b))
            
if __name__ == '__main__':
    main()

Solution (Python):
from decimal import Decimal, ROUND_DOWN


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

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

Solution (Python):
import math
from decimal import Decimal

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

print(math.trunc(A*B))

Solution (Python):
from decimal import *
import math 

a, b = input().split()

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

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

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

Solution (Python):
from decimal import Decimal

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

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

Solution (Python):
a, b = input().split()
a = int(a)
b = b.split('.')
if len(b) == 1:
    ans = a * int(b[0])
elif len(b[-1]) == 1:
    ans = a * (10 * int(b[0]) + int(b[1])) // 10
else:
    ans = a * (100 * int(b[0]) + int(b[1])) // 100
print(ans)

Solution (Python):

import decimal

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

Solution (Python):
import math
from decimal import *

getcontext().prec = 20

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

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

Solution (Python):
import math
import decimal

a,b = map(str,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 *

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

print(int(t))

Solution (Python):

a, b = map(str, input().split())
b = b.replace(".", "")
a = int(a)
b = int(b)
print(a*b//100)

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

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

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

A2=int(round(float(B)*100,0))

C=Fraction(A2,100)
D=int(A)*C
print(int(D))

Solution (Python):
import decimal

x,y = map(str,input().split())
a=decimal.Decimal(x)
b=decimal.Decimal(y)
z=a*b
z=int(z)
print(z)

Solution (Python):
from decimal import Decimal

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

ans = A * B

print(int(ans))

Solution (Python):
def resolve():
    li = input().split()
    A = int(li[0])
    B = int(li[1].replace('.',''))
    ans = int(A*B//100)
    print(ans)
resolve()

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

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

Solution (Python):
import numpy as np


def main(A, B):

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


A, B = map(float, input().split())
A=int(A+0.01)
B*=100
B=int(B+0.01)
print(main(A, B))

Solution (Python):
import decimal

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

an = a*b






ans = "" 
for i in str(an):
    if i == ".":
        break
    ans += i

print(ans)

Solution (Python):
def resolve():
    a,b = input().split()
    a = int(a)
    c = int(b.replace('.', ''))
    d = str(a * c)
    if len(d) < 3:
        d = '0' * (3 - len(d)) + d
    if b.find('.') == -1:
        print(d)
    else:
        l = len(b) - b.find('.') - 1
        print(d[:-l])


if __name__ == "__main__":
    resolve()

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

b1,b2 = int(b[:-3]), Decimal("0" + b[-3:])
print(int(a)*b1+int(Decimal(a)*b2))

Solution (Python):
from collections import Counter 
from collections import defaultdict
from collections import deque
from functools import reduce
import math
import itertools
import heapq
import numpy as np
import bisect
import sys
sys.setrecursionlimit(10**6)


def bfs(s,n,node):
    
    check=[False for _ in range(n)]
    check[s]=True
    
    queue=deque([s])
    visited_num=1

    
    
    color=[-1 for _ in range(n)]
    color[s]=0
    
    while visited_num<n:
        
        if len(queue)==0:
            
            
            return color

        now_vertex=queue.popleft()
        
        for next_vertex in node[now_vertex]:


            if check[next_vertex]==True:
                continue

            queue.append(next_vertex)
            check[next_vertex]=True

            
            color[next_vertex]=color[now_vertex]+1
            visited_num+=1

    return color




ceil=lambda x,y: (x+y-1)//y
input_list = lambda : list(map(int,input().split()))






a=input().split()
n=int(a[0])
m=a[1]
ans=0
ans+=n*int(m[0])
ans+=n*int(m[2])//10
ans+=n*int(m[3])//100
mod=0
tmp=int(str(n*int(m[2]))[-1])
if tmp<10:
    tmp*=10
mod+=tmp

tmp=int(str(n*int(m[3]))[-2:])
mod+=tmp


print(ans+mod//100)

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


from decimal import *
import math

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

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

Solution (Python):
import sys
from decimal import *
import math
def input(): return sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
sys.setrecursionlimit(4100000)

import math

import logging

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)

from decimal import *


def resolve():
    
    
    A, B = [Decimal(x) for x in sys.stdin.readline().split()]  
    

    
    
    
    

    logger.debug('{}'.format([A, B]))

    B = B * 100

    logger.debug('{}'.format([A, B]))

    c = int(A * B)

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


if __name__ == "__main__":
    resolve()





import sys
from io import StringIO
import unittest


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)

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

B_int=int(B[0])
B_point=int(B[1])

print(A*B_int+(A*B_point)//100)

Solution (Python):
a, b = input().split()
a = int(a)
b_i = int(b[:-3])
b_f = int(b[-2:])
if b_f == 0:
  print(a*b_i)
  exit()
b_m = a*b_f
if b_m < 100:
  print(a*b_i)
  exit()
print(a*b_i + int(str(b_m)[:-2]))

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

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

print(math.floor(int(a)*round(Decimal(b),2)))

Solution (Python):
from decimal import Decimal
import math

a,b = input().split()

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

ans = a * b

print(math.floor(ans))

Solution (Python):
from decimal import Decimal
a, b = map(str, input().split())
a = Decimal(a)
b = Decimal(b)
ab = str(a*b).split(".")
print(ab[0])

Solution (Python):
import math
from decimal import Decimal

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

print(math.trunc(A*B))

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 = input().split()
A = Decimal(A)
B = Decimal(B)
A = int(A)
print(int(A * B))

Solution (Python):
import numpy as np

a, b = input().split()
a = int(a)
b = np.array([b], dtype='float128')

print(int(np.floor(a * b[0])))

Solution (Python):
S = list(map(str,input().split()))
from decimal import Decimal
A = Decimal(S[0])
B = Decimal(S[1])
C = A * B
print(int(C))

Solution (Python):
from decimal import Decimal
import math

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

print(math.floor(A*B))

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

b1, b2 = map(str, b.split("."))
d = len(b2)

ans = int(a) * int(b1 + b2) // 10**d
print(ans)

Solution (Python):
from decimal import *

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

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

print(ans)

Solution (Python):
import decimal
A,B=map(decimal.Decimal,input().split())
multi=A*B
multi_floor = multi.quantize(decimal.Decimal('0'),rounding=decimal.ROUND_FLOOR)
print(multi_floor)

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

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

Solution (Python):
a, b = input().split()
a = int(a)
t = b.split(sep='.')
b = int(t[0]) * 100 + int(t[1])

print(a * b // 100)

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

Solution (Python):


A, B = input().split()
A = int(A)
B = B.replace('.', '')
B = int(B)
ans = A*B
ans = str(ans)




result = ans[0:-2]
if result == "":
    result = "0"
print(result)

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

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
from collections import defaultdict
import math

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

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

if __name__ == '__main__':
    main()

Solution (Python):
from decimal import Decimal, ROUND_DOWN

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

Solution (Python):
import math
A,B = input().split()
A = int(A)
C1 = A*int(B[0])*100
C2 = A*int(B[2])*10
C3 = A*int(B[3])
Ans = C1+C2+C3
Ans = math.floor(Ans//100)
print(Ans)

Solution (Python):
from decimal import *

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

Solution (Python):
import math
import decimal

i = list(map(decimal.Decimal, input().split()))
A = int(i[0])
B = i[1]

print(math.floor(A * B))

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

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

b *= 100
a = int(a)
b = int(b)
if list(str(int(a * b)))[:-2]:
    [sys.stdout.write(i) for i in list(str(int(a * b)))[:-2]]
    print("")
else:
    print(0)

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

print(int(A * B))

Solution (Python):
import math
from decimal import Decimal

def main():
    A, B = input().split()
    ans = Decimal(A) * Decimal(B)
    print(math.floor(ans))



if __name__ == "__main__":
    main()

Solution (Python):
from decimal import Decimal

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

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

Solution (Python):
import decimal

init =input().split(' ')

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

multi = a * b

result = int(multi // 1)

print(result)

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    A, B = input().rstrip().split()
    A = int(A)
    ans = 0
    ans += A*int(B[0])*100
    ans += A*int(B[2])*10
    ans += A*int(B[3])
    print(ans//100)


if __name__ == '__main__':
    main()

Solution (Python):
import math
from decimal import *
getcontext().prec = 40
x,y = map(str,input().split()) 
X = Decimal(int(x))
Y = Decimal(y)
z = math.floor(X*Y)
print(int(z))

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

Solution (Python):
def main():
    A, B = input().split()
    a = int(A)
    b = int(B.replace('.', ''))
    str_ans = str(a*b)
    if a*b < 100:
        print('0')
    else:
        print(str_ans[:-2])


if __name__ == '__main__':
    main()

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


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


if __name__ == '__main__':
    main()

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

a=int(a)
b=int(float(b)*100+0.1)

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

print(c)

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

Solution (Python):
from decimal import Decimal

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

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

Solution (Python):
A, B = input().split()
A = int(A)
B = B.replace('.', '')
while len(B) < 3:
    B += '0'
B = int(B)

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

Solution (Python):
from decimal import *
a, b = map(Decimal, input().split())
print(Decimal(a*b).quantize(Decimal("1"), rounding=ROUND_DOWN))

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

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

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

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

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


print(int(ans))

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

Solution (Python):
import math

def main():
  a, b = input().split()
  a = int(a)
  b = b[0] + b[2]+ b[3]
  c = int(b)
  ans = a * c // 100
  ans = math.floor(ans)
  print(ans)
 
 
if __name__ == '__main__':
  main()

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

from decimal import *

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

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

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

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

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


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

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

Solution (Python):
a, b = input().split()
keta = len(b) - b.find(".") - 1
a_n = int(a)
b_n = int(b.replace(".", ""))
ans = a_n * b_n
ans_s = str(ans)
if len(ans_s) < keta + 1:
    print(0)
else:
    print(ans_s[:-keta])

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

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

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

s=str(Decimal(A*B))
print(Decimal(s).quantize(Decimal("0"),rounding=ROUND_DOWN))

Solution (Python):
import sys
import copy
from collections import deque
stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  
sa, sb = ns().split()

tb = ''.join(sb.split("."))

a = int(sa)
b = int(tb)

print(a*b//100)

Solution (Python):
import sys
def LS(): return list(sys.stdin.readline().rstrip().split())
A,B = LS()
B = B.replace('.','')
A,B = int(A),int(B)
print(A*B//100)

Solution (Python):

import math
import sys


def solve(A: int, B: int):
    r = str(A*B)
    if len(r) > 3:
        print(r[:len(r)-2])
    else:
        print(0)
    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 = next(tokens)
    startWithZero = True
    everyZero =True
    l = 0
    bstr = ""
    for c in B:
        if c==".":
            continue
        if c == "0":
            l += 1
            if startWithZero:
                pass
            else:
                bstr += "0"
        else:
            everyZero = False
            l += 1
            startWithZero = False
            bstr += c
    for i in range(3-l):
        bstr+= "0"
    if everyZero:
        print(0)
        exit()
    solve(A, int(bstr))

if __name__ == '__main__':
    main()

Solution (Python):

import decimal
a, b = input().split()

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

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

Solution (Python):




import sys
input = sys.stdin.readline



def main():
    A,B = map(str,input().split())

    A = int(A)
    B100 = int(B[0]) * 100 + int(B[2:])

    res = A * B100 // 100

    print(res)



main()

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

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

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

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

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


print(int(A*B))

Solution (Python):
from decimal import *
n, m = input().split()
root2 = Decimal(n) * Decimal(m)
n = 0
y = Decimal(str(root2)).quantize(Decimal(str(10**(n*-1))), rounding=ROUND_DOWN)
print(y)

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

A = int(A)
B = int(B * 1000)

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

Solution (Python):
A, B = input().split()
A = int(A)
Ba, Bb = B.split('.')
B = 100 * int(Ba) + int(Bb)
m = A * B
print(m // 100)

Solution (Python):
import math

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








B_fix = int(round(B*100))
B_sei, B_sho = divmod(B_fix,100)
B_sho1, B_sho2 = divmod(B_sho, 10)



ans = 100 * A * B_sei + 10 * A * B_sho1 + 1 * A * B_sho2

ans = ans // 100

print(ans)

Solution (Python):
A,B = input().split()
a = int(A)
b1 = int(B[0])*100
b2 = int(B[2])*10
b3 = int(B[3])

answer = a*(b1+b2+b3) // 100
print(answer)

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

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

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

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

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

Solution (Python):
from decimal import Decimal


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

    print(int(A*B))


if __name__ == "__main__":
    main()

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

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

print(math.floor(a * b))

Solution (Python):
from decimal import *

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

print(int(ans))

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