qyliang/CodeNanoFix huggingface dataset:
Buggy code:
#!/usr/bin/env python3

import sys
sys.setrecursionlimit(300000)


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

if __name__ == '__main__':
    main()


Fixed code:
#!/usr/bin/env python3

import sys
sys.setrecursionlimit(300000)


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

if __name__ == '__main__':
    main()
Buggy code:
import math
A,B = input().split()
print int(A)*int(B.replace('.',''))//100

Fixed code:
import math
A,B = input().split()
print (int(A)*int(B.replace('.',''))//100)
Buggy code:
from decimal import Decimal
a, b = input().split()
print(Decimal(a) * Decimal(b))


Fixed code:
from decimal import Decimal
a, b = input().split()
print(int(Decimal(a) * Decimal(b)))
Buggy code:
ab=input().split()
a=int(ab[0])
b=int(b[0]+b[2]+b[3])

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

Fixed code:
ab=input().split()
a=int(ab[0])
b=int(ab[1][0]+ab[1][2]+ab[1][3])
 
s=a*b
print(s//100)
Buggy code:
from decimal import *
i = input().split()
a = int(i[0])
b = Decimal(i[1])i
print(int(a * b))

Fixed code:
from decimal import *
i = input().split()
a = int(i[0])
b = Decimal(i[1])
print(int(a * b))
Buggy code:
import math
import decimal

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

Fixed code:
import math
import decimal

a, b = map(str, input().split())
a = decimal.Decimal(a)
b = decimal.Decimal(b)
ans = a * b
ans = math.floor(ans)
print(int(ans))
Buggy code:
A,B=map(float,input().split())

B=int(B*1000)

ans=A*B//1000

print(ans)

Fixed code:

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

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

ans=A*B//1000

print(ans)
Buggy code:
def main():
  	from decimal import Decimal
    a,b = map(decimal,input().split())
    print(int(a*b))
    return
main()

Fixed code:
def main():
    from decimal import Decimal
    a,b = map(Decimal,input().split())
    print(int(a*b))
    return
main()
Buggy code:
import math
a,b=input().split()
a=int(a)
c=b[0]+b[2]+b[3]
print(int(a*c/100))
#print(a*b)

Fixed code:
import math
a,b=input().split()
a=int(a)
c=int(b[0]+b[2]+b[3])
print(int(a*c)//100)
#print(a*b)
Buggy code:
a, b = map(float, input().split())
print(int(a*(b*(100+0.5))//100))

Fixed code:
a, b = map(float, input().split())
print(int(a)*int(b*100+0.5)//100)
Buggy code:
a = input().split()
for i in range(2):
    a[i] = int(a[i]) if i == 0 else float(a[i]*100)
print(int(a[0] * a[1] / 100))


Fixed code:
a = input().split()
for i in range(2):
    a[i] = int(a[i]) if i == 0 else round(float(a[i])*100)
print(int(a[0] * a[1] // 100))
Buggy code:
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  a,b=LS()

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

  return str(a*b)[:-2]

# main()
print(main())


Fixed code:
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  a,b=LS()

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

  x=str(a*b)[:-2]
  if x=='':
    return 0
  return x

# main()
print(main())
Buggy code:
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  a,b=LS()
  a=int(a)
  b=float(b)
  
  b*=100
  b=int(b)

  ans=a*b
  return a//100

# main()
print(main())


Fixed code:
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  a,b=LS()
  a=int(a)
  b=b.replace('.','')
  b=int(b)
  
  ans=a*b
  return ans//100

# main()
print(main())
Buggy code:
from decimal import *
getcontext().prec = 2

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

Fixed code:
from decimal import *
getcontext().prec = 32

a,b= input().split()
d = Decimal(a)*Decimal(b)
print(Decimal(d).quantize(Decimal('0'), rounding=ROUND_DOWN))
Buggy code:
A, B = input().split()
A = int(input())
B = int(B.replace(".". ""))

print(A*B//100)

Fixed code:
A, B = input().split()
A = int(A)
B = int(B.replace(".", ""))

print(A*B//100)
Buggy code:
A, B = map(str, input().split())
ans = 0
index = 1
B = B[::-1]
for b in B:
  if b == ".":
    continue
  ans += int(A) * int(b) * 10**index
  index += 1
print(ans//100)

Fixed code:
A, B = map(str, input().split())
ans = 0
index = 0
B = B[::-1]
for b in B:
  if b == ".":
    continue
  ans += int(A) * int(b) * 10**index
  index += 1
print(ans//100)
Buggy code:
A, B = input().split()
print(ans = int(A) * round(float(B) * 100) // 100)

Fixed code:
A, B = input().split()
ans = int(A) * round(float(B) * 100) // 100
print(int(ans))
Buggy code:
a,b = map(str,input().split())
a2 = int(a)
b2 = 100*int(b[0:1])+10*int(b[2:3])+int(b[3:4])
if b2 == 0:
    ans = 0
else:
    tmp = str(a2*b2)
    l = len(tmp)
    ans = int(tmp[0:l-2])
print(ans)

Fixed code:
a,b = map(str,input().split())
a2 = int(a)
b2 = 100*int(b[0:1])+10*int(b[2:3])+int(b[3:4])
if a2 == 0 or b2 == 0:
    ans = 0
else:
    tmp = str(a2*b2)
    l = len(tmp)
    if l <= 2:
        ans = 0
    else:
        ans = int(tmp[0:l-2])
print(ans)
Buggy code:
x=input().split()
a=int(x[0])
b=round(x[1]*100)

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

Fixed code:
x=input().split()
a=int(x[0])
b=round(float(x[1])*100)
print(int(a*b//100))
Buggy code:
a,b = map(str,input().split())

a = int(a)

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

print((a*b)//100)


Fixed code:
a,b = map(str,input().split())

a = int(a)

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

print((a*b)//100)
Buggy code:
inputs= list(input().split())
A=int(inputs[0])
B=int(float(inputs[1]+0.5)*100)
Ans=A*B/100
print(Ans)


Fixed code:
inputs= list(input().split())
A=int(inputs[0])
B=float(inputs[1])
B=int(B*100+0.5)
Ans=A*B//100
print(Ans)
Buggy code:
import sys
from decimal import Decimal
input = sys.stdin.readline


def readstr():
    return input().strip()


def readint():
    return int(input())


def readnums():
    return map(int, input().split())


def readstrs():
    return input().split()


def main():
    A, B = readstrs()
    A = Decimal(A)
    B = Decimal(B)
    print(A * B)
    print(int(Decimal(A * B)))


if __name__ == "__main__":
    main()


Fixed code:
import sys
from decimal import Decimal
input = sys.stdin.readline


def readstr():
    return input().strip()


def readint():
    return int(input())


def readnums():
    return map(int, input().split())


def readstrs():
    return input().split()


def main():
    A, B = readstrs()
    A = Decimal(A)
    B = Decimal(B)
    print(int(Decimal(A * B)))


if __name__ == "__main__":
    main()
Buggy code:
a, b = map(float, input().split())

b *= 100
b = round(b)

print(a*b//100)

Fixed code:
a, b = map(float, input().split())

a = int(a)

b *= 100
b = round(b)

print(a*b//100)
Buggy code:
from decimal import Decimal, ROUND_FLOOR

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

print(A, B)
print((A * B).quantize(Decimal("1"), rounding=ROUND_FLOOR))


Fixed code:
from decimal import Decimal, ROUND_FLOOR

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

# print(A, B)
print((A * B).quantize(Decimal("1"), rounding=ROUND_FLOOR))
Buggy code:
import decimal

a, b = input().split()

a = Decimal(a)
# print(b)
b = Decimal(b)
# print(b)

print(int(a*b))


Fixed code:
import decimal

a, b = input().split()

a = decimal.Decimal(a)
# print(b)
b = decimal.Decimal(b)
# print(b)

print(int(a*b))
Buggy code:
ma = lambda :map(int,input().split())
ni = lambda:int(input())
import collections
import math
import itertools
gcd = math.gcd
a,b = input().split()
a = int(a)
b100 = 100*int(b[0]) + 10*int(b[1]) +int(b[2])

print(a*b100//100)


Fixed code:
ma = lambda :map(int,input().split())
ni = lambda:int(input())
import collections
import math
import itertools
gcd = math.gcd
a,b = input().split()
a = int(a)
b100 = 100*int(b[0]) + 10*int(b[2]) +int(b[3])

print(a*b100//100)
Buggy code:
a, b = input().split()
b = b.replace('.', '')
int(a)
int(b)
print((a*b)//100)

Fixed code:
a, b = input().split()
b = b.replace('.', '')
a = int(a)
b = int(b)
print((a*b)//100)
Buggy code:
from decimal import Decimal
A,B = input().split()
A=Decimal(A)
B=Decimal(B)
AB=math.floor(A*B)
print(AB)

Fixed code:
from decimal import Decimal
import math
A,B = input().split()
A=Decimal(A)
B=Decimal(B)
AB=math.floor(A*B)
print(AB)
Buggy code:
import sys

input = sys.stdin.readline

value_list = input().split()

A = int(value_list[0])
B = float(value_list[1])

print(A * int(B * 100))

Fixed code:
import sys

input = sys.stdin.readline

value_list = input().split()

A = int(value_list[0])
B = float(value_list[1])

print(A * round(B * 100) // 100)
Buggy code:
A,B=map(str,input().split())
A=int(A)
B=list(B)
if '.' in B:
    B.remove('.')
else:
    B.append('0')
    B.append('0')
n=len(B)
b=sum(10**(n-1-j)*int(B[j]) for j in range(n))
ans=list(str(A*b))
ans.pop(len(ans)-1)
ans.pop(len(ans)-1)
n2=len(ans)
trueans=sum(10**(n2-1-j)*int(ans[j]) for j in range(n2))
print(trueans)

Fixed code:
A,B=map(str,input().split())
A=int(A)
B=list(B)
if len(B)<=2:
    B.append('0')
    B.append('0')
elif B[-3]=='.':
        B.remove('.')
elif B[-2]=='.' :
    B.remove('.')
    B.append('0')
else:
    B.append('0')
    B.append('0')
n=len(B)
b=sum(10**(n-1-j)*int(B[j]) for j in range(n))
ans=list(str(A*b))
if len(ans)<=2:
    ans='0'
else:
    ans.pop(len(ans)-1)
    ans.pop(len(ans)-1)
n2=len(ans)
trueans=sum(10**(n2-1-j)*int(ans[j]) for j in range(n2))
print(trueans)
Buggy code:
#c
a,b=map(float, input().split())
import math
a = decimal.Decimal(a)
b = decimal.Decimal(b)
ans = a*b
print(ans)

Fixed code:
#c
a,b=map(float, input().split())
import math
import decimal
a = decimal.Decimal(a)
b = decimal.Decimal(str(b))
ans = a*b
print(int(ans))
Buggy code:
a,b = input().split()

a = int(a)

ans = 0
ans += int(b[0])*100
ans += int(b[2])*100
ans += int(b[3])*100

print((ans*a)//100)

Fixed code:
a,b = input().split()

a = int(a)

ans = 0
ans += int(b[0])*100
ans += int(b[2])*10
ans += int(b[3])

print((ans*a)//100)
Buggy code:
A, B = map(str, input().split())
A = int()
B = B.replace(".", "")
B = int(B)
print(A*B//100)

Fixed code:
A, B = map(str, input().split())
A = int(A)
B = B.replace(".", "")
B = int(B)
print(A*B//100)
Buggy code:
import math
A,B = map(float,input().split())
B =  B*100
ans = int(A)*B//100
print(ans)

Fixed code:
import math
A,B = map(float,input().split())
B =  B*100
ans = int(A)*round(B)//100
print(ans)
Buggy code:
A,B=input().split()

n,m=0,0
for c in B:
  m*=10
  if c!='.':
    n=n*10+int(c)
    m=1

print((int(A)*n)//m)


Fixed code:
A,B=input().split()

n,m=0,0
for c in B:
  m*=10
  if c!='.':
    n=n*10+int(c)
  else:
    m=1

print((int(A)*n)//m)
Buggy code:
# 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) == 2:
    #     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())


Fixed code:
# 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())
Buggy code:
a, b = map(float, input().split())

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

print (c)

Fixed code:
a, b = map(float,input().split())
print(int(a) * int(float(b)*1000)//1000)
Buggy code:
from decimal import Decimal
def main():
    a, b = input().split(" ")
    a = int(a)
    b = Decimal(b)
    print(a*b)
    
if __name__ == "__main__":
    main()

Fixed code:
from decimal import Decimal
def main():
    a, b = input().split(" ")
    a = int(a)
    b = Decimal(b)
    print(int(a*b))

if __name__ == "__main__":
    main()
Buggy code:
import math
a,b=map(lambda x:x,input().split())
a=int(a)
b=int(round(b*100))
print(a*b//100)

Fixed code:
import math
a,b=map(lambda x:x,input().split())
a=int(a)
b=round(float(b)*100)
print(int(a*b//100))
Buggy code:
a, b = input().split()

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

print(a*b//100)

Fixed code:
a, b = input().split()

a = int(a)
b = round(float(b) * 100)
print(a * b // 100)
Buggy code:
def main():
    import sys
    import math
    a,b = map(str, input().split())
    a = int(a)
    b = int(b.replace('.',''))
    c = math.floor(a*100*b/100)
    
    print(c)
    


if __name__ == '__main__':
    main()

Fixed code:
def main():
    import sys
    import math
    a,b = map(str, input().split())
    a = int(a)
    b = int(b.replace('.',''))
    c = a*b//100    
    print(c)
    


if __name__ == '__main__':
    main()
Buggy code:
def resolve():
    a, b = input().split()
    a = int(a)
    b100 = int(b.replace('.', ''))

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

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

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

    ans = int(ans)
    print(ans)
resolve()
Buggy code:
import math

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

# A *= 100
B = float(B)
B = math.floor( * 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)


Fixed code:
import math

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

# A *= 100
# B = float(B)
# B = math.floor(B * 100)
B = B.replace('.', '').ljust(3, '0')
B = int(B)

# 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)
Buggy code:
import decimal
ab = input().split()
a,b = int(ab[0]),decimal(ab[1])
answer = int(a*b)
print(answer)


Fixed code:
from decimal import Decimal
ab = input().split()
a,b = int(ab[0]),Decimal(ab[1])
answer = int(a*b)
print(answer)
Buggy code:
a, b = map(str, input().split())
ans = int(a) * (int(b[0]) * 100 + int(b[2]) * 10 + int(b[3]))
print(int(ans) / 100)


Fixed code:
a, b = map(str, input().split())
ans = int(a) * (int(b[0]) * 100 + int(b[2]) * 10 + int(b[3]))
print(int(ans) // 100)
Buggy code:
a, b = map(float, input().split())
print(int(a*(b+0.001)*100/100))


Fixed code:
a, b = input().split()
a = int(a)
b = int((float(b) + 0.001) * 100)
print(a*b//100)
Buggy code:
a,b=input().split()
a=int(a)
b=int(b.replace('.',''))
ans=int(a*b)
print(ans/100)

Fixed code:
a,b=input().split()
a=int(a)
b=int(b.replace('.',''))
ans=int(a*b)
print(ans//100)
Buggy code:
# -*- codinf: utf-8 -*-
A, B = map(float, input().split())
a = int(A)
b = int(round(B * 100, 0))
print(b)
x = a * b
y = x // 100
print(y)

Fixed code:
# -*- codinf: utf-8 -*-
A, B = map(float, input().split())
a = int(A)
b = int(round(B * 100, 0))
x = a * b
y = x // 100
print(y)
Buggy code:
from decimal import Decimal
a, b = map(Decimal, input().split())
print(a*b)


Fixed code:
from decimal import Decimal
a, b = map(Decimal, input().split())
print(int(a*b))
Buggy code:
import math
a, b = map(str, input().split())
a = int(a)
b = float(b)
print(a, b, a * b)
b = int(b * 100)
print(a, b, a * b, a * b // 100)
ans = int(a * b // 100)
print(ans)

Fixed code:
import math
a, b = map(str, input().split())
a = int(a)
b = float(b)

b = int(b * 1000)

ans = int(a * b // 1000)
print(ans)
Buggy code:
from decimal import Decimal

n,k = input().split()
n =int(n)
k =Decimal(k)


a = math.floor(n*k)
print(a)

Fixed code:
from decimal import *
import math 
n,k = input().split()
n =Decimal(n)
k =Decimal(k)
a = math.floor(n*k)
print(a)
Buggy code:
def i():
	return int(input())
def i2():
	return map(str,input().split())
def s():
	return str(input())
def l():
	return list(input())
def intl():
	return list(int(k) for k in input().split())

from decimal import Decimal
a,b = i2()
c = Decimal(a)
d = Decimal(b)
print(c*d)

Fixed code:
def i():
	return int(input())
def i2():
	return map(str,input().split())
def s():
	return str(input())
def l():
	return list(input())
def intl():
	return list(int(k) for k in input().split())

from decimal import Decimal
a,b = i2()
c = Decimal(a)
d = Decimal(b)
print(int(c*d))
Buggy code:
i = input().split()
a = int(i[0])
b = int(i[0]+i[2:])
print(a * b // 100)

Fixed code:
i = input().split()
a = int(i[0])
b = int(i[1][0]+i[1][2:])
print(a * b // 100)
Buggy code:
a,b = map(str,input().split())
b100 = int(b[0]) * 100 + int(b[2]) * 10 + int(b[3])
# print(b)
# print(b100)
print(int(int(a)*b/100))


Fixed code:
a,b = map(str,input().split())
b100 = int(b[0]) * 100 + int(b[2]) * 10 + int(b[3])
# print(b)
# print(b100)
print((int(a)*b100)//100)
Buggy code:
"""
[a,b]=list(map(float,input().split()))
import math
a=int(a)
b=int(b*100)
ans=a*b
ans=ans/100
ans=math.floor(ans)
print(ans)
"""
import decimal
[a,b]=list(input().split()
a10=decimal.Decimal(a)
b10=decimal.Decimal(b)
ans=int(a10*b10)
print(ans)


"""
[a,b]=list(input().split())
a=int(a)
b12=list(b.split('.'))
bkai=int(int(b12[0])*100+int(b12[1]))
ans=a*bkai
ans=ans//100
print(ans)

Fixed code:
"""
[a,b]=list(map(float,input().split()))
import math
a=int(a)
b=int(b*100)
ans=a*b
ans=ans/100
ans=math.floor(ans)
print(ans)
"""
import decimal
[a,b]=list(input().split())
a10=decimal.Decimal(a)
b10=decimal.Decimal(b)
ans=a10*b10
ans=int(ans)
print(ans)


"""
[a,b]=list(input().split())
a=int(a)
b12=list(b.split('.'))
bkai=int(int(b12[0])*100+int(b12[1]))
ans=a*bkai
ans=ans//100
print(ans)
"""
Buggy code:
"""
[a,b]=list(map(float,input().split()))
import math
a=int(a)
b=int(b*100)
ans=a*b
ans=ans/100
ans=math.floor(ans)
print(ans)
"""
[a,b]=list(input().split())
a=int(a)
b12=list(b.split('.'))
bkai=int(b12[0]*100+b12[1])
ans=a*bkai
ans=ans//100
print(ans)

Fixed code:
"""
[a,b]=list(map(float,input().split()))
import math
a=int(a)
b=int(b*100)
ans=a*b
ans=ans/100
ans=math.floor(ans)
print(ans)
"""
[a,b]=list(input().split())
a=int(a)
b12=list(b.split('.'))
bkai=int(int(b12[0])*100+int(b12[1]))
ans=a*bkai
ans=ans//100
print(ans)
Buggy code:
a,b=map(str,input().split())

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

#from decimal import *

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

print(int(a*b))

Fixed code:
a,b=map(str,input().split())

#a=int(a)
#b=float(b)

from decimal import *

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

print(int(a*b))
Buggy code:
import sys
A, B =map(float,input().split())
A = int(A)
B = (B+sys.float_info.epsilon*5)*100
ans = A*B
print(ans)


Fixed code:
import sys
A, B =map(float,input().split())
A = int(A)
B = int((B+sys.float_info.epsilon*5)*100)
ans = A*B//100
print(ans)
Buggy code:
from decimal import Decimal
a, b = map(str, input().split())
print(float(b))
print(int(int(a)*Decimal(b)))

Fixed code:
from decimal import Decimal
a, b = map(str, input().split())
print(int(int(a)*Decimal(b)))
Buggy code:
#abc169c
a,b=map(str,input().split())
a=int(a)
b=float(b)
print(int(a*b*100)/100)


Fixed code:
#abc169c
a,b=map(str,input().split())
a=int(a)
b=round(100*float(b))
print(a*b//100)
Buggy code:
def main():
    _a, _b = input().split()
    a = int(_a)
    b = int(_b[0:-3]) * 100 + int(_b[-2:])

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

if __name__ == '__main__':
    main()

Fixed code:
def main():
    _a, _b = input().split()
    a = int(_a)
    b = int(_b[0:-3]) * 100 + int(_b[-2:])
    print(a * b // 100)

if __name__ == '__main__':
    main()
Buggy code:
from sys import stdin
import sys

a,b = [int(x) for x in stdin.readline().rstrip().split()]
print(a*(b*100)/100)

Fixed code:
from sys import stdin
import sys

a, b = [x for x in stdin.readline().rstrip().split()]
a = int(a)
b = int(b.replace('.',''))

print(a * b  // 100)
Buggy code:
A, B = map(str, input())
A = int(A)
B = int(B.replace(',', ''))
print(A * B / 100)

Fixed code:
A, B = map(str, input().split())
A = int(A)
B = int(B.replace('.', ''))
print(A * B // 100)
Buggy code:
a,b=list(map(float,input().split()))
b=round(b*100)
print(a*b//100)

Fixed code:
a,b=list(map(float,input().split()))
a=int(a)
b=round(b*100)
print((a*b)//100)
Buggy code:
a, b = map(float, input().split()) 
a = int(a)
b*=100
b = int(round(b))
print(a,b)
ans = a*b
ans = ans//100
print(ans)

# import math
# print(0.11*100)
# i = 0.01
# while i <= 1.00:
#     print(round(i*100))
#     i+=0.01

Fixed code:
a, b = map(float, input().split()) 
a = int(a)
b*=100
b = int(round(b))
# print(a,b)
ans = a*b
ans = ans//100
print(ans)

# import math
# print(0.11*100)
# i = 0.01
# while i <= 1.00:
#     print(round(i*100))
#     i+=0.01
Buggy code:
from decimal import Decimal

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

Fixed code:
from decimal import Decimal

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

from decimal import Decimal

a, b = input().split()

print(int(decimal(a)*decimal(b)))


Fixed code:
# -*- coding: utf-8 -*-

from decimal import Decimal

a, b = input().split()

print(int(Decimal(a)*Decimal(b)))
Buggy code:
A, B = list(map(float, input().split()))
#print(A*B)
print((A*(B*100)+0.5)//100)

Fixed code:
A, B = list(map(float, input().split()))
#print(A*B)
print(int((int(A+0.5)*int(B*100+0.5))//100))
Buggy code:
A, B = list(map(str, input().split()))

a = int(A)
b = int(B[0])
b2 = int(B[2:4])
#print(b)
#print(b2)
#print(b)

b3 = b*100
bb = b3 + b2
tmp = a*bb
#print(a*b)

ans = str(tmp)

print(ans[:-2])


Fixed code:
A, B = list(map(str, input().split()))

a = int(A)
b = int(B[0])
b2 = int(B[2:4])
#print(b)
#print(b2)
#print(b)

b3 = b*100
bb = b3 + b2
tmp = a*bb
#print(a*b)

print(int(tmp//100))