qyliang/CodeNanoFix huggingface dataset:
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)
if b == 0:
    print(0)
    exit()

t = int(0.5+a*b)
#print(t)
#b3 = b*100
bb = int(0.5+a*b2)
tmp = bb//100+0.5
#print(tmp)
#print(a*b)
bef = tmp+t
ans = int(bef+0.5)

print(ans)



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)


t = a*b
#print(t)
#b3 = b*100
bb = a*b2
tmp = bb//100
#print(tmp)
#print(a*b)
bef = tmp+t
ans = str(bef)

print(ans)
Buggy code:
A, B = input().split()
A = int(A)
B = int(B)*100 + int(B[-2:])

print(A*B // 100)

Fixed code:
A, B = input().split()
A = int(A)
B = int(B[:-3])*100 + int(B[-2:])

print(A*B // 100)
Buggy code:
import math


def main() -> None:
    a, b = input().split()

    print(math.floor(int(a) * int(b*100) / 100))

    return


if __name__ == '__main__':
    main()


Fixed code:
import math


def main() -> None:
    a, b = input().split()

    print((int(a)*int(b.replace('.', ''))) // 100)

    return


if __name__ == '__main__':
    main()
Buggy code:
a,b=input().split()
a=int(a)
b=int(b[0]+b[1:])
print((a*b)//100)

Fixed code:
a,b=input().split()
a=int(a)
b=int(b[0]+b[2:])
print((a*b)//100)
Buggy code:
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))

from collections import defaultdict, deque
from sys import exit
import math
import copy
from bisect import bisect_left, bisect_right
from heapq import *
import sys
# sys.setrecursionlimit(1000000)
INF = 10 ** 17
MOD = 1000000007

from fractions import *
def inverse(f):
    # return Fraction(f.denominator,f.numerator)
    return 1/f


def combmod(n, k, mod=MOD):
    ret = 1
    for i in range(n - k + 1, n + 1):
        ret *= i
        ret %= mod

    for i in range(1, k + 1):
        ret *= pow(i, mod - 2, mod)
        ret %= mod

    return ret
def bunsu(n):
    ret = []
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            tmp = 0
            while(True):
                if n % i == 0:
                    tmp += 1
                    n //= i
                else:
                    break
            ret.append((i, tmp))

    ret.append((n, 1))
    return ret

def solve():
    a, b = list(map(float, input().split()))
    print(((a*100) * (b*100))//10000)
def main():
    # n = getN()
    # for _ in range(n):
    solve()
if __name__ == "__main__":
    solve()


Fixed code:
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))

from collections import defaultdict, deque
from sys import exit
import math
import copy
from bisect import bisect_left, bisect_right
from heapq import *
import sys
# sys.setrecursionlimit(1000000)
INF = 10 ** 17
MOD = 1000000007

from fractions import *
def inverse(f):
    # return Fraction(f.denominator,f.numerator)
    return 1/f


def combmod(n, k, mod=MOD):
    ret = 1
    for i in range(n - k + 1, n + 1):
        ret *= i
        ret %= mod

    for i in range(1, k + 1):
        ret *= pow(i, mod - 2, mod)
        ret %= mod

    return ret
def bunsu(n):
    ret = []
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            tmp = 0
            while(True):
                if n % i == 0:
                    tmp += 1
                    n //= i
                else:
                    break
            ret.append((i, tmp))

    ret.append((n, 1))
    return ret

def solve():
    a, b = input().split()
    a = int(a)
    b = int(b[:-3]) * 100 + int(b[-2:])
    ans = (a * b) // 100
    print(ans)
    # print(str(ans)[:-2])
def main():
    # n = getN()
    # for _ in range(n):
    solve()
if __name__ == "__main__":
    solve()
Buggy code:
from decimal import Decimal
a, b = map(str,input().split())
c = Decimal(a)
d = Decimal(b)
e = c * d
print(e)


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

readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prl = lambda x: print(*x ,sep='\n')

a,b = input().split(' ')
ash_1 = int(a[-1])
ash_2 = int(a[-2:])
bsh_1 = int(b[-2])
bsh_2 = int(b[-1])
bsh_0 = int(b[0])
kuri = int(ash_1*bsh_1 + ash_2*bsh_2)
if len(a) == 1:
    res = int(a)*bsh_0 + kuri
elif len(a) == 2:
    a1 = a[:-1]
    res = int(a)*bsh_0 + int(a1)*bsh_1 + kuri
else:
    a1 = a[:-1]
    a2 = a[:-2]
    res = int(a)*bsh_0 + int(a1)*bsh_1 + int(a2)*bsh_2 + kuri
print(res)

Fixed code:
import sys
import math

readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prl = lambda x: print(*x ,sep='\n')

a,b = input().split(' ')
ash_1 = int(a[-1])
ash_2 = int(a[-2:])
bsh_1 = int(b[-2])
bsh_2 = int(b[-1])
bsh_0 = int(b[0])
kuri = (ash_1*bsh_1*10 + ash_2*bsh_2) //100
if len(a) == 1:
    res = int(a)*bsh_0 + kuri
elif len(a) == 2:
    a1 = a[:-1]
    res = int(a)*bsh_0 + int(a1)*bsh_1 + kuri
else:
    a1 = a[:-1]
    a2 = a[:-2]
    res = int(a)*bsh_0 + int(a1)*bsh_1 + int(a2)*bsh_2 + kuri
print(res)
Buggy code:
A ,B= map(float,input().split())
A = int(A)
C = str(B)
if B == 10.0:
  D = 1000
elif B == 0.0:
  D = 0
else:
  D = int(C[-1]) + int(C[-2])*10 + int(C[-4])*100
ans = A*D
ans = ans//100
print(ans)

Fixed code:
A ,B= map(float,input().split())
A = int(A)
C = str(B)
if B == 10.0:
  D = 1000
elif B == 0.0:
  D = 0
elif len(C) == 4:
  D = int(C[-1]) + int(C[-2])*10 + int(C[-4])*100
elif len(C) == 3:
  D = int(C[-1])*10 + int(C[-3])*100
  
ans = A*D
ans = ans//100
print(ans)
Buggy code:
#!/usr/local/bin/python3
# coding: utf-8

ha = input()
kita = ha.split(" ")
a = int(kita[0])
b = int(kita[1].replace(".",""))
m = a*b
m = str(m)

c = kita[1].split(".")
try:
    co = len(c[1])
except:
    co = 0
if a*b == 0:
    print("0")
elif co > 0:
    print(m[:-1*co])
else:
    print(m)

Fixed code:
#!/usr/local/bin/python3
# coding: utf-8

ha = input()
kita = ha.split(" ")
a = int(kita[0])
b = int(kita[1].replace(".",""))
m = a*b
m = str(m)

c = kita[1].split(".")
try:
    co = len(c[1])
except:
    co = 0
if int(kita[0]) * float(kita[1]) < 1:
    print("0")
elif co > 0:
    print(m[:-1*co])
else:
    print(m)
Buggy code:
from decimal import Decimal
import math
a,b = list(map(float, input().split()))
b *= 1000
A = int(a)
B = int(b)
#print(a)
#print(b)

#ab = a*b
#print(ab)

#ac = Decimal(a*b)
print(a*b//1000)


 

Fixed code:
from decimal import Decimal
import math
a,b = list(map(float, input().split()))
b *= 1000
A = int(a)
B = int(b)
#print(a)
#print(b)

#ab = a*b
#print(ab)

#ac = Decimal(a*b)
print(A*B//1000)
Buggy code:
A, B = input.split()
a = int(A)
b = float(B) * 100
c = a * b // 100
print(c)

Fixed code:
A, B = input().split()
a = int(A)
b = round(float(B) * 100)
c = a * b // 100
print(c)
Buggy code:
import numpy as np 
A,B = map(str,input().split())
A = int(A)
B = int(B[0]+B[2]+B[3])
C = A*B/100
print(C)

Fixed code:
import numpy as np 
A,B = map(str,input().split())
A = int(A)
B = int(B[0]+B[2]+B[3])
print(int(A*B//100))
Buggy code:
from decimal import Decimal
a, b = map(Decimal, input().split())

print(math.floor(a * b))

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

print(math.floor(a * b))
Buggy code:
A,B= list(input().split())
a = int(B[0])
b = int(B[2])
c = int(B[3])
if int(A) > 1000:
   e = int(A[-2])
   f = int(A[-1])
   d = (int(A)- 10 * e - f)/100
   error = 10 * (c * e + b * f) + c * f
   error = int(error/100)
   ans = int(A) * a + 10 * d * b + e * b + c * d + error
   print(ans)
else:
   print(int(int(A)*float(B))

Fixed code:
A,B= list(input().split())
a = int(B[0])
b = int(B[2])
c = int(B[3])
if int(A) > 1000:
   e = int(A[-2])
   f = int(A[-1])
   d = int((int(A)- 10 * e - f)/100)
   error = 10 * (c * e + b * f) + c * f
   error = int(error/100)
   ans = int(A) * a + 10 * d * b + e * b + c * d + error
   print(int(ans))
else:
   print(int(int(A)*float(B)))
Buggy code:
import math
line = input().split()
a = int(line[0])
b = float(line[1])
c = a*b
c *= 100


print(c//100)

Fixed code:
import math
line = input().split()
a = int(line[0])
b = round(100 * float(line[1]))


# c = round(a * b) = a * (b * 100)  / 100

print(a*b//100)
Buggy code:
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
print(a*b_i + int(str(b_m)[:-2]))

Fixed code:
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]))
Buggy code:
import sys 
input =sys.stdin.readline 
from deciaml import Decimal 

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

main()

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

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

main()
Buggy code:
from decimal import *
A, B = input().split()
A = Decimal(A)
B = Decimal(B)
print(A * B)

Fixed code:
from decimal import *
A, B = input().split()
A = Decimal(A)
B = Decimal(B)
print(int(A * B))
Buggy code:
from sys import stdin,stdout
LI=lambda:list(map(int,input().split()))
MAP=lambda:map(int,input().split())
IN=lambda:int(input())
S=lambda:input()
import math
from collections import Counter,defaultdict

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


Fixed code:
from sys import stdin,stdout
LI=lambda:list(map(int,input().split()))
MAP=lambda:map(int,input().split())
IN=lambda:int(input())
S=lambda:input()
import math
from collections import Counter,defaultdict

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

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

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

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

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

Fixed code:
from decimal import Decimal
import math
a,b = input().split()
decA = Decimal(a)
decB = Decimal(b)
ans = decA * decB
print(math.floor(ans))
Buggy code:
line = input()
nums = line.split(" ")
a = int(nums[0])
b = int(nums[1].replace(".", ""))
print(str(a*b)[:-2])


Fixed code:
line = input()
nums = line.split(" ")
a = int(nums[0])
b = int(nums[1].replace(".", ""))
print(str(a*b)[:-2] or 0)
Buggy code:
from decimal import *
A,B =map(lambda x:Decimal(x),input().split(' '))
print(A*B)

Fixed code:
from decimal import *
A,B =map(lambda x:Decimal(x),input().split(' '))
print(int(A*B))
Buggy code:
A,B=map(float,input().split(' '))
print(int(A)*(1000*B)//1000)

Fixed code:
A,B=map(float,input().split())
A=int(A)
B=int(B*1000)
print ((A*B)//1000)
Buggy code:
import re

a, b = input().split()
b = b.replace('.','')
a = int(a)
b = int(b)
result = a * b 
float_r = result / 100
print(float_r)

if type(float_r) == int:
  print(float_r)
else:
  print(re.sub('\.[0-9]*','',str(float_r)))

Fixed code:
import re

a, b = input().split()
b = b.replace('.','')
a = int(a)
b = int(b)
result = a * b 
float_r = result // 100

if type(float_r) == int:
  print(float_r)
else:
  print(re.sub('\.[0-9]*','',str(float_r)))
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:
from fractions import Fraction
a, b = input().split()
b = Fraction(b)
ans = Fraction(a*b)
ans = ans // 1
print(int(ans))

Fixed code:
from fractions import Fraction
a, b = input().split()
A = int(a)
B = Fraction(b)
ans = A*B
ans = ans // 1
print(int(ans))
Buggy code:
a, b = input(). split()
a = int(a)
b = b.replace('.', '')
b = int(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:
a, b = map(float, input(). split())
a = int(a)
b = int(b*100)
print(a*b)
print(int(a*b//100))

Fixed code:
a, b = 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 = int(b*1000)
print(a*b)
print(int(a*b//1000))

Fixed code:
a,b = input().split()
 
a = int(a)
b = int(float(b) * 1000)
 
print((a*b)//1000)
Buggy code:
a, b = input().split()
a = int(a)
b = b[0] + b[2:]
print(a*b//100)


Fixed code:
a, b = input().split()
a = int(a)
b = int(b[0]) * 100 + int(b[2:])
print((a * b) // 100)
Buggy code:
import math
from decimal import Decimal, getcontext
a,b=input().split()
a = Decimal(a)
b = Decimal(b)
print(a*b)
print(math.floor(a*b))

Fixed code:
from decimal import *
import math

a, b = input().split()

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

print(math.floor(Decimal(a*b)))
Buggy code:
A,B = input().split()
C = B.split(".")
print(int(A)*float(B[0])+int(A)*float(B[0])//100)

Fixed code:
A,B = input().split()
C = B.split(".")
print(int(A)*int(C[0])+int(A)*int(C[1])//100)
Buggy code:
a,b=input().split()
a=int(a)
print(b)
b=int(b[0] + b[2] + b[3])
print(a * b // 100)


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

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

print(A*B)

Fixed code:
from decimal import Decimal

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

print(int(A*B))
Buggy code:
inputs = input().split()
a = int(inputs[0])
b = inputs[1]
b = 100 * int(b[0]) + 10 * int(b[1]) + int(b[2])

print(int(a * b / 100))

Fixed code:
inputs = input().split()
a = int(inputs[0])
b = inputs[1]
b = 100 * int(b[0]) + 10 * int(b[2]) + int(b[3])

print(a * b // 100)
Buggy code:
#!/usr/bin/env python3
A, B = [s for s in input().split()]
A = int(A)
B = float(B) * 100
 
print(str(A * B // 100))

Fixed code:
#!/usr/bin/env python3
A, B = [s for s in input().split()]
A = int(A)
B = round(float(B) * 100)

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

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


Fixed code:
A, B = input().split()
A = int(A)
B = int(float(B) * 100 + 0.05)
print(A * B // 100)
Buggy code:
A, B = map(float, input().split())
B = (B + 0.1)* 100
B = int(B)
print(int(A) * B // 100)


Fixed code:
A, B = map(float, input().split())
B = B * 100 + 0.1
B = int(B)
print(int(A) * B // 100)
Buggy code:
s = input().split()
a = int(s[0]);
b = int(s[1][0:1]+s[2:len(s[1])])
b *= 100
print(a*b//100)


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

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

b = format(round(b, 2))
print(b)
ans = Decimal(a) * Decimal(b)

print(int(ans))


Fixed code:
from decimal import Decimal
a, b = map(float, input().split())

b = format(round(b, 2))
ans = Decimal(a) * Decimal(b)

print(int(ans))
Buggy code:
# coding: utf-8
# Your code here!

a,b=input().split()
b=list(b)
if a=="0" or b=="0":
    print(0)
else:
    b.remove('.')
    b=''.join(b)
    a=int(a)
    b=int(b)
    c=str(a*b)
    c=list(c)
    del c[-1]
    del c[-1]
    c=''.join(c)
    print(c)


Fixed code:
# coding: utf-8
# Your code here!

a,b=input().split()
b=list(b)
if a=="0" or b=="0":
    print(0)
else:
    b.remove('.')
    b=''.join(b)
    a=int(a)
    b=int(b)
    c=str(a*b)
    if a*b<100:
        print(0)
    else:
        c=list(c)
        del c[-1]
        del c[-1]
        c=''.join(c)
        print(c)
Buggy code:
a,b=input().split()
from decimal import Decimal
ans=Decimal(a)*Decimal(b)
print(int(ans))a,b=input().split()
from decimal import Decimal
ans=Decimal(a)*Decimal(b)
print(int(ans))

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

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

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


Fixed code:
import math
from decimal import *

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

ans = Decimal(Decimal(a * lb) // Decimal(100))
print(int(ans))
Buggy code:
A,B = input().split()
print((int(A)*(100*float(B)))//100)

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

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


Fixed code:
from decimal import *

a, b = input().split()
ans = Decimal(a) * Decimal(b)
print(int(ans))
Buggy code:
st = input().strip().split()

a = int(st[0])
b = 0

for x in st[1]:
  if x == '.':
  else: b = b*10 + x

print(a*b//100)

Fixed code:
st = input().strip().split()
 
a = int(st[0])
b = 0
d = 0
 
for x in st[1]:
  if x == '.':
    d = 1
  else:
    b = b*10 + int(x)
    d = d*10

print(a*b//d)
Buggy code:
from decimal import Decimal
A,B = input().split()
b = Decimal(B)
print(int(A*b))


Fixed code:
from decimal import *
A,B = input().split()
print(int(int(A)*Decimal(B)))
Buggy code:
from decimal import Decimal
Ans = 0
AB = input().split()
A,B = int(AB[0]), Decimal(AB[1])
IB = int(B * 100)
print(A)
print(IB)
Ans = A * IB // 100
print(Ans)

Fixed code:
from decimal import Decimal
Ans = 0
AB = input().split()
A,B = int(AB[0]), Decimal(AB[1])
IB = int(B * 100)
#print(A)
#print(IB)
Ans = A * IB // 100
print(Ans)
Buggy code:
a, b = input().split()
a = int(a)
b.replace('.','')
b = int(b)
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=input().split()
print((int(a)*(100*int(b[0])+10*int(b[2]))+int(b[3]))//100)

Fixed code:
a,b=input().split()
print((int(a)*(100*int(b[0])+10*int(b[2])+int(b[3])))//100)
Buggy code:
A, B = input().split()
A = int(A)
B = float(B)
B = int(B * 1000)
C = A * B
C //= 100
print(C)


Fixed code:
A, B = input().split()
A = int(A)
B = float(B)
B = int(B * 1000)
C = A * B
C //= 1000
print(C)
Buggy code:
import math


def solve():
    A, B = input().split()
    print(int(A) * int(B[-4] + B[-2:])* 100 // 100)


if __name__ == '__main__':
    solve()


Fixed code:
import math


def solve():
    A, B = input().split()
    print(int(A) * int(B[-4] + B[-2:]) // 100)



if __name__ == '__main__':
    solve()
Buggy code:
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import numpy as np
def S(): return input()
def I(): return int(input())
def MS(): return map(str,input().split())
def MI(): return map(float,input().split())
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in input()]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]

A,B = MI()

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

Fixed code:
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import numpy as np
def S(): return input()
def I(): return int(input())
def MS(): return map(str,input().split())
def MI(): return map(float,input().split())
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in input()]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]

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

print(A*B // 100)
Buggy code:
import decimal

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


print((A*B))


Fixed code:
import decimal

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

print(int(A*B))
Buggy code:
import math
A, B = input().split()
A = int(A)

if A == 0 or B == '0.00':
    ans = 0
else:
    ans = A*int(B[0])*100 + A*int(B[2])*10 + A*int(B[3])
    ans = str(ans)
    ans = ans[0:len(ans)-2]
print(ans)

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

if A == 0 or B == '0.00':
    ans = 0
else:
    ans = A*int(B[0])*100 + A*int(B[2])*10 + A*int(B[3])
    ans = str(ans)
    if len(ans)-2 <= 0:
        ans = 0
    else:
        ans = ans[0:len(ans)-2]
print(ans)
Buggy code:
import decimal
a,b = input().split()
print(int(decimai.Decimal(a) * decimal.Decimal(b)))

Fixed code:
import decimal
a,b = input().split()
print(int(decimal.Decimal(a) * decimal.Decimal(b)))
Buggy code:
# -*- coding: utf-8 -*-
a, b = input().split()
b_arr = b.split('.')
b = b_arr[0] + str(int(b_arr[1]) * 100)
print(int(a)*int(b)//100)

Fixed code:
# -*- coding: utf-8 -*-
a, b = input().split()
b_arr = b.split('.')
print(int(a)*int(b_arr[0])+int(a)*int(b_arr[1])//100)
Buggy code:
import math
x,y = list(map(str,input().split()))
yy=y.replace(".","")
print(int(yy))
xy=str(int(x)*int(yy))
print(xy[:len(xy)-2] if len(xy)>2 else 0)


Fixed code:
x,y = list(map(str,input().split()))
yy=y.replace(".","")
xy=str(int(x)*int(yy))
print(xy[:len(xy)-2] if len(xy)>2 else 0)