peterverebics/CodeNet_Python_118 huggingface dataset:
import math
import sys
import bisect
readline = sys.stdin.readline


def main():
    a, b = map(float, readline().rstrip().split())
    a = int(a)
    b = round(b * 100)
    print((a * b) // 100)


if __name__ == '__main__':
    main()
a, b = input().split()
b = int(b[0] + b[2:])
print(str(int(a) * b)[0:-2] or 0)
from decimal import Decimal

A, B = map(Decimal, input().split())
print(str(A*B)[:-3])
import sys
from decimal import Decimal

num_list = input().split()
ans = Decimal(num_list[0]) * Decimal(num_list[1])
print(int(ans))
A, B = map(float, input().split())

A = int(A)
B = round(B*100)

print(A*B//100)
a,b = input().split()
from decimal import Decimal
a = int(a)
b = Decimal(b)
print(int(a*b))
# C - Multiplication 3
from decimal import Decimal


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


if __name__ == "__main__":
    main()
A, B = input().split()
A = int(A)
B = int(B.replace('.',''))
print(A*B//100)
#dt = {} for i in x: dt[i] = dt.get(i,0)+1
ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]

a,b = input().split()
a = int(a)
b = list(b.split("."))
b = ''.join(b)
b = int(b)
print(a*b//100)
from decimal import Decimal
a, b = list(map(Decimal, input().split()))
print(int(a*b))
a, b = input().split()
a = int(a)
b_int, b_frac = b.split(".")
bb = int(b_int) * 100 + int(b_frac)
print(a * bb // 100)
a, b = input().split()

x = int(a)
y = round(100*float(b))

print(x * y // 100)
a, b = input().split()
a = int(a)
b = int(b.replace(".", ""))
ans = a * b // 100
print(ans)
import io,sys
sys.setrecursionlimit(10**6)

def main():
    s = sys.stdin.readline().rstrip().split()
    a = int(s[0])

    b = int(float(s[1])*100+0.1)

    print(a*b//100)
main()
from math import floor

a, b = map(float, input().split())
a = int(a)
b *= 100
b = round(b)
print(a*b//100)
from decimal import Decimal
import math

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

print(math.floor(A * B))
from decimal import *
li = list(map(str,input().split()))
print(int(Decimal(li[0]) * Decimal(li[1])))
from decimal import *

a, b = input().split()
ans = Decimal(a) * Decimal(b)
print(int(ans))
a,b = map(str,input().split())
a = int(a)
b = 100*int(b[0])+10*int(b[2])+int(b[3])
print(a*b//100)
#import bisect,collections,copy,heapq,itertools,math,numpy,string
#from operator import itemgetter
import sys
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())
A,B = LS()
for i,c in enumerate(B):
  if c == '.':
    break
res = str(int(A)*int(B[0:i]+B[i+1:]))
pos = len(res)-(len(B)-i-1)
if pos <= 0:
  print("0")
else:
	print(res[0:pos])
a, b = map(float, input().split())
a = int(a)
b = int(b*1000)
ans = a*b//1000
print(ans)
a, b = input().split()
a = int(a)
b = int(float(b) * 100 + 0.5)
print(a * b // 100)
sa, sb = input().split()
a = int(sa)
bi,bf = map(int,sb.split("."))
b = bi * 100 + bf
print((a*b)//100)
from decimal import *
A, B = map(str, input().split())
print(Decimal(A)*Decimal(B)//1)
a,b=map(str,input().split())
a=int(a)
c,d=map(int,b.split("."))
print(a*c+int(a*d//100))
import math
import numpy as np
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN


def main():
    a = list( map( float, input().split()))
    a1 = int(a[0])
    a2 = Decimal(str(a[1])).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN)
    s = a1*a2
    print(math.floor(s))
    
if __name__ == '__main__':
    main()
a, b = input().split()
a = int(a)
b = int(b[0] + b[2] + b[3])
print(a*b//100)
a,b = input().split()
a1 = int(a)
b1 = int(b[0] + b[2] + b[3])
print(a1*b1//100)
#c
a,b = input().split()

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

print(ans)
from decimal import Decimal

A, B = input().split()
ans = Decimal(A) * Decimal(B)
print(int(ans))
A,B=input().split()
a=int(A)
b=round(float(B)*100)
print(a*b//100)
A, B = input().split()

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

result = str(A * B)[:-2]
if len(result) > 0:
	print(result)
else:
	print(0)
a,b = input().split()
#print(a,b)
A = int(a)
x,y = b.split('.')
B = int(x)*100+int(y)

print(int(A*B)//100)
from decimal import Decimal
a, b = input().split()
a = int(a)
b = Decimal(b)
ans = int(a*b)
print(ans)
a,b = input().split()
a = int(a)
#print(b)
ans = a*int(b[0])
ans2 = a*int(b[2:])
#print(ans)
#print(ans2)
if len(str(ans2))>2:
    ans = ans + int(str(ans2)[:-2])
print(ans)
n, m =map(float,input().split()) 

n =int(n)
m =round( m *100)
ans = n * m // 100
print(round(ans))
from decimal import Decimal

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

print(int(Decimal(a) * Decimal(b)))
import math
l=input().split()
a,b=int(l[0]),round(float(l[1])*100)
ans = str(a*b)
if len(ans)<=2:
  print(0)
  exit()
print(ans[:-2])
a, b = input(). split()
a = int(a)
b = int(float(b)*100+0.5)
print(a*b//100)
A,B = input().split()
from decimal import *

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

print(int(A*B))
from decimal import Decimal
A,B=input().split()
print(int(Decimal(A)*Decimal(B)))
a,b=input().split()
print(int(a)*round(float(b)*100)//100)
from decimal import *

A, B = map(Decimal, input().split())
print(int(A * B))
# coding: utf-8


def main():
    a, b = map(str, input().split())
    # print(b)

    a = int(a)
    b = str(b)
    # print(b)
    if len(b) == 1:
        b = b[0] + "00"
    elif len(b) == 3:
        b = b[0] + b[2] + "0"
    else:
        b = b[0] + b[2] + b[3]
    # b = b[0] + b[2] + b[3]
    b = int(b)
    # print(b)
    # exit()
    
    return a*b // 100


print(main())
#!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
#%%code
from decimal import Decimal  as D
def resolve():
    A,B=input().split()
    a=D(A)
    b=D(B)
    print(int(a*b))
#%%submit!
resolve()
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)
a,b=input().split()
a=int(a)
b=int(b.replace('.',''))
print(a*b//100)
import sys
input = lambda: sys.stdin.readline().rstrip()
from decimal import Decimal

A, B = map(Decimal, input().split())
print(int(A*B))
a, b = input().split()
a = int(a)
b100 = int(b.replace('.', ''))
print(a*b100//100)
A,B=input().split()
A=int(A)
B=int(100*float(B)+0.1)
C=A*B
print(int(C))
a,b=input().split()
a=int(a)
b=float(b)
z=a*b//1
print(int(z))
import math
a,b = map(float, input().split()) 

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

a, b = list(map(float, input().split()))
print(math.floor(a * b))
import math
a, b = input().split()
c=int(a)
d=float(b)
print(math.floor(c*d))
a,b = map(float, input().split())
b100 = int(b*100)
ab = int(a*b100)
print(str(ab)[:-2])
A,B = (float(x) for x in input().split())
ans = A * B
print(int(ans))
import math
a,b = map(float,input().split())
c = a * b
ans = math.floor(c)
print(int(ans))
import math

A, B = list(input().split())
A = int(A)
B = '{:.2f}'.format(float(B)).replace('.', '')
B = int(B)

# A *= 100
# B = int(B * 100)


AB = A * B / 100
floored = int(math.floor(AB))
print(floored)

# AB = A * B
# AB = str(AB)
# AB = AB[0:-2]
# AB = 0 if AB == '' else AB
# print(AB)
import math
in_ = list(input().split())
A = int(in_[0])
B = int(float(in_[1]) * 100)
ans = A * B
ans = int(ans / 100)
print(ans)
A, B = map(str, input().split())
A = int(A)
B = float(B)
Ax = A // 100
Ay = A % 100
Bx = B // 1
By = int((B - Bx) * 100)
p = Ax * Bx * 100 + Ax * By + Ay * Bx
q = (Ay * By) // 100
print(int(p + q))
a,b = input().strip().split()
a,b = [int(a), float(b)]
c = a*b;
d = int(c)
print(d)
a, b = map(float, input().split())
c = a * b
print(int(c))
a,b = map(float, input().split())
c = b.as_integer_ratio()
d = int(c[0])
e = int(c[1])
print(int(a*d/e))
a, b = input().split()
a = int(a)
b = float(b)
b_int = int(b)
b_float = b - b_int
print(a * b_int + int(a * b_float))
A, B = map(float, input().split())
C = str(A * B)
if '.' in C:
    ans = C.split('.')
    print(ans[0])
else:
    print(C)
a,b = input().split()
c = float(a)*float(b)
d = str(c).split(".")[0]
print(int(d))
a,b=input().split()
a = int(a)
b = int(float(b)*100)
ans = a*b
from math import gcd
n = 100
g = gcd(ans,n)
while g != 1:
    ans //= g
    n //= g
    g = gcd(ans,n)
print(ans//n)
import math
A,B = list(map(float, input().split()))
print(int(A*int(B*100)/100))
a, b = map(float, input().split())
print(int(a*b))
lst = input().split()
a = int(lst[0])
b = float(lst[1])
if a == 0 or b == 0:
  print(0)
else:
  print(int(a*b))
Input = input().split()
A = Input[0]
A = float(A)
B = Input[1]
B = float(B)
AB = A*B
AB = int(AB)
print(AB)
a, b = map(float, input().split())
ans = int(a * b)
print(ans)
from decimal import Decimal
from math import floor

a, b = map(float, input().split())
res = Decimal(a) * Decimal(b)
print(floor(res))
import math
     
s = input().split()

s[1] = s[1].replace(".", "")
     
num = int(s[0]) * int(s[1])
     
print(math.floor(num/100))
A, B = map(float, input().split())
print(int(A*B))
a, b = map(float, input().split())
print(int(a * b))
#!/usr/bin/env python3
import collections
import itertools as it
import math
#import numpy as np
 
#  = input()
#  = int(input())
a, b  = map(float, input().split())
#  = list(map(int, input().split()))
#  = [int(input()) for i in range(N)]
#
# c = collections.Counter()

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

A = int(A)
B = float(B)

B *= 100

ans = A * B / 100

print(int(ans))
import math
A, B = map(float,input().split())

print(math.floor(A*B))
N,M = map(float,input().split())
import math
from decimal import *
print(math.floor(Decimal(N*M)))
from math import floor


def main():
    a, b = map(float, input().split())
    print(floor(a * b))


if __name__ == '__main__':
    main()
a,b=input().split()
a=int(a)
b=int(float(b)*100)
print(int(a*b/100))
a,b = map(float, input().split())
print(int(a*b))
il = input().split()

A = float(il[0])
B = float(il[1])

import math

print(math.floor(A*B))
a,b=map(float,input().split())
print(int(a*b//1))
A, B = map(str, input().split())
B = float(B)
A = int(A)
import math
a = A*B

a = math.floor(a)

print(a)
A,B=input().split()

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

C=int(A*B/100)

print(C)
# -*- coding: utf-8 -*-
import math

i = list(input().split())
print(math.floor(int(i[0])*float(i[1])))
A,B=map(float,input().split())
print(int(A*int(B*100))//100)
import numpy as np
import sys
a,b=input().split()
a=float(a)/10000;
b=float(b)*10000;
print(int(float(a)*float(b)))
import math
A,B = input().split()
a = int(A)
b = float(B)
print(int(a*b))
def default():
    a=input()
    a=a.split()
    a[0]=int(a[0])
    a[1]=float(a[1])
    a[1]=int(a[1]*a[0])
    print(a[1])
if(__name__=="__main__"):
    default()
import math
import numpy as np
# math.floor

X = list(input().split())
A = int(X[0])
B = float(X[1])

# s = str(A*B)

ans = (A*int(B*100))//100
print(ans)
from decimal import Decimal

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

print(a*b)
import math
val = list(input().split())
ans = float(val[0]) * float(val[1])

print(int(ans))
s=input().split()
a=int(s[0])
b=float(s[1])
print(a*int(b*100)//100)
a, b = map(float, input().split())

b = int(b*100)

print(int(a*b//100))
a,b=map(float, input().split())
b=100*b
b=b//100
print(a*b)
import math
A,B=input().split()
ans=int(A)*float(B)
print(math.floor(ans))
a,b=map(float, input().split())
ans=(a*b)//1
print(int(ans))
inputs = list(map(float, input().split()))

multiple = inputs[0] * inputs[1]

multiple_str = str(multiple)
if '.' in multiple_str:
    print(multiple_str.split('.')[0])
else:
    print(multiple_str)
a,b=open(0).read().split()
a=int(a)
b=int(float(b)*100)
print(a*b//100)
A, B = input().split()
A = int(A)
B = float(B)
print(int(A*B))
from sys import stdin
input = stdin.readline


def main():
  A, B = input().split()
  A = int(A)
  B = int(100*float(B))

  print((A*B)//100)


if(__name__ == '__main__'):
  main()
a, b = map(float, input().split())
b = int(b*100)
a = int(a)

print(int((a*b)//100))
a,b = input().split()
a = int(a)
b = float(b)*100
ans = a*b // 100
print(int(ans))
import sys
A,B=map(float, sys.stdin.readline().split())
print int(A*B)
import math

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

print(math.floor(a * b))
import math
import numpy as np

def main():
    a = list( map( float, input().split()))
    #print(format(a[0], '.20f'))
    a1 = int(a[0])
    a2 = int(round(a[1],3)*100)
    #print(format(a[1], '.20f'))
    #print(format(a2, '.20f'))
    s = a1*a2/100
    #print(format(s, '.20f'))
    print(math.floor(s))
    
if __name__ == '__main__':
    main()
def main():
    a, b = map(float, input().split())
    zajedno = a*b
    print(int(zajedno))


if __name__ == '__main__':
    main()
a,b = input().split()
a1 = int(a)
bs = list(b)
b1 = int(bs[0])
b2 = 0
if len(b)==3:
  b2 = int(bs[2])*10
else:
  b2 = int(bs[2]+bs[3])
b1 = b1*100+b2
ans = int(a1*b1/100)
print(ans)
import math

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

print(math.floor(a * b))
import numpy as np
A,B = input().split()
B = float(B)

A = int(A)

B = int(B*100)
ans = str(np.dot(A,B))
if len(ans) <=2:
    print(0)
else:
    print(ans[:-2])
A, B = map(float, input().split())

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

x = A*B/100

ans = int(x)

print(ans)
import sys
input = sys.stdin.readline
#n = int(input())
#l = list(map(int, input().split()))
'''
A=[]
B=[]
for i in range():
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)'''
import math
ab=input().split()
a=int(ab[0])
b=int(float(ab[1])*100)
#print(b)
print(a*b//100)
n , m = map (float,input().split())
s = n * m
print(int(s))
import math
a = 0.0
b = 0.0
a,b = map(float,input().split())
print(
math.floor(a*b)
)
import math
A, B = map(float, input().split())
print(math.floor(A * B))
nums = input().split()
a = int(nums[0])
b = float(nums[1])

print(int(a*b))
from math import floor
a, b = map(float, input().split())
ans = floor(a * b)
print(ans)
a, b = map(float, input().split())
a = int(a)
from decimal import Decimal
from fractions import Fraction
import math
dc_b = Decimal.from_float(b)
print(math.floor(dc_b*a))
from sys import stdin
A,B = [float(x) for x in stdin.readline().rstrip().split()]
print(int(A*B))
a, b = map(float, input().split())
a = int(a)
b1 = int(b * 100)
print(int((a*b1)//100))
from math import floor
print(eval('floor(int('+input().replace(' ',')*float(')+'))'))
import math
a, b = map(float,input().split())
ans = int(a * (100*b))
print(math.floor(ans/100))
import math
a, b = map(float, input().split())
print(math.floor(a*b))
from math import floor
a,b = [e for e in input().split(" ")]
a = int(a)
b = round(float(b),2)
r = a*b
print(floor(r))
from decimal import *
a,b=map(float, input().split(" "))
b *= 100
print((int)(a*b)/100+0.001)
A, B = map(float,input().split(' '))
print(int((A*B)//1))
A, B = map(float,input().split())
print(int(A*B))
A, B = map(float, input().split())
mul = A * B
print(int(mul))
a, b = input().split()
a = int(a)
b = float(b)

print(int(a*b))
import math
A, B = map(float, input().split())
from decimal import Decimal
from decimal import *  


A = Decimal(A)
B = Decimal(B)
# print(A, B)
C = A*B
# print(C)
print(math.floor(C))

exit()
A, B=input().split()
B=float(B)
B="%.2f" % round(B, 2)
re=int(A)*float(B)
print (int(re//1))
import math
a, b = map(float, input().split())
w = a * b
ans = math.floor(w)
print(ans)
import math
A, B = map(float, input().split(" "))
print(math.floor(A*B))
import decimal
decimal.getcontext().prec = 5
S = input().split()
A = int(S[0])
B = float(S[1])

B = decimal.Decimal(B)

print(int((A*B)/1))
a, b = input().strip().split()
a, b = [int(a), float(b) * 1000]
x = (a * b) // 1000
print(int(x))
import sys
#sys.exit()
#sorted( ,reverse=True)
#N = int(input())
A,B = map(str, input().split())
A = int(A)
B = B.replace('.','')
B = int(B)
#A = list(map(int, input().split()))
#A = [int(input()) for _ in range(N)]
C = A * B / 100
#cnt = 0
#cnt += 1



#print(N)
#print(A,B)
#print(A*B)
#print(A*B/100)
#print(C)
#print(A)
#print('Yes')
#print('No')
print(int(C))
import math
a,b = list(map(float, input().split()))
b2 = int(b * 100)
Ans1 = a * b2 / 100
Ans = math.floor(a * b) 
print(Ans)
import math


AB = list(map(float, input().split()))
A = int(AB[0])
B = AB[1]

result = A * B
print(math.floor(result))
a,b=map(float,input().split())
print(int(a*(int(b*100))/100))
import math
#from decimal import *
a,b = map(float, input().split())
int(a)
b = b*100
int(b)
#b_i = float(b - math.floor(b))
#print(b_i)
ans = int(a*b)
#Decimal(ans)
#ans_i = math.floor(a*b_i)
# ans = math.floor(Decimal(a)*Decimal(b))
print(int(ans//100))
a, b = map(float, input().split())
ans = int(a * (b * 100 + 0.5) / 100)
print(ans)
import sys, math
def main():
    s = list(input().split())
    a = int(s[0])
    b = list(s[1])
    for i in range(len(b)):
        if b[i] == '.':
            b[i] = ''
    b = int(''.join(b))
    print(math.floor(a*b/100))
    
if __name__ == "__main__":
    main()
a=list(input().split())
x=int(a[0])
y=float(a[1])
print(int(x*y))
a,b=input().split()
a=int(a)
b=float(b)

print(int(a*b+0.0001))
A,B=map(float,input().split())
X=A*(B*100)/100
print(int(X))
s = input().split()
a = int(s[0])
b = float(s[1])
print(int(a*b))
#! /usr/bin/env python3

import sys
import math
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

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

ans = int(A) * int(B * 1000000) // 1000000

print(int(ans))
from decimal import *
import math
r = list(map(float,input().split()))
x = Decimal(r[0])
y = Decimal(str(r[1])).quantize(Decimal(str(10**(2*-1))), rounding=ROUND_DOWN)
z = x * y

x = math.floor(x)

print(x)
a, b = input().split()
a = float(a)
b = float(b)
print(int(a * b))
a ,b = map(float, input().split()) 
print(int(a*b))
# -*- coding:utf-8 -*-
import sys
def main():
  n, m = map(str, input().split())
  ms = m[0:len(m)-3]
  mt = m[len(m)-2:len(m)]
  print ((int(n) * int(ms) + int(int(n) * int(mt) / 100)))

main()
a, b = map(float, input().split())
print(int(a * b // 1))
#C - Multiplication 3
A,B= map(float,input().split())
A = A/10000000
B = B*100

print(int(A*B*100000))
## coding: UTF-8
#from decimal import *
import math

A, B = map(str,input().split())
A = int(A)
B = float(B)
#print(A, B)
#print(A%10)

print(math.floor(A*B))
#print(A*B//1)
'''
A = Decimal(A)
B = Decimal(B)
C = A*B
'''

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

print(b, c, d)
'''
a,b = map(float,input().split())

print(int((a*b)//1))
a, b = input().split()
a = int(a)
b1, b2 = float(b).as_integer_ratio()
print(int(((a * b1) / b2) // 1))
a, b = input().split()
a = int(a)
b = float(b)
res = a * int(b*100) // 100
print(int(res))
import math 
x, n = list(map(float, input().split()))
x_100 = x*100
n_100 = n*100
print(math.floor(x_100*n_100/10000))
a, b = input().split()
x = int(a)
y = float(b)

print(int(x*y))
a, b = map(float,input().split())

print(int(a*b))
a,b = map(str, input().split())
a = int(a)
b = float(b)*100
bans = a*b
ans = int(bans/100)
import sys


def main():
    A,B=map(float,input().split())
    print(int(A*B))

if __name__ == "__main__":
    main()
A,B=input().split()
print(int(int(A)*int(B[:1]+B[-2:])/100))
import math
from decimal import *
A, B = map(float, input().split())
ans = Decimal(A) * Decimal(B)
ans = int(ans)
print(ans)
import math

n,k =input().split()

a=float(n) * float(k)

print(math.floor(a))
a, b = input().split()
a = int(a)
b = int(float(b)*100)
print(a*b//100)
a,b=map(float,input().split())
b=b*100
a,b=int(a),int(b)
print(int((a*b)//100))
import math
A,B = input().split()
A = int(A)
B = B.replace(".","")
 
B = int(B)
print(math.floor(A*B/100))
import sys
#import numpy as np
import math
#from fractions import Fraction
#import itertools
#from collections import deque
#import heapq
#from fractions  import gcd
a,b=input().split()
a=int(a)
b=float(b)
b=int(b*100)
ans=str(a*b)
n=len(ans)
if n>2:
  print((a*b)//100)
else:
  print(0)
import math
a,b= input().split()
a= int(a)
b = float(b)
print(math.floor(a*b))
import sys
import math

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

ans=int(float(A)*float(B))
print(ans)
import math
a, b = map(float, input().split())
answer = 1
print(math.floor(a*b))
a,b = map(float, input().split())
a = int(a)
ans = (a * int(b * 100)) // 100
print(ans)
a,b=[i for i in input().split()]
a=int(a)
b=float(b)
print(int(a*b))
import numpy as np
from functools import *
import sys
sys.setrecursionlimit(100000)


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


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


a,b=acinput()


b_int=int(b)
b_fl=b-b_int
res1=a*b_int
res2=np.floor(a*b_fl)

print(int(res1+res2))
import math
A, B = [ float(i) for i in input().strip().split(' ')]
B = int(B * 100)
print(math.floor(A*B/100))
import math
a,b = map(float, input().split())
c = int(b*100+0.5)
print(int(a*c/100))
a,b = input().split()

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

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

import math
print(math.floor(a * b))
import math
a,b = input().split()
a = int(a)
b = float(b)
print(int(math.floor(a*b)))
import sys
from math import ceil, floor, sqrt, sin, cos, pi
from itertools import accumulate, permutations, combinations
from fractions import gcd # 最大公約数
from collections import deque, Counter
from operator import itemgetter
from heapq import heappop,heappush
sys.setrecursionlimit(10**7)
def lcm(x, y): return ((x * y) // gcd(x, y)) # 最小公倍数
# list(map(int, input().split()))

ia, ib = input().split()
a = int(ia)
b = float(ib)
print(floor(a*b))
a,b = map(float,input().split())
print(int(a*b))
import sys

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


def solve():
    A, B = input().split()
    A = int(A)
    B = float(B)

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


if __name__ == '__main__':
    solve()
a, b = input().split(' ')
def doit(a,b):
  x,y = b.split('.')
  m=1
  if int(x) > 0:
    m = (1*int(a)*int(x) + int(a)*int(y))//100
  else:
    m = (1*int(a) + int(a)*int(y))//100
    
  return int(m)
 
print(doit(a,b))
import sys
import itertools
# import numpy as np
import time

sys.setrecursionlimit(10 ** 7)

from collections import defaultdict

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

a, b = readline().split()
a = int(a)
b = float(b)

import math
print(math.floor(a * b))
a, b = list(map(float, input().split()))
b_100 = int(b * 100)
a = int(a)
print(int((b_100 * a) / 100))
from sys import stdin
import math

A, B = [float(x) for x in stdin.readline().rstrip().split()]

print(math.floor(A*B))
a, b = map(float, input().split())
a = int(a)
b = int(b * 100)
ans = str(a * b)
print(ans)
if len(ans) <= 2:
    print(0)
else:
    print(ans[:-2])
import math
A, B = map(float, input().split())

print(math.floor(A *B))
a, b = map(str, input().split())
a = int(a)
b = int(float(b)*100)
if len(str(a*b)) <= 3:
    print(str(a * b)[0])
else:
    print(str(a * b)[:-2])
A,B=input().split()
C=int(A)
D=float(B)
print(int(C*D))
a,b = map(float,input().split())
a = int(a)
c = a*b 
print(int(c))
import math
from math import floor
import fractions
a,b=(float(x) for x in input().split())
a=int(a)
ans=math.floor(a*b)
print(int(ans))
import math
a,b = map(str,input().split())
ans = int(a)*float(b)
print(math.floor(ans))
A, B = map(float, input().split())
epsilon = 0.000001
A = int(A)
B = int((100*B+epsilon))
print(int(A*B+epsilon)//100)
a, b = map(float, input().split())
a = int(a)

print(a*b // 1)
import math

a,b=input().split()

print(
  math.floor(
    int(a)*int(b.replace(".", ""))/100
  )
)
from fractions import Fraction
from math import floor
a, b = map(float, input().split())
b = Fraction.from_float(b)
a = int(a)
b*=a
print(floor(b))
tmp = input().split()
a = int(tmp[0])
b = float(tmp[1])

print(int(a * b))
a,b=map(str,input().split())
tempb=float(b)*100
tempa=int(a)
print(int(tempa*tempb/100))
A, B = map(float, input().split())
print(int((A * B) // 1))
A,B=map(float, input().split())

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

# 2darray [[0] * 4 for i in range(3)]
import math

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