Problem:


Score : 300 points

Problem Statement

Compute A \times B, truncate its fractional part, and print the result as an integer.

Constraints

0 \leq A \leq 10^{15}

0 \leq B < 10

A is an integer.

B is a number with two digits after the decimal point.

Input

Input is given from Standard Input in the following format:

A B

Output

Print the answer as an integer.

Sample Input 1

198 1.10

Sample Output 1

217

We have 198 \times 1.10 = 217.8. After truncating the fractional part, we have the answer: 217.

Sample Input 2

1 0.01

Sample Output 2

0

Sample Input 3

1000000000000000 9.99

Sample Output 3

9990000000000000



Sample input:
198 1.10


Sample output:
217

Submission status: Wrong Answer

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

    print(int(a*b))

Submission status: Wrong Answer

Solution code:
A,B = map(float, input().split())

print(int((A*B)//1))

Submission status: Wrong Answer

Solution code:
import math

A, B = map(float, input().split())
ans = A * B
print(math.floor(ans))

Submission status: Wrong Answer

Solution code:
"""    Arnab Chanda    """

from collections import defaultdict, deque
from itertools import permutations
from sys import stdin,stdout
from bisect import bisect_left, bisect_right
from copy import deepcopy
import heapq

int_input=lambda : int(stdin.readline())
string_input=lambda : stdin.readline().split()
multi_int_input =lambda : map(int, stdin.readline().split())
multi_input = lambda : stdin.readline().split()
list_input=lambda : list(map(int,stdin.readline().split()))
string_list_input=lambda: list(string_input())
MOD = pow(10,9)+7


a, b = multi_input()

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

c = a*b

print(int(c))

Submission status: Wrong Answer

Solution code:
a,b=map(float,input().split())
ans=str(a*b)
print(ans.split(".")[0])

Submission status: Wrong Answer

Solution code:
AB = list(input().split())
A = int(AB[0])
B = float(AB[1])
print(int(A*B))

Submission status: Wrong Answer

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

print(int(int(a)*float(b)))

Submission status: Wrong Answer

Solution code:
a, b = input().split()
a = int(a)
ans = int(a * int(b[0]) + a * int(b[2]) / 10 + a * int(b[3]) / 100)
print(ans)

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

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

Submission status: Wrong Answer

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

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

print(a*b//100)

Submission status: Wrong Answer

Solution code:
import math
A,B=input().split()
A=int(A)
B=float(B)
ans=A*B
ans=math.floor(ans)
print(ans)

Submission status: Wrong Answer

Solution code:
import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()

def resolve():
    A, B = LF()

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

if __name__ == '__main__':
    resolve()

Submission status: Wrong Answer

Solution code:
a,b = map(float,input().strip().split())
print(int(a*b))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
from math import floor

A,B =(float(x) for x in input().rstrip('\n').split())
print(floor(A*B))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
# import sys
import math #sqrt,gcd,pi
# import decimal
# import queue # queue
# import bisect
# import heapq # priolity-queue
# import time
# from itertools import product,permutations,\
#     combinations,combinations_with_replacement
# 重複あり順列、順列、組み合わせ、重複あり組み合わせ
# import collections # deque
# from operator import itemgetter,mul
# from fractions import Fraction
# from functools import reduce

mod = int(1e9+7)
# mod = 998244353
INF = 1<<29
lINF = 1<<35

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

def main():
    a,b = input().split()
    a = int(a)
    b = float(b)
    print(int(a*b))
    return

if __name__=='__main__':
    main()

Submission status: Wrong Answer

Solution code:
a, b = [float(x) for x in input().split()]

print(int(a*b))

Submission status: Wrong Answer

Solution code:
A,B = [float(i) for i in input().split()]
print(int(A*B))

Submission status: Wrong Answer

Solution code:
import sys
import math
import itertools
import collections
import heapq
import numpy as np

rl = sys.stdin.readline

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

Submission status: Wrong Answer

Solution code:
import math
ls = list(input().split())
a = int(ls[0])
b = float(ls[1])

print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
a,b = map(float, input().split())
ans = int((a * b))
print(ans)

Submission status: Wrong Answer

Solution code:
import math
A,B=input().split()
A=float(A)
B=float(B)
ans=math.floor(A*B)
print(ans)

Submission status: Wrong Answer

Solution code:
A, B = input().split(' ')
A = int(A)
B = float(B)
res = A * B
print(int(res))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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


# 入力を整数に変換して受け取る
def input_int():
    return int(input())


# マイナス1した値を返却
def int1(x):
    return int(x) - 1


# 半角スペース区切り入力をIntに変換してMapで受け取る
def input_to_int_map():
    return map(int, input().split())


# 半角スペース区切り入力をIntに変換して受け取る
def input_to_int_tuple():
    return tuple(map(int, input().split()))


# 半角スペース区切り入力をIntに変換してマイナス1した値を受け取る
def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


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

    import math
    return math.floor(float(a) * float(b))

if __name__ == "__main__":
    print(main())

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:

A, B = [float(_) for _ in input().split()]

x = A * B

x = int(x)

print(x)

Submission status: Wrong Answer

Solution code:
a,b = input().split(" ")
a = int(a)
b = float(b)
ans = str(a*b)
print(ans.split('.')[0])

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
import numpy as np

ans = a * b

print(int(ans))

Submission status: Wrong Answer

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

res = int(a) * float(b)

print(int(res))

Submission status: Wrong Answer

Solution code:
a,b=[float(_) for _ in input().split()]

print(int(a*b))

Submission status: Wrong Answer

Solution code:
def main():
    #N=input()
    #A = list(map(int, input().split())) 
    A,B=input().split()
    A=int(A)
    B=float(B)
    ans=A*B
    print(int(ans//1))

main()

Submission status: Wrong Answer

Solution code:
a, b = [float(i) for i in input().split()]
print(int(a * b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
A,B=map(float, input().split())

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

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

Submission status: Wrong Answer

Solution code:
a, b = [float(e) for e in input().split()]
print(int(a*b))

Submission status: Wrong Answer

Solution code:
import sys

sys.setrecursionlimit(10000000)
import os
import math
import bisect
import collections
import itertools
import heapq
import re
import queue

# import fractions

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A, B = fl()
    print(math.floor(A * B))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

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

print(a * b // 100)

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
import math
a, b = map(float, input().split())
result = a*b

print(math.floor(result))

Submission status: Wrong Answer

Solution code:
import sys
#sys.exit()
#sorted( ,reverse=True)
#N = int(input())
S,T = map(str, input().split())
S = int(S)
T = float(T)
#A = list(map(int, input().split()))
#A = [int(input()) for _ in range(N)]

#cnt = 0
#cnt += 1



#print(N)
print(int(S*T))
#print(A)
#print('Yes')
#print('No')
#print(cnt)

Submission status: Wrong Answer

Solution code:
# coding: utf-8

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

print(int(a*b))

Submission status: Wrong Answer

Solution code:
A, B = map(float,input().split())
C = A*B
print(int(C))

Submission status: Wrong Answer

Solution code:
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

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

#処理内容
def main():
	A, B = list(input().split())
	A = int(A)
	B = float(B)
	print(int(A * B // 1))


if __name__ == '__main__':
	main()

Submission status: Wrong Answer

Solution code:
import math

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

print(math.floor(a * b))

Submission status: Wrong Answer

Solution code:

#!/usr/bin/python
# -*- coding: utf-8 -*-

import math

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

print(math.floor(A*B))

Submission status: Wrong Answer

Solution code:
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

s = rs()
A, B = s.split()
A = int(A)
B = float(B)

print(int(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a=list(input().split())
print(int(float(a[0])*float(a[1])))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from decimal import *
A,B = map(float,input().split())
print(int(Decimal(A)*Decimal(B)))

Submission status: Wrong Answer

Solution code:
from math import floor
a, b = map(float, input().split())
b *= 100
print(floor((a*b)//100))

Submission status: Wrong Answer

Solution code:
from decimal import Decimal
from math import ceil
A = list(map(float,input().split()))
print(int(Decimal(A[0]*A[1])))

Submission status: Wrong Answer

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

res = int(a*b)

print(res)

Submission status: Wrong Answer

Solution code:
from math import floor

A, B = map(float, input().split())
print(floor(A * B))

Submission status: Wrong Answer

Solution code:
X, Y = input().split()
X = int(X)
Y = int(float(Y) * 100)
print(X * Y // 100)

Submission status: Wrong Answer

Solution code:
import sys
import math

sys.setrecursionlimit(10 ** 7)

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

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

A = int(A)
ANS = A * B + 10 ** (-12)

print(int(math.floor(ANS)))

Submission status: Wrong Answer

Solution code:
a,b=map(float,input().split())
t=a*b
print(int(t))

Submission status: Wrong Answer

Solution code:
A,B =map(float, input().split())
print(int(A*B))

Submission status: Wrong Answer

Solution code:
from math import sqrt,gcd,ceil 
def ii():return int(input())
def mi():return map(float,input().split())
def li():return list(mi())
def si():return input()

a,b=mi()
print(int(a*b))

Submission status: Wrong Answer

Solution code:
import sys
import math

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

    ans = math.floor(a*b)
    print(ans)
    return


if __name__ == "__main__":
    main()
    sys.exit(0)

Submission status: Wrong Answer

Solution code:
A,B = map(float,input().split())

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

Submission status: Wrong Answer

Solution code:
import math
a, b = map(float, input().split())

print(math.floor(a*b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from __future__ import division, print_function

''' Hey stalker :) '''
INF = 10 ** 10
TEST_CASES = False
from collections import defaultdict, Counter
import math
def main():
    a, b = input().split()
    print(math.floor(int(a)*float(b)))

''' FastIO Footer: PyRival Library, Thanks @c1729 and contributors '''
import os
import sys
from bisect import bisect_left, bisect_right
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
# else:
#     sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")
get_int = lambda: int(input())
get_list = lambda: list(map(int, input().split()))
if __name__ == "__main__":
    if TEST_CASES:
        [main() for _ in range(int(input()))]
    else:
        main()

Submission status: Wrong Answer

Solution code:
import math
a, b = map(float, input().split())
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
t = input().split()
a = int(t[0])
b = int(float(t[1]) * 100)
print(a * b // 100)

Submission status: Wrong Answer

Solution code:
s = input().split()
a = int(s[0])
b = int(float(s[1]) * 100)
print(a * b // 100)

Submission status: Wrong Answer

Solution code:
A = [float(i) for i in input().split()]

ans = int(A[0])*int(A[1]*100)//100
print(int(ans))

Submission status: Wrong Answer

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

answer = a * b

print(int(answer))

Submission status: Wrong Answer

Solution code:
from math import floor
A,B = map(float,input().split())
print(floor(A*B))

Submission status: Wrong Answer

Solution code:
A, B = map(float, input().split())
if A == 0 or B == 0:
    print(0)
else:
    print(int(int(A) * B))

Submission status: Wrong Answer

Solution code:
A, B = list(map(float, input().split()))

print(int(A * B))

Submission status: Wrong Answer

Solution code:
A,B = map(float,input().split())
c = int(A * B)
print(c)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
data = input().split()
A = int(data[0])
B = float(data[1])
ans = A*B
print(int(ans))

Submission status: Wrong Answer

Solution code:
a=list(map(float,input().split()))
print(a[0]*a[1])

Submission status: Wrong Answer

Solution code:
ab = input().split()
a = int(ab[0])
b = float(ab[1])
import math
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
A ,B = map(float, input().split())

print(int(A*B))

Submission status: Wrong Answer

Solution code:
import sys
import copy
from collections import deque
stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces
a, b = na()
print(int(a*b))

Submission status: Wrong Answer

Solution code:
eps = 1e-15

A, B = [float(x) for x in input().strip().split()]
print(int(A*B + eps))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
import math
import itertools
a, b = map(float, input().split())
print(int(a * b))

Submission status: Wrong Answer

Solution code:
"""
N = list(map(int,input().split()))
S = [str(input()) for _ in range(N)]
S = [list(map(int,list(input()))) for _ in range(h)] 
print(*S,sep="")
"""

import sys
sys.setrecursionlimit(10**6)
input = lambda: sys.stdin.readline().rstrip()
inf = float("inf") # 無限

from math import floor

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

Submission status: Wrong Answer

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

import math


def prod_floor(a, b):
    return math.floor(a * b)


def main():
    a, b = (float(x) for x in input().split())
    res = prod_floor(a, b)
    print(res)


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
N,M = map(float,input().split())
import math
print(math.floor(N*M))

Submission status: Wrong Answer

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

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


num=a*b

print(int(num))

Submission status: Wrong Answer

Solution code:
A, B = input().strip().split()
ans = int(int(A) * float(B))
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a, b = input().split()
a = int(a)
b = float(b)*100
print(int(a*b/100))

Submission status: Wrong Answer

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

b = b * 100

res = a * b

res //= 100

print(int(res))

Submission status: Wrong Answer

Solution code:
import sys

# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
import heapq
import decimal
# import statistics
import queue

sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7

ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))


# ===CODE===


def main():
    a, b = input().split()
    a = float(a)
    b = float(b)

    ans = int(a * b)

    print(ans)


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
def solve():
    a,b = map(float, input().split())

    ans = int(a*b)//1

    return ans
    

print(solve())

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
n,k=map(float,input().split())
p=n*k
p=p//1
print(int(p))

Submission status: Wrong Answer

Solution code:
def main():
    a,b = input().split()
    a = int(a)
    b = float(b)
    print(int(a*b))

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
a, b = map(float, input().split())
print(int(a*b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
a,b=[float(i) for i in input().split()]
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
A, B = [float(s) for s in input().split()]
print(int(A * B))

Submission status: Wrong Answer

Solution code:
import sys
readline=sys.stdin.readline
 
A,B=map(float,readline().split())
print(int(A * B))

Submission status: Wrong Answer

Solution code:
def resolve():
    a, b = map(float, input().split())
    b *= 100
    a = int(a)
    b = int(b)
    ans = a* b
    ans //= 100
    print(ans)
resolve()

Submission status: Wrong Answer

Solution code:
a,b = map(float, input().split())
k = b - int(b)
print(int(int(a*k)+a*int(b)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# coding: utf-8
import sys

# from operator import itemgetter
sysread = sys.stdin.readline
read = sys.stdin.read
#from heapq import heappop, heappush
#from collections import defaultdict

sys.setrecursionlimit(10 ** 7)
# import math
# from itertools import product, accumulate, combinations, product
# import bisect# lower_bound etc
#import numpy as np
# from copy import deepcopy
#from collections import deque
#import numba
import math

def run():
    A, B = map(float, input().split())
    A = int(A)
    B = int(B * 100)
    ret = A * B
    print(ret // 100)

if __name__ == "__main__":
    run()

Submission status: Wrong Answer

Solution code:
import math

A, B = map(lambda x: float(x), input().split(" "))

result = math.floor(A*B)

print(result)

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
a = int(a)
b *= 100  # 整数にしておく

ab = a * b / 100

print(int(ab))

Submission status: Wrong Answer

Solution code:
import sys
import math
from collections import deque

sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(float, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()


def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]


#隣接リスト 1-order
def make_adjlist_d(n, edges):
    res = [[] for _ in range(n + 1)]
    for edge in edges:
        res[edge[0]].append(edge[1])
        res[edge[1]].append(edge[0])
    return res


def make_adjlist_nond(n, edges):
    res = [[] for _ in range(n + 1)]
    for edge in edges:
        res[edge[0]].append(edge[1])
    return res


#nCr
def cmb(n, r):
    return math.factorial(n) // math.factorial(r) // math.factorial(n - r)


def main():
    A, B = NMI()
    print(int(A*B//1))


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
from math import trunc
a, b = map(float, input().split())
print(trunc(a * b))

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
import bisect
import numpy as np
import math
from collections import deque
from collections import defaultdict
from math import gcd

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

print(int(A*B))

Submission status: Wrong Answer

Solution code:
from math import floor
a, b = [float(i) for i in input().split()]
print(floor(a * b))

Submission status: Wrong Answer

Solution code:
import sys
# from functools import lru_cache, cmp_to_key
# from heapq import merge, heapify, heappop, heappush
# from math import ceil, floor, gcd
from collections import defaultdict as dd, deque, Counter as C
# from itertools import combinations as comb, permutations as perm
# from bisect import bisect_left as bl, bisect_right as br, bisect
# from time import perf_counter
# from fractions import Fraction
# sys.setrecursionlimit(pow(10, 6))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]


a, b = map(float, input().split())
temp = str(a * b)
index = temp.index('.')
print(temp[:index])

Submission status: Wrong Answer

Solution code:
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))

Submission status: Wrong Answer

Solution code:
A,B = map(float,input().split())
A *= 100
B *= 100
ans = int(A * B // 10000)
print(ans)

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
a, b = [float(x) for x in input().split()]
print(int((a*b)//1))

Submission status: Wrong Answer

Solution code:
# input
A, B = input().split()
A = int(A)
B = float(B)

# output
print(int(A*B))

Submission status: Wrong Answer

Solution code:
import sys
from collections import Counter
from collections import deque
import heapq
import math
import fractions
import bisect
import itertools
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))

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

Submission status: Wrong Answer

Solution code:
from math import floor

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from math import floor
A,B=map(float,input().split())

print(int(floor(A*B)))

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2 * 10**6)


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


def main():

    tA, tB = input().split()
    A = int(tA)
    B = int(100 * float(tB))
    ans = int(A * B) // 100

    print(ans)

    return


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
if __name__ == "__main__":
    A, B = map(float, input().split())
    print(int(A * B))

Submission status: Wrong Answer

Solution code:
from math import floor
A,B = input().split()
A = int(A)
B = float(B)
print(floor(A*B))

Submission status: Wrong Answer

Solution code:
import math
a,b=map(str,input().split())
a=int(a)
b=float(b)
c=math.floor(a*b)
print(c)

Submission status: Wrong Answer

Solution code:
a,b = input().split()
a=int(a)
b=int(float(b)*100)

print(a*b//100)

Submission status: Wrong Answer

Solution code:
A, B = map(float, input().split())



print(int(A*B))

Submission status: Wrong Answer

Solution code:
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
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 = int(float(b) * 100)
ans = a * b // 100
print(ans)

Submission status: Wrong Answer

Solution code:
a,b = map(str,input().split(' '))
x = int(a)
y = float(b)
print(int(x*y))

Submission status: Wrong Answer

Solution code:
from math import floor
from sys import stdin, stdout

int_in = lambda: int(stdin.readline())
arr_in = lambda: [int(x) for x in stdin.readline().split()]
mat_in = lambda rows: [arr_in() for y in range(rows)]
str_in = lambda: stdin.readline().strip()
out = lambda o: stdout.write("{}\n".format(o))
arr_out = lambda o: out(" ".join(map(str, o)))
bool_out = lambda o: out("YES" if o else "NO")
tests = lambda: range(1, int_in() + 1)
case_out = lambda i, o: out("Case #{}: {}".format(i, o))


if __name__ == "__main__":
    parts = str_in().split()
    a = int(parts[0])
    b = float(parts[1])
    out(floor(a*b))

Submission status: Wrong Answer

Solution code:
a,b = [float(i) for i in input().split()]

print(int(a*b))

Submission status: Wrong Answer

Solution code:
# Contest No.: ABC169
# Problem No.: A
# Solver:      JEMINI
# Date:        20200531

import sys
import heapq

def main():
    a, b = map(float, sys.stdin.readline().split())
    ans = int(a * b)
    print(ans)
    return

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import numpy as np
import math
import collections


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

print(int(A * B))

Submission status: Wrong Answer

Solution code:
from math import floor
A,B=map(float,input().split())
A=int(A)
B=int(B*100)
print(A*B//100)

Submission status: Wrong Answer

Solution code:
from sys import exit
import math
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

a=list(input().split())
n = int(a[0])
m = float(a[1])
print(math.floor(n*m))

Submission status: Wrong Answer

Solution code:
import math
a, b = input().split()
a = int(a)
b = float(b)

print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
import math

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

AB = A*B

ans = math.floor(AB)

print(ans)

Submission status: Wrong Answer

Solution code:
A, B = list(map(float, input().split()))

B = int(B * 100)

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

Submission status: Wrong Answer

Solution code:
import math
A,B=map(float,input().split())
print(math.floor(A*B))

Submission status: Wrong Answer

Solution code:
A, B = input().split()
ans = int(int(A)*float(B))
print(ans)