qyliang/CodeNanoFix huggingface dataset:
Buggy code:
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
from decimal import *
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
#import numpy as np
INF = float("inf")
#d = defaultdict(int)
#d = defaultdict(list)
#N = int(input())
#A = list(map(int,input().split()))
#S = list(input())[:-1]
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = [int(input()) for _ in range(N)]
#S = [list(input())[:-1] for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
A,B = map(float,input().split())
if round(A) == 0 or B <= 0.005:
    print(0)
else:
    a = int(A)
    b = Decimal(B)
    print(floor(a*b))
    

    





Fixed code:
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
#import numpy as np
INF = float("inf")
#d = defaultdict(int)
#d = defaultdict(list)
#N = int(input())
#A = list(map(int,input().split()))
#S = list(input())[:-1]
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = [int(input()) for _ in range(N)]
#S = [list(input())[:-1] for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
A,B = map(float,input().split())
if math.floor(A) == 0 or B <= 0.005:
    print(0)
else:
    A = int(A)
    B *= 100.0
    B = round(B)
    c = A*B
    c = round(c)
    print(c // 100)
Buggy code:
import math

def main():
    a, b = input().split()
    a = int(a)
    b1, b2 = map(int, b.split('.'))
    ans = a * b1 * 100 + b2
    ans = ans // 100

    print(f'{ans}')


if __name__ == '__main__':
    main()

Fixed code:
def main():
    a, b = input().split()
    a = int(a)
    b1, b2 = map(int, b.split('.'))
    ans = a * ((b1 * 100) + b2)

    ans = ans // 100

    print(f'{ans}')


if __name__ == '__main__':
    main()
Buggy code:
a,b=input().split()
c,c = b.split(".")
print(int(a)*int(b)+int(a)*int(c)//100)

Fixed code:
a,b=input().split()
b,c = b.split(".")
print(int(a)*int(b)+int(a)*int(c)//100)
Buggy code:
import math

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

Fixed code:
import math
import decimal

A, B = map(str, input().split())
A = int(A)
B = decimal.Decimal(B)
print(math.floor(A*B))
Buggy code:
import math,decimal
arr = list(input().split())

A=int(arr[0])
B=decimal.Decimal(arr[1])
C=A * B
D=math.floor(C)
print(C)
print(D)

Fixed code:
import math,decimal
arr = list(input().split())

A=int(arr[0])
B=decimal.Decimal(arr[1])
C=A * B
D=math.floor(C)
#print(C)
print(D)
Buggy code:
from decimal import Decimal as dec

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

if __name__ == "__main__":
    main()

Fixed code:
from decimal import Decimal as dec

def main():
    a, b = map(dec, input().split())
    print(int(dec(a*b)))

if __name__ == "__main__":
    main()
Buggy code:
# -*- coding: utf-8 -*-
from decimal import Decimal

str_A,str_B = input().rstrip().split()

A = int(str_A)
B = Decimal(str_B)

print(A*B)


Fixed code:
# -*- coding: utf-8 -*-
from decimal import Decimal

str_A,str_B = input().rstrip().split()

A = int(str_A)
B = Decimal(str_B)

print( int(A*B) )
Buggy code:
# -*- coding: utf-8 -*-

str_A,str_B = input().rstrip().split()

A = int(str_A)
B = int(str_B.replace(".",""))  # B * 100

print("ans",A*B//100)


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

str_A,str_B = input().rstrip().split()

A = int(str_A)
B = int(str_B.replace(".",""))  # B * 100

print(A*B//100)
Buggy code:
import match
from  decimal import Decimal
a,b=map(map(Decimal,input().split()));
c=a*b
print(math.floor(c))

Fixed code:
import math
from decimal import Decimal
a,b=map(Decimal,input().split());
c=a*b
print(math.floor(c));
Buggy code:
from decimal import Decimal

a,b = input().split()
b = round(b*100)
c = int(a)*int(b)//100

print(c)

Fixed code:
from decimal import Decimal

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

print(c)
Buggy code:
a, b = input().split()
a = int(a)
b = int(b.replace('.',''))

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

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

print(a * b // 100)
Buggy code:
import math
import decimal

r = list(map(float,input().split()))

x = decimal.Decimal(str(r[1])).quantize(Decimal('0'),rounding=ROUND_HALF_UP)
y = decimal.Decimal(str(r[1])).quantize(Decimal('0.01'),rounding=ROUND_HALF_UP)

z = x * y

z = math.floor(z)

print(z)

Fixed code:
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

r = list(map(float,input().split()))

x = Decimal(str(r[0])).quantize(Decimal('0'),rounding=ROUND_HALF_UP)
y = Decimal(str(r[1])).quantize(Decimal('0.01'),rounding=ROUND_HALF_UP)

z = x * y

z = math.floor(z)

print(z)
Buggy code:
from decimal import Decimal
a,b = map(str,input().split())
a = int(a)
b = Decimal(b)
print(a*b)

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

Fixed code:
import decimal
a,b = map(decimal.Decimal,input().split())
print(int(a*b))
Buggy code:
def cc():
    a, b = map(str, input().split())
    a2 = int(a)
    b2 = int(b.replace('.', ''))
    c = a2 * b2
    ans = str(c)[0:-2] if len(c) > 2 else 0
    print(ans)
if __name__ == "__main__":
    cc()


Fixed code:
def cc():
    a, b = map(str, input().split())
    a2 = int(a)
    b2 = int(b.replace('.', ''))
    c = a2 * b2
    ans = str(c)[0:-2] if len(str(c)) > 2 else 0
    print(ans)
if __name__ == "__main__":
    cc()
Buggy code:
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
# input = sys.stdin.readline 
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(float, input().split())

    getcontext().prec = 3

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

    ans = a * b

    print(Decimal(floor(ans/100)))
            
if __name__ == '__main__':
    main()


Fixed code:
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
# input = sys.stdin.readline 
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())

    # getcontext().prec = 2

    print(floor(a*b))
            
if __name__ == '__main__':
    main()
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 sys
input  = input().split()

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

print(int(A*B))

Fixed code:
import sys
input  = input().split()

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

print((A*B // 100))
Buggy code:
A,B=input().split()
B=round(float(B))
B=B*100
print(int(int(A)*B//100))

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

for i in range(len(b)):
    if b[i] == '.':
        t = 10 ** (len(b)-1-i)
        nb = int(b[:i] + b[i+1])

print(a*nb//t)

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

for i in range(len(b)):
    if b[i] == '.':
        t = 10 ** (len(b)-1-i)
        nb = int(b[:i] + b[i+1:])

print(a*nb//t)
Buggy code:
a,b = input().split()
c = int(a)
d = round(float(b)*100)
print(c*d)

Fixed code:
a,b = input().split()
c = int(a)
d = round(float(b)*100)
print(c*d//100)
Buggy code:
import math
from decimal import Decimal
a, b = input().split()
//a = decimal.Decimal(a)
//b = decimal.Decimal(b)
print(math.floor(Decimal(a) * Decimal(b)))


Fixed code:
import math
from decimal import Decimal
a, b = input().split()
a = Decimal(a)
b = Decimal(b)
print(math.floor(a * b))
Buggy code:
import decimal from decimal
import math

A, B = input().split()

B = decimal(B)
A = int(A)
product = A*B

print(math.floor(product))

Fixed code:
from decimal import Decimal
import math

A, B = input().split()

B = Decimal(B)
A = int(A)
product = A*B

print(math.floor(product))
Buggy code:
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)
print(s[0:s_len-2])

Fixed code:
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)
Buggy code:
A, B = input().split()
A = int(A)
B = B.replace(".", "")
print(int(A * B / 100))

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

print(A * B//100)
Buggy code:
from decimal import Decimal
A, B = input().split()
dec_a = Decimal(A)
dec_b = Decimal(B)

print(dec_a * dec_b)

Fixed code:
from decimal import Decimal
A, B = input().split()
dec_a = Decimal(A)
dec_b = Decimal(B)

print(int(dec_a * dec_b))
Buggy code:
A, B = input().split()
A = int(A)
# B = int(B.replace(".", ""))
# B = (int(B[0]) - 0) * 100 + (int(B[2]) - 0) * 10 + (int(B[3]) - 0)
print(A * B // 100)

Fixed code:
A, B = input().split()
A = int(A)
# B = int(B.replace(".", ""))
B = (int(B[0]) - 0) * 100 + (int(B[2]) - 0) * 10 + (int(B[3]) - 0)
print(A * B // 100)
Buggy code:
from decimal import Decimal

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

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

Fixed code:
from decimal import Decimal

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

ans = a * b
print(int(ans))
Buggy code:
A, B = input().split()

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

print((A*B)//100)

Fixed code:
A, B = input().split()
 
A = int(A)
B = float(B)
B = round((B*100))
 
print((A*B)//100)
Buggy code:
from decimal import Decimal

m,n=map(Decimal,input().split(''))
print(int(m*n))

Fixed code:
from decimal import Decimal

m,n=map(Decimal,input().split(' '))
print(int(m*n))
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:
import numpy as np
import math
[A,B] = input().split()
c = 0
if '.' in B:
    c = int(B.find('.'))
c = len(B)-c-1
B = B.replace(".","")
A = np.int64(A)
B = np.int64(B)
C = A*B
if c == 0 or C <=100:
    print(math.floor(C/int(10**c)))
else c == 1:
    print(str(C)[:-c])

Fixed code:
import numpy as np
import math
[A,B] = input().split()
c = 0
if '.' in B:
    c = int(B.find('.'))
c = len(B)-c-1
B = B.replace(".","")
A = np.int64(A)
B = np.int64(B)
C = A*B
if c == 0 or C <=100:
    print(math.floor(C/int(10**c)))
else:
    print(str(C)[:-c])
Buggy code:
#!/usr/bin/python

import sys
import math 

#Input Functions
#===============

input = sys.stdin.readline

def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return(map(int,input().split()))

#===============

def run_test() :
    (a, b) = map(float, input().split())
    a = int(a)
    b = int(b * 100)
    a *= b * 100
    a //= 100
    print(int(a))

def main() :
	run_test()

if __name__ == '__main__' :
	main()


Fixed code:
#!/usr/bin/python

import sys
import math 

#Input Functions
#===============

input = sys.stdin.readline

def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return(map(int,input().split()))

#===============

def run_test() :
    (a, b) = map(float, input().split())
    a = int(a)
    b = int(b * 100 + 0.5)
    a *= b
    a //= 100
    print(int(a))

def main() :
	run_test()

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


Fixed code:
def main():
    a,b=map(float,input().split())
    a=int(a)
    print(int((b*100+0.1)//1)*a//100)
main()
Buggy code:
a,b=map(str,input().split())
A=int(a)
B=""
for i in range(len(b)):
  if b[i]!=".":
    B+=b[i]
  else:
    pass
B=int(B)
ans=A*B
print(ans)

Fixed code:
a,b=map(str,input().split())
A=int(a)
B=""
for i in range(len(b)):
  if b[i]!=".":
    B+=b[i]
  else:
    pass
B=int(B)
ans=A*B//100
print(ans)
Buggy code:
a,b=map(input().split())
a=int(a)
b=list(b)
b=[b[0],b[2],b[3]]
c=a*b[0]+a*b[2]//10+a*b[3]//100
print(c)

Fixed code:
a,b=input().split()
a=int(a)
b=list(b)
b=[int(b[0]),int(b[2]),int(b[3])]
c=(a*b[0]*100+a*b[1]*10+a*b[2])//100
print(c)
Buggy code:
a,b = input().split()

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

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


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

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

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


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

ans = a*b//100
print(ans)
Buggy code:
a,b = map(str,input().split())
b = list(b)
del b[-3]
b = "".join(b)
print(round(int(a)*int(b)/100))

Fixed code:
a,b = map(str,input().split())
b = list(b)
del b[-3]
b = "".join(b)
print(int(a)*int(b)//100)
Buggy code:
A, B = input().split()
A = int(A)
B100 = ""

for s in range(len(B)):
    if B[s] != ".":
        B100 += B[s]

B100 = int(B100)

ans = A * B100 // 100

print(ans[0])


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

for s in range(len(B)):
    if B[s] != ".":
        B100 += B[s]

B100 = int(B100)

ans = A * B100 // 100

print(ans)
Buggy code:
import math

a, b = map(str, input().split())
a = int(a)
b100 = int(b[0]+b[2]+b[3])
ab = str(a*b100)

print(b100)
if len(ab)>=3:
    print(ab[:-2])
else:
    print(0)


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

if int(b[0])==0:
    if int(b[2])==0:
        b100 = int(b[3])
    else:
        b100 = int(b[2]+b[3])
else:
    b100 = int(b[0]+b[2]+b[3])
    
ab = str(a*b100)

if len(ab)>=3:
    print(ab[:-2])
else:
    print(0)
Buggy code:
a,b=map(float,input().split())
b=int(b*100+0.5)
ans=a*b//100
print(ans)

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

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

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

print(a*b)

Fixed code:
from decimal import Decimal

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

print(int(a*b))
Buggy code:
import math
from decimal import Decimal
a,b = map(float,input().split())
a = Decimal(a)
b =Decimal(b)
print('{:.020f}'.format(b))
print(b)
# b *=100
# b = int(b)
# print(math.floor(a*b/100))
# c = a%10000
# e = math.floor(a / 10000)

# print(int(e*b*10000+c*b))

# c = b-int(b)
# for 
# d = int(b)
# s = a*d+c*a
print(int(math.floor(a*b)))

Fixed code:
import math
from decimal import Decimal
a,b = map(str,input().split())
a = Decimal(a)
b =Decimal(b)
# print('{:.020f}'.format(b))
# print(b)
# b *=100
# b = int(b)
# print(math.floor(a*b/100))
# c = a%10000
# e = math.floor(a / 10000)

# print(int(e*b*10000+c*b))

# c = b-int(b)
# for 
# d = int(b)
# s = a*d+c*a
print(int(math.floor(a*b)))
Buggy code:
a,b=input().split()
a = int(a)
b = float(b)
b = round(b * 100)
ans = (a*c) // 100
print(ans)

Fixed code:
a,b=input().split()
a = int(a)
b = float(b)
b = round(b * 100)
ans = (a*b) // 100
print(ans)
Buggy code:
A,B = input().split()
A = int(A)
B = list(B)
B.pop(-3)
B = int("".join(B))
print(A,B)
print((A*B)//100)

Fixed code:
A,B = input().split()
A = int(A)
B = list(B)
B.pop(-3)
B = int("".join(B))
print((A*B)//100)
Buggy code:
from Decimal import *
n1, n2 = map(Decimal, input().split())
print(int(n1*n2))

Fixed code:
from decimal import Decimal
n1, n2 = map(Decimal, input().split())
print(int(n1*n2))
Buggy code:
a,b = input().split()

a = int(a)
b = b[0] + b[2] + b[3]

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

Fixed code:
a,b = input().split()
p = int(a)
q = int(b[0] + b[2] + b[3])

print(p * q // 100)
Buggy code:
from math import floor
A= input().split()
p = int(A[0])
q = float(A[1]*100)
t = p*q
p //= 100
print(p)

Fixed code:
from math import floor
A= input().split()
p = int(A[0])
q = round(float(A[1])*100)
t = p*q
t //= 100
print(t)
Buggy code:
a, b = input().split()
a = int(a)
b = int(b[0])*100 + int(b[1])*10 + int(b[3])
c = a*b
print(c//100)


Fixed code:
a, b = input().split()
a = int(a)
b = int(b[0])*100 + int(b[2])*10 + int(b[3])
c = a*b
print(c//100)
Buggy code:
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd, floor
from itertools import permutations, combinations, product, accumulate, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from decimal import *
#from fractions import gcd
def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True

t = input().split()
a, b = int(t[0]), Decimal(t[1])
ans = a * b
print(ans)

Fixed code:
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd, floor
from itertools import permutations, combinations, product, accumulate, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from decimal import *
#from fractions import gcd
def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True

t = input().split()
a, b = int(t[0]), Decimal(t[1])
bb = floor(b)
bbb = (b - bb)
ans = a * bb + int(a * bbb)
print(ans)
Buggy code:
from decimal import Decimal

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

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

print(a*b)

Fixed code:
from decimal import Decimal

a, b = input().split()

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

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


Fixed code:
a,b=input().split()
a = int(a)
b = float(b)
b = round(b * 100)
ans = (a*b) // 100
print(ans)
Buggy code:
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush
from math import ceil, floor, sqrt, gcd
from copy import deepcopy

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

if __name__ == "__main__":
    main()

Fixed code:
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush
from math import ceil, floor, sqrt, gcd
from copy import deepcopy
from decimal import *

def main():
    a,b = map(Decimal, input().split())
    result = a*b
    print(int(result))
    
if __name__ == "__main__":
    main()
Buggy code:
A, B = input().split()

A = int(A)
B = int(float(B) * 100 + 0.5)
ans = A * B / 100

print(ans)

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

A = int(A)
B = int(float(B) * 100 + 0.5)
ans = A * B // 100

print(ans)
Buggy code:
A,B = input().split()
from decimal import Decimal
A = Decimal(A)
B = Decimal(B)
N = A*B
print(N.quantize(Decimal('1')))


Fixed code:
A,B = input().split()
from decimal import Decimal,ROUND_DOWN
A = Decimal(A)
B = Decimal(B)
N = A*B
print(N.quantize(Decimal('1'),rounding=ROUND_DOWN))
Buggy code:
A, B = input().split()
B = B.replace('.', '')
print(B)
print(int(A) * int(B) // 100)

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


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