ZhenlongDai/ACPR huggingface dataset:
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = input().split()

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

result = a * round(100 * b) / 100

print(int(result))

Failing test case input:
1011010011100001 9.99

Expected output:
10099990010889009


Actual output:
10099990010889010


Fixed submission (verdict: Accepted):
import decimal

a, b = input().split()

a = int(a)
b = decimal.Decimal(b)

result = a * b

print(int(result))

Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
def main():
    A, B = input().split()
    A ,B = int(A), float(B) 

    print(int(A*B))



if __name__ == "__main__":
    main()


Failing test case input:
1000000110011001 9.99

Expected output:
9990001099009899


Actual output:
9990001099009900


Fixed submission (verdict: Accepted):
def main():

    A, B = input().split()
    A = int(A)
    B100 = int(B[0] + B[2:])
    print(A*B100


if __name__ == "__main__":
    main()

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b = input().split()
print(int(int(a)*float(b)))

Failing test case input:
1010000100000010 9.99

Expected output:
10089900999000099


Actual output:
10089900999000100


Fixed submission (verdict: Accepted):
a,b = input().split()
b = int(float(b)*100+0.5)
print(int(a)*b

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
A, B = map(float, input().split())
B=100*B
A=int(A)
print(math.floor(A*B/100))



Failing test case input:
1000110000000001 9.99

Expected output:
9991098900000009


Actual output:
9991098900000010


Fixed submission (verdict: Accepted):
import math
from decimal import Decimal
A, B = input().split()
B=Decimal(B)
A=int(A)
print(math.floor(A*B))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):



def main():
    import sys
    input = sys.stdin.readline

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


if __name__ == '__main__':
    main()


Failing test case input:
1000000110011011 9.99

Expected output:
9990001099009999


Actual output:
9990001099010000


Fixed submission (verdict: Accepted):



def main():
    from decimal import Decimal
    import sys
    input = sys.stdin.readline

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


if __name__ == '__main__':
    main()

Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
from decimal import Decimal
in_ = list(input().split())
A = int(in_[0])
B = int(float(in_[1]) * 100)
ans = Decimal(A * B)
print(ans)

Failing test case input:
1010010100000101 9.99

Expected output:
10090000899001008


Actual output:
1009000089900100899


Fixed submission (verdict: Accepted):
from decimal import Decimal
in_ = list(input().split())
A = int(in_[0])
B = Decimal(in_[1])
ans = Decimal(A * B)
print(int(ans))
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
A,B=list(map(float,input().split()))
B=100*B
C=A*B
C=math.floor(C/100)
print(C)

Failing test case input:
1011001000101001 9.99

Expected output:
10099899991008999


Actual output:
10099899991009000


Fixed submission (verdict: Accepted):
import math
from decimal import Decimal
A,B=list(map(Decimal,input().split()))
B=100*B
C=A*B
C=math.floor(C/100)
print(C)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal

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

print('{:.0f}'.format(c))


Failing test case input:
1011010000101001 9.99

Expected output:
10099989901008999


Actual output:
10099989901009000


Fixed submission (verdict: Accepted):
from decimal import Decimal, ROUND_DOWN

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

print(Decimal(c).quantize(1, rounding=ROUND_DOWN))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal
from decimal import Decimal, getcontext
import math
a,b = map(float,(input().split()))






b = b * 100

ans = a *b
ans = ans /100
ans = math.floor(ans)

print(ans)


Failing test case input:
1010000110000001 9.99

Expected output:
10089901098900009


Actual output:
10089901098900010


Fixed submission (verdict: Accepted):
from decimal import Decimal
from decimal import Decimal, getcontext
import math
a,b = map(float,(input().split()))








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

ans = math.floor(ans)

print(ans)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal, ROUND_FLOOR

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

ans = a * b

val_floor_d = Decimal(ans).quantize(Decimal('0'), rounding=ROUND_FLOOR)

print(val_floor_d)

Failing test case input:
1000010100000010 9.99

Expected output:
9990100899000099


Actual output:
9990100899000100


Fixed submission (verdict: Accepted):
from decimal import Decimal, ROUND_FLOOR

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

ans = a * b

val_floor_d = ans.quantize(Decimal('0'), rounding=ROUND_FLOOR)

print(val_floor_d)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A, B = input().split()
ans = 0
A = int(A)
B = float(B)*100
ans = A*B
print(int(ans/100))

Failing test case input:
1010110100001101 9.99

Expected output:
10090999899010998


Actual output:
10090999899011000


Fixed submission (verdict: Accepted):
A, B = input().split()
ans = 0
A = int(A)
B = B.replace(".", "")
ans = A*int(B)
print(ans
Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
import sys
input = sys.stdin.readline
import math
def main():
    inp = input().split()
    a = int(inp[0])
    b = int(float(inp[1]) * 100000000000000)
    ans = a * b 
    print(ans)
if __name__ == "__main__":
    main()

Failing test case input:
24 1.10

Expected output:
26


Actual output:
2640000000000000


Fixed submission (verdict: Accepted):
import sys
input = sys.stdin.readline
import math
from decimal import Decimal
def main():
    inp = input().split()
    a = int(inp[0])
    b = Decimal(inp[1])
    ans = a * b
    ans = math.floor(ans)
    print(ans)
if __name__ == "__main__":
    main()

Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
def resolve():
    import sys
    input = sys.stdin.readline
    
    
    
    a, b = map(float, input().split())
    
    
    
    
    
    

    print(int(a*b))


resolve()

Failing test case input:
1011000010000001 9.99

Expected output:
10099890099900009


Actual output:
10099890099900010


Fixed submission (verdict: Accepted):
def resolve():
    import sys
    input = sys.stdin.readline
    from decimal import Decimal
    
    
    

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

    print(int(a*b))


resolve()

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A, B = input().split()
A = int(A)

B = (int(B[0]) - 0) * 100 + (int(B[2]) - 0) * 10 + (int(B[3]) - 0)
print(int(A * B / 100))

Failing test case input:
1001001001101011 9.99

Expected output:
10000000000999099


Actual output:
10000000000999100


Fixed submission (verdict: Accepted):
A, B = input().split()
A = int(A)

B = (int(B[0]) - 0) * 100 + (int(B[2]) - 0) * 10 + (int(B[3]) - 0)
print(A * B

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal
a, b = input().split()
a = int(a)
b = float(b)

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


Failing test case input:
1000000000000001 9.99

Expected output:
9990000000000009


Actual output:
9990000000000010


Fixed submission (verdict: Accepted):
import math
import decimal
a, b = input().split()
a = decimal.Decimal(a)
b = decimal.Decimal(b)
print(math.floor(a * b))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from fractions import Fraction
a, b = map(float, input().split())
ans = a*Fraction(b)
ans = Fraction(ans) 
print(int(ans))

Failing test case input:
1000000110011011 9.99

Expected output:
9990001099009999


Actual output:
9990001099010000


Fixed submission (verdict: Accepted):
from fractions import Fraction
a, b = input().split()
A = int(a)
B = Fraction(b)
ans = A*B
ans = ans 
print(int(ans))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b=map(float,input().split())
a=int(a)
b=int(b*100)

print(int(a*b/100))

Failing test case input:
1011000010000001 9.99

Expected output:
10099890099900009


Actual output:
10099890099900010


Fixed submission (verdict: Accepted):
a,b=map(float,input().split())
a=int(a)
b=int((b+10**-8)*100)
print(a*b
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A = input().split()
a = int(A[0])
b = float(A[1])

an = a*b






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

print(ans)

Failing test case input:
1000100000100001 9.99

Expected output:
9990999000999009


Actual output:
9990999000999010


Fixed submission (verdict: Accepted):
import decimal

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

an = a*b






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

print(ans)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(float, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]




import math
A, B = mi()
A = int(A)
print(int(A*B))

Failing test case input:
1010000101000010 9.99

Expected output:
10089901008990099


Actual output:
10089901008990100


Fixed submission (verdict: Accepted):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(str, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]




import math
from decimal import Decimal

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

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal
A,B = map(str, input().split())
A = int(A)
B = Decimal(B)
print(A * B)

Failing test case input:
24 1.10

Expected output:
26


Actual output:
26.40


Fixed submission (verdict: Accepted):
from decimal import Decimal
A,B = map(str, input().split())
A = int(A)
B = Decimal(B)
print(int(A * B))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = input().split()
a = int(a)
b = float(b)
print(int(a * b))

Failing test case input:
1000011000000001 9.99

Expected output:
9990109890000009


Actual output:
9990109890000010


Fixed submission (verdict: Accepted):
a, b = input().split()
a = int(a)
b = int(float(b) * 100 + 0.1)
print(int(a * b)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import decimal

a, b = input().split()

a = int(a)
b = decimal.Decimal(b)

print(a*b)

Failing test case input:
0010110100001101 9.99

Expected output:
100999899010998


Actual output:
100999899010998.99


Fixed submission (verdict: Accepted):
import decimal
import math
 
a, b = input().split()
 
a = int(a)
b = decimal.Decimal(b)
 
print(math.floor(a*b))
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A, B = list(input().split())
A = int(A)
B = float(B)
print(int(A * B))


Failing test case input:
1000000100000010 9.99

Expected output:
9990000999000099


Actual output:
9990000999000100


Fixed submission (verdict: Accepted):
A, B = list(input().split())
A = int(A)
B = int(B[0] + B[2:])
print((A * B)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
from decimal import Decimal

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

print(math.floor(Decimal(int(a)*b)))

Failing test case input:
1000011000000001 9.99

Expected output:
9990109890000009


Actual output:
9990109890000010


Fixed submission (verdict: Accepted):
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

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

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

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
def main():
    
    
    A, B = map(float,input().split())
    
    if A == 0:
        return 0

    else:
        AB = A*(B*100+0.05)
        return int(AB/100)
        
    
print(main())

Failing test case input:
1010100000000001 9.99

Expected output:
10090899000000009


Actual output:
10091404050000008


Fixed submission (verdict: Accepted):
import decimal

def main():
    
    
    A, B = map(decimal.Decimal,input().split())
    
    if A == 0:
        return 0

    else:
        AB = A*B
        return int(AB)
        
    
print(main())

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

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


Failing test case input:
1000000110001001 9.99

Expected output:
9990001098909999


Actual output:
9990001098910000


Fixed submission (verdict: Accepted):

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

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):


import copy
import random
import bisect 
import fractions 
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) 

d = collections.deque()
def LI(): return list(map(float, sys.stdin.readline().split()))

A, B = LI()
B = B * 100

print(math.floor(A * B / 100))

Failing test case input:
1010000110000001 9.99

Expected output:
10089901098900009


Actual output:
10089901098900010


Fixed submission (verdict: Accepted):


import copy
import random
import bisect 
import fractions 
import math
import sys
import collections
from decimal import Decimal 

mod = 10**9+7
sys.setrecursionlimit(mod) 

d = collections.deque()
def LI(): return list(map(float, sys.stdin.readline().split()))

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

print(math.floor(A * B))
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import io,sys
sys.setrecursionlimit(10**6)

def main():
    s = sys.stdin.readline().rstrip().split()
    a = int(s[0])
    b = float(s[1])
    print(int(a*b))
main()

Failing test case input:
1010000100000010 9.99

Expected output:
10089900999000099


Actual output:
10089900999000100


Fixed submission (verdict: Accepted):
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
main()

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A,B = map(str,input().split())

A = int(A)

B = float(B)*100

print(A*int(B))

Failing test case input:
1011000010000000 9.99

Expected output:
10099890099900000


Actual output:
1009989009990000000


Fixed submission (verdict: Accepted):
A,B = map(str,input().split())

A = int(A)

B = float(B)*1000000

print(int(A*int(B)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math


def main():

    A, B = map(float, input().split())
    A = int(A)
    if A == 0 or int(B) == 0:
        print(0)
        return
    AB = math.floor(A*B)
    print(AB)


if __name__ == '__main__':
    main()


Failing test case input:
1001001000101010 9.99

Expected output:
9999999991009089


Actual output:
9999999991009090


Fixed submission (verdict: Accepted):
from math import floor, ceil
import decimal


def main():

    A, B = map(float, input().split())
    B = round(B, 2)
    A = int(A)
    A = decimal.Decimal(str(A))
    B = decimal.Decimal(str(B))
    AB = A*B
    AB = floor(AB)
    print(AB)


if __name__ == '__main__':
    main()

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

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

print(math.floor(A*B/100))

Failing test case input:
1000010100000010 9.99

Expected output:
9990100899000099


Actual output:
9990100899000100


Fixed submission (verdict: Accepted):
A,B = input().split()
A = int(A)
B = round(float(B)*100)

print(int(A*B

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
a,b = map(float, input().split())
a = int(a)
b = round(b,2)
print(int(a*b))


Failing test case input:
1000100110001001 9.99

Expected output:
9991000098909999


Actual output:
9991000098910000


Fixed submission (verdict: Accepted):
from decimal import Decimal
import math
a,b = map(str, input().split())
b = Decimal(b)
a = int(a)
print(int(a*b))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b = map(float,input().split())
a = int(a)
x =int(b)
y = round(b-x,2)
print(a*x+int(a*y))

Failing test case input:
1000010000000001 9.99

Expected output:
9990099900000009


Actual output:
9990099900000010


Fixed submission (verdict: Accepted):
a,b = map(str,input().split())
a = int(a)
b = int(float(b)*100+0.001)
print(a*b
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
ab = list(input().split())
a = int(ab[0])
b = float(ab[1])

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

Failing test case input:
1010110111001101 9.99

Expected output:
10091000008900998


Actual output:
10091000008901000


Fixed submission (verdict: Accepted):
ab = list(input().split())
a = int(ab[0])
b = int(float(ab[1]) * 1000)

ans = a * b
print(int(ans

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
n=input().split()
a = int(n[0])
b=float(n[1])*100
b= int(b)
ans = a*b

print(ans/100)


Failing test case input:
24 1.10

Expected output:
26


Actual output:
26.4


Fixed submission (verdict: Accepted):
import math
from decimal import Decimal
n=input().split()
a = int(n[0])
b=Decimal(n[1])
ans = a*b

print(int(ans))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A, B = map(float, input().split())

A = int(A)
B = float('{:.2f}'.format(B))
ans = A * B

print(int(ans))

Failing test case input:
1010100000100001 9.99

Expected output:
10090899000999009


Actual output:
10090899000999010


Fixed submission (verdict: Accepted):
A, B = map(str, input().split())

A = int(A)
B1, B2 = map(int, B.split('.'))
ans = (A * B1) + int(A * B2 

print(ans)

Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
A, B = list(map(float, input().split()))

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

print(int(ans_b))


Failing test case input:
1000000100000010 9.99

Expected output:
9990000999000099


Actual output:
999000099900009984


Fixed submission (verdict: Accepted):
A, B = input().split()
B = B.replace('.', '')

A, B = list(map(int, [A, B]))

ans_b = A*B

print(int(ans_b

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import *
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b=STRM()
    a=Decimal(int(a))
    b=Decimal(float(b))
    print(int(a*b))
    
if __name__ == '__main__':
    do()

Failing test case input:
1000000101000001 9.99

Expected output:
9990001008990009


Actual output:
9990001008990010


Fixed submission (verdict: Accepted):
from decimal import *
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b=STRM()
    a=Decimal(int(a))
    b=b[0]+b[2:4]
    b=Decimal(int(b))
    print(a*b
    
if __name__ == '__main__':
    do()
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import sys
import itertools

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))

Failing test case input:
1001000100000010 9.99

Expected output:
9999990999000099


Actual output:
9999990999000100


Fixed submission (verdict: Accepted):
import sys
import itertools

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 = int(float(b) * 100 + 0.5)
print(a * b

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

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

Failing test case input:
1000000110011001 9.99

Expected output:
9990001099009899


Actual output:
9990001099009900


Fixed submission (verdict: Accepted):
import decimal

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

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = map(str, input().split())
b1, b2 = b.split('.')
bb = int(b1) * 100 + int(b2)
print(int((int(a) * bb)/100))

Failing test case input:
1001000100000010 9.99

Expected output:
9999990999000099


Actual output:
9999990999000100


Fixed submission (verdict: Accepted):
a, b = map(str, input().split())
a = int(a)
b1, b2 = b.split('.')
b = int(b1) * 100 + int(b2)
ans = a * b
print(ans

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
a, b = map(float, input().split())
ans = math.floor(a*b)
print(ans)
  

Failing test case input:
1010000000000101 9.99

Expected output:
10089900000001008


Actual output:
10089900000001010


Fixed submission (verdict: Accepted):
from decimal import *
import math
a, b = map(Decimal, input().split())
ans = math.floor(a*b)
print(ans)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

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


print(int(ans/100))

Failing test case input:
198 1.10

Expected output:
217

Actual output:
21780


Fixed submission (verdict: Accepted):
from decimal import *

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

print(int(ans))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from sys import stdin
import math

A, B = input().split(" ")
a = int(A)
b = float(B)
print (math.floor(a*b))


Failing test case input:
1000000000000101 9.99

Expected output:
9990000000001008


Actual output:
9990000000001010


Fixed submission (verdict: Accepted):
from sys import stdin
import math
from decimal import Decimal

A, B = input().split(" ")
a = int(A)
b = Decimal(B)
print (math.floor(a*b))
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b = map(float,input().split())
a = int(a)
print(int(a*b))

Failing test case input:
1010010110000010 9.99

Expected output:
10090000998900099


Actual output:
10090000998900100


Fixed submission (verdict: Accepted):
a,b = map(str,input().split())
a = int(a)
b = int(b.replace(".",""))
print(a*b

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import decimal
import math


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

print(math.floor(decimal.Decimal(a) * decimal.Decimal(b)))


Failing test case input:
1011000010000001 9.99

Expected output:
10099890099900009


Actual output:
10099890099900010


Fixed submission (verdict: Accepted):
import decimal
import math


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

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

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

Failing test case input:
1010000000000101 9.99

Expected output:
10089900000001008


Actual output:
10089900000001010


Fixed submission (verdict: Accepted):
import math
import decimal

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

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
def main():
    a, b = input().split()

    a = int(a)
    b = round(float(b), 2)

    res = a * b

    print(int(res))

if __name__ == '__main__':
    main()

Failing test case input:
1000010100000001 9.99

Expected output:
9990100899000009


Actual output:
9990100899000010


Fixed submission (verdict: Accepted):
def main():
    a, b = input().split()

    a = int(a)
    b = int(round(float(b) * 100, 0))

    res = a * b

    print(int(res 

if __name__ == '__main__':
    main()

Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
def main():
    a, b = input().split()
    a = int(a)
    b = float(b)
    print(int(a * b))

if __name__ == '__main__':
    main()

Failing test case input:
1000000101000001 9.99

Expected output:
9990001008990009


Actual output:
9990001008990010


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

if __name__ == '__main__':
    main()

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal
import math
a,b = map(Decimal,input().split())
ans = a*b
print(ans)
print(math.floor(ans))

Failing test case input:
1010000101000010 9.99

Expected output:
10089901008990099


Actual output:
10089901008990099.90
10089901008990099


Fixed submission (verdict: Accepted):
from decimal import Decimal
import math
a,b = map(Decimal,input().split())
ans = a*b
print(math.floor(ans))
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

def main():
    A,B=map(str, input().split(" "))
    A = int(A)
    B = float(B)
    A_B_mul = A * B
    
    
    print(str(A_B_mul).split(".")[0])
    
if __name__ == "__main__":
    main()


Failing test case input:
1100110000100001 9.99

Expected output:
10990098900999009


Actual output:
1


Fixed submission (verdict: Accepted):
def main():
    A,B=map(str, input().split(" "))
    A = int(A)
    B = int(B.split(".")[0] + B.split(".")[1])
    mul_AB = A * B
    if mul_AB < 100:
        print(0)
    else:
        print(str(mul_AB)[:-2])

    
if __name__ == "__main__":
    main()

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
s = input().split()
a=int(s[0]);b=float(s[1])
print(int(math.floor(a*b)))

Failing test case input:
1011011000101001 9.99

Expected output:
10099999891008999


Actual output:
10099999891009000


Fixed submission (verdict: Accepted):
from decimal import Decimal
s = input().split()
a=int(s[0]);b=Decimal(s[1])
print(int(a*b))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
a,b = map(float,input().split())
print (int(math.floor(a*b)))


Failing test case input:
1010000000000101 9.99

Expected output:
10089900000001008


Actual output:
10089900000001010


Fixed submission (verdict: Accepted):
import math
from decimal import Decimal
a,b = map(Decimal, input().split())
print (math.floor(a*b))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A, B = input().split()

print(int(int(A) * float(B)))

Failing test case input:
1010110011001101 9.99

Expected output:
10090999009900998


Actual output:
10090999009901000


Fixed submission (verdict: Accepted):
A, B = input().split()

print(int(A) * round(float(B) * 100)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal
a,b=input().split()
print(int(a)*Decimal(b))

Failing test case input:
1000000110000101 9.99

Expected output:
9990001098901008


Actual output:
9990001098901008.99


Fixed submission (verdict: Accepted):
from decimal import Decimal
a,b=input().split()
print(int(int(a)*Decimal(b)))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b = input().split()
a = int(a)
b = float(b)
print(int(a*(b*100)/100))

Failing test case input:
1011000010000001 9.99

Expected output:
10099890099900009


Actual output:
10099890099900010


Fixed submission (verdict: Accepted):
a,b = input().split()
a = int(a)
b = b[:-3] + b[-2:]
b = int(b)
print(a*b
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal, ROUND_DOWN
a,b = input().split()
a = int(a)
b = float(b)
x = a*b
print(x)
if x < 10**15:
  d = Decimal(str(x))
  y = d.quantize(Decimal('0'), rounding=ROUND_DOWN)
  print(y)  
else:
  print(1)

Failing test case input:
1010001000100101 9.99

Expected output:
10089909991000008


Actual output:
1.008990999100001e+16
1


Fixed submission (verdict: Accepted):
from decimal import Decimal, ROUND_DOWN
a,b = input().split()
a = int(a)
b = Decimal(b)
x = Decimal(a*b)
d = Decimal(str(x))
y = d.quantize(Decimal(str(0)), rounding=ROUND_DOWN)
print(y)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b=map(float,input().split())
print(int(a*(round(b*100)/100)))

Failing test case input:
1000110000100001 9.99

Expected output:
9991098900999009


Actual output:
9991098900999010


Fixed submission (verdict: Accepted):
a,b=input().split()
print(int(a)*round(float(b)*100)

Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
import math

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

res = int(math.floor(A * B + 1e-5))
print(res)


Failing test case input:
1000010100000001 9.99

Expected output:
9990100899000009


Actual output:
9990100899000010


Fixed submission (verdict: Accepted):
import math

A, B = input().split()
A = int(A)
B = float(B)
B = int(B * 100 + 1e-5)

res = int(math.floor((A * B) 
print(res)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

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

b *= 100

ans = (a * b) 

print(ans)

Failing test case input:
0010010100001101 9.99

Expected output:
100000899010998


Actual output:
1.00000899010999e+16


Fixed submission (verdict: Accepted):
a, b = map(float, input().split())

a = int(a)

b *= 100
b = round(b)

print(a*b

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal
import math

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


A = int(aaa[0])
B = aaa[1]


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


Failing test case input:
1010000110000001 9.99

Expected output:
10089901098900009


Actual output:
10089901098900010


Fixed submission (verdict: Accepted):
from decimal import Decimal
import math


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








print(int(Decimal("{}".format(aaa[0])) * Decimal("{}".format(aaa[1]))))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A,B=map(float,input().split())

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


Failing test case input:
1000011000000001 9.99

Expected output:
9990109890000009


Actual output:
9990109890000010


Fixed submission (verdict: Accepted):
from decimal import *
A,B=map(Decimal,input().split())

c=int(A*B)
print(c)
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

def main():
    A,B=map(str, input().split(" "))
    A = int(A)
    B = int(float(B) * 100)
    A_B_mul = A * B
    
    
    print(int(A_B_mul / 100))
    
if __name__ == "__main__":
    main()


Failing test case input:
1001001001101011 9.99

Expected output:
10000000000999099


Actual output:
10000000000999100


Fixed submission (verdict: Accepted):
def main():
    A,B=map(str, input().split(" "))
    A = int(A)
    B = int(B.split(".")[0] + B.split(".")[1])
    mul_AB = A * B
    if mul_AB < 100:
        print(0)
    else:
        print(str(mul_AB)[:-2])

    
if __name__ == "__main__":
    main()

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = map(float, input().split())
a = int(a)
print(int(a*b))


Failing test case input:
1010000100000101 9.99

Expected output:
10089900999001008


Actual output:
10089900999001010


Fixed submission (verdict: Accepted):
a, b = input().split()
b = int(b.replace(".", ""))
a = int(a)
print(a*b

Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter

from functools import lru_cache

sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7


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


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


def str_inp():
    
    return list(input()[:-1])


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


Failing test case input:
1000000101000001 9.99

Expected output:
9990001008990009


Actual output:
9990001008990010


Fixed submission (verdict: Accepted):
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter

from functools import lru_cache

sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7


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


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


def str_inp():
    
    return list(input()[:-1])


a, b = input().split()
a = int(a)
b = list(b)
dot = 0
for i in range(len(b)):
    if b[-i - 1] == ".":
        dot = i
        del b[-1 - i]
        b = int("".join(b))
        break
ans = str(a * b)
if len(ans) <= dot:
    ans = 0
else:
    ans = ans[:-dot]
print(ans)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from math import floor
a, b = input().split()
a = int(a)
b = float(b)


print(floor(a * b))

Failing test case input:
1000110001000001 9.99

Expected output:
9991098909990009


Actual output:
9991098909990010


Fixed submission (verdict: Accepted):
from math import floor
import decimal
a, b = input().split()
a = int(a)
b = decimal.Decimal(b)


print(floor(a * b))
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import *
from math import *

getcontext().prec = 100
a, b = map(Decimal, map(float, input().split()))
print(floor(a * b))





Failing test case input:
1000000111001011 9.99

Expected output:
9990001108900099


Actual output:
9990001108900100


Fixed submission (verdict: Accepted):
from decimal import *
from math import *

getcontext().prec = 10000
a, b = map(Decimal, input().split())
print(floor(a * b))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

A, B = input().split()

a = int(A)
b = float(B)

c = a * b

p = math.floor(c)
C = int(p)
print(C)


Failing test case input:
1010000101000010 9.99

Expected output:
10089901008990099


Actual output:
10089901008990100


Fixed submission (verdict: Accepted):
import math
import decimal

A, B = input().split()

a = int(A)
b = decimal.Decimal(B)

c = a * b

p = math.floor(c)
C = int(p)
print(C)

Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
A,B=input().split()
A=int(A)
B=float(B)

print(int(A*B))


Failing test case input:
1100110000100001 9.99

Expected output:
10990098900999009


Actual output:
10990098900999010


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

print((A*B)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = input().split()

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

print(int(result))

Failing test case input:
1000001000101010 9.99

Expected output:
9990009991009089


Actual output:
9990009991009090


Fixed submission (verdict: Accepted):
import decimal

a, b = input().split()

a = int(a)
b = decimal.Decimal(b)

result = a * b

print(int(result))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A,B=map(str,input().split())
A=int(A)
B=float(B)
print(int(A*B))

Failing test case input:
1000010100000010 9.99

Expected output:
9990100899000099


Actual output:
9990100899000100


Fixed submission (verdict: Accepted):
import decimal
A,B=map(str,input().split())
A=int(A)
B=decimal.Decimal(B)
print(int(A*B))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal
a,b = map(str,input().split())

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


print(round(ans))


Failing test case input:
1000010100000101 9.99

Expected output:
9990100899001008


Actual output:
9990100899001009


Fixed submission (verdict: Accepted):
from decimal import Decimal
a,b = map(str,input().split())

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


print(int(ans))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
from decimal import Decimal

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

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

Failing test case input:
1000011000000001 9.99

Expected output:
9990109890000009


Actual output:
9990109890000010


Fixed submission (verdict: Accepted):
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

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

print(math.floor(int(a)*round(Decimal(b),2)))
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal
A,B=input().split()
A=int(A)
B=Decimal(float(B))
print(int(A*B))

Failing test case input:
1000000110001001 9.99

Expected output:
9990001098909999


Actual output:
9990001098910000


Fixed submission (verdict: Accepted):
from math import floor
from decimal import Decimal
A,B=input().split()
A=int(A)
B=Decimal(B)
print(floor(A*B))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
a,b = input().split()
a = int(a)
b = float(b) * 100
print(int(a * b / 100))

Failing test case input:
1010100000000001 9.99

Expected output:
10090899000000009


Actual output:
10090899000000010


Fixed submission (verdict: Accepted):
import math
a,b = input().split()
a = int(a)
b = round(float(b) * 100)
print(a * b

Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
ab = input().split()

a = int(ab[0])
b = float(ab[1])

print(int(a*b))

Failing test case input:
1000000111001011 9.99

Expected output:
9990001108900099


Actual output:
9990001108900100


Fixed submission (verdict: Accepted):
ab = input().split()
a = int(ab[0])
b = str(ab[1])

b = b.replace(".", "")

print(a*int(b)

Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
def resolve():
    a, b = map(float, input().split())
    from math import floor
    print(floor(a * b))


if __name__ == '__main__':
    resolve()


Failing test case input:
1000000110011011 9.99

Expected output:
9990001099009999


Actual output:
9990001099010000


Fixed submission (verdict: Accepted):
def resolve():
    from fractions import Fraction
    a, b = map(Fraction, input().split())
    ans = a * b
    ans = int(ans)
    print(ans)


if __name__ == '__main__':
    resolve()

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = map(float, input().split())
print(int(a * b))


Failing test case input:
1011000010000001 9.99

Expected output:
10099890099900009


Actual output:
10099890099900010


Fixed submission (verdict: Accepted):
a, b = map(int, input().replace('.', '').split())
print(a*b

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = input().split()

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

print(int(result))

Failing test case input:
1000000111011011 9.99

Expected output:
9990001108999999


Actual output:
9990001109000000


Fixed submission (verdict: Accepted):
import decimal

a, b = input().split()

a = int(a)
b = decimal.Decimal(b)

result = a * b

print(int(result))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A,B=map(float,input().split())
print(int(A*B))

Failing test case input:
1010000000100101 9.99

Expected output:
10089900001000008


Actual output:
10089900001000010


Fixed submission (verdict: Accepted):
A,B=map(float,input().split())
A =int(A)
B=round(100*B)
print(A*B
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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())
print(int(a*b))


Failing test case input:
1000000101000001 9.99

Expected output:
9990001008990009


Actual output:
9990001008990010


Fixed submission (verdict: Accepted):
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

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
lis = input().split()
a = int(lis[0])
b = float(lis[1])
b *= 100.0
b = int(b)
ans = a*b
ans 
print(ans)

Failing test case input:
17 1.10

Expected output:
18


Actual output:
1870


Fixed submission (verdict: Accepted):
a,b = input().split()
a = int(a)
b = float(b)
b *= 1000
b = int(b)
print((a*b)

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = input().split()
a = int(a)
b = list(map(int, b.split('.')))
b = b[0]*100+b[1]
import math

ans = math.floor(a*b/100)
print(ans)

Failing test case input:
1001001000101010 9.99

Expected output:
9999999991009089


Actual output:
9999999991009090


Fixed submission (verdict: Accepted):
a, b = input().split()
a = int(a)
b = list(map(int, b.split('.')))
b = b[0]*100+b[1]
ans = a*b
if ans<100:
  print(0)
else:
  print(str(ans)[:-2])

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
A, B = input().split()
A = float(A)
B = float(B)

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



Failing test case input:
1010000000000001 9.99

Expected output:
10089900000000009


Actual output:
1.008990000000001e+16
10089900000000010


Fixed submission (verdict: Accepted):
from decimal import Decimal
import math
A, B = input().split()
A = Decimal(A)
B = Decimal(B)

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

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
inputs = list(map(lambda x:float(x), input().split()))
multiple = int(inputs[0]) * float(inputs[1])

multiple_str = str(multiple)
if '.' in multiple_str:
    ans = int(multiple_str.split('.')[0])
else:
    ans = int(multiple_str)

print(ans)



Failing test case input:
1000010100000101 9.99

Expected output:
9990100899001008


Actual output:
9990100899001010


Fixed submission (verdict: Accepted):
from decimal import Decimal

inputs = list(map(lambda x:Decimal(x), input().split()))
multiple = inputs[0] * inputs[1]

multiple_str = str(multiple)
if '.' in multiple_str:
    ans = int(multiple_str.split('.')[0])
else:
    ans = int(multiple_str)

print(ans)
Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal
a, b = map(float, input().split())
print(int(Decimal(a) * Decimal(b)))

Failing test case input:
1001000110000101 9.99

Expected output:
9999991098901008


Actual output:
9999991098901009


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

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from sys import stdin
import math
A, B = [float(x) for x in stdin.readline().rstrip().split()]
print(math.floor(A * B))

Failing test case input:
1000000110011011 9.99

Expected output:
9990001099009999


Actual output:
9990001099010000


Fixed submission (verdict: Accepted):
from sys import stdin
from decimal import Decimal
import math
A, B = [Decimal(x) for x in stdin.readline().rstrip().split()]
print(int(math.floor(A * B)))

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
AB = list(input().split())

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

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


ans = int(A * B)

print(ans)

Failing test case input:
1001001000101010 9.99

Expected output:
9999999991009089


Actual output:
9999999991009090


Fixed submission (verdict: Accepted):
AB = list(input().split())
 
A = int(AB[0])
B = float(AB[1])
 
B = round(B * 100)
 
ans = int(A * B 
 
print(ans)

Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
import sys
input = sys.stdin.readline
import math
def main():
    inp = input().split()
    ans = int(inp[0])*float(inp[1])
    ans = math.floor(ans)
    print(ans)
if __name__ == "__main__":
    main()

Failing test case input:
1010100000000001 9.99

Expected output:
10090899000000009


Actual output:
10090899000000010


Fixed submission (verdict: Accepted):
import sys
input = sys.stdin.readline
import math
from decimal import Decimal
def main():
    inp = input().split()
    a = int(inp[0])
    b = Decimal(inp[1])
    ans = a * b
    ans = math.floor(ans)
    print(ans)
if __name__ == "__main__":
    main()
Problem: p02659
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
import sys
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
MOD = 10**9 + 7

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

Failing test case input:
1011010001100001 9.99

Expected output:
10099989910989009


Actual output:
10099989910989010


Fixed submission (verdict: Accepted):
import sys
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
MOD = 10**9 + 7


a, b = input().split()
a = int(a)
b1 = int(b[:-3])
b2 = int(b[-2:])
print(a*b1+a*b2

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from decimal import Decimal

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





print(int(a*b))




 

Failing test case input:
1010110111001101 9.99

Expected output:
10091000008900998


Actual output:
10091000008901000


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







print(A*B

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
import sys
input = sys.stdin.readline

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

main()

Failing test case input:
1000110000100001 9.99

Expected output:
9991098900999009


Actual output:
9991098900999010


Fixed submission (verdict: Accepted):
from decimal import Decimal
import sys
input = sys.stdin.readline

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

main()

Problem: p02659
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

A, B = input().split()

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

result = A * B

print(math.floor(result))

Failing test case input:
1000110000000001 9.99

Expected output:
9991098900000009


Actual output:
9991098900000010


Fixed submission (verdict: Accepted):
import math
from decimal import Decimal


A, B = input().split()

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

result = Decimal(A * B)

print(math.floor(result))