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:
def examA():
    A, B = LI()
    ans = A*B
    print(ans)
    return

def examB():
    N = I()
    A = LI()
    for a in A:
        if a==0:
            print(0)
            return
    ans = 1
    for a in A:
        ans *= a
        if ans>10**18:
            print(-1)
            return
    print(ans)
    return

def examC():
    A, B = list(map(float,input().split()))
    ans = (int(A*B*100))//100
    print(ans)
    return

def examD():
    def factorization(n):
        arr = defaultdict(int)
        temp = n
        for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
            if temp % i == 0:
                cnt = 0
                while temp % i == 0:
                    cnt += 1
                    temp //= i
                arr[i] = cnt
        if temp != 1:
            arr[temp] = 1
        if arr == []:
            arr[n] = 1
        return arr
    C = [0,1,3,6,10,15,21,28,36,45]
    N = I()
    F = factorization(N)
    ans = 0
    #print(F)
    for f in F.values():
        for i in range(10):
            if C[i]>f:
                ans += i-1
                break
    print(ans)
    return

def examE():
    N = I()

    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 1<<60
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examC()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

Submission status: Wrong Answer

Solution code:
N, M = input().split()
N = int(N)
M = float(M)
M = int(100*M)

ans = int(N *M)
print(ans//100)

Submission status: Wrong Answer

Solution code:
import math

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

c = a*b
c /= 10
print(math.floor(c))

Submission status: Wrong Answer

Solution code:
import math

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

print(math.floor(N * B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
X,Y=list(map(float,input().split()))

print(int(X*Y))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
x,y = map(float,input().split())
import math

print(math.floor(x*y))

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

Submission status: Wrong Answer

Solution code:
import math
a, b = list(map(float,input().split()))
c = a * b
decimal , whole = (math.modf(c))
print(int(whole))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
N = [float(e) for e in input().split()]
ans = (N[0]*N[1])//1
print(math.floor(ans))

Submission status: Wrong Answer

Solution code:
a, b = input().split()
a = int(a)
b = float(b)
b1 = int(b)
b2 = b - int(b)
s1 = a*b1
s2 = int(a*b2)
print(int(s1+s2), end="")

Submission status: Wrong Answer

Solution code:
import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)

a,b = map(float,ipt().split())
a = int(a)
a100 = a//100
b1 = int(b*100)
a1 = a-a100*100
print(a100*b1+int(a1*b))

Submission status: Wrong Answer

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

from decimal import Decimal
from fractions import Fraction
import math
ans = Decimal.from_float(a)*Decimal.from_float(b)

print(math.floor(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import numpy as np
A, B = input().split()
A = np.array(A).astype(np.float64)
B = np.array(B).astype(np.float64)

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:
# -*- coding: utf-8 -*-
a,b = list(map(float,input().split()))

b*=100

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)



def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1             # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a, b = map(float, input().split())
    print(int(a * b))


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
x,y = map(str,input().split()) 
X = int(x)
Y = float(y)
print(int(X*Y//1))

Submission status: Wrong Answer

Solution code:
if __name__ == '__main__':
    a = [float(i) for i in input().split()]
    c=int(a[0]) * int((a[1]*100))
    print((c//100))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import math

inlist = input().split()
num1 = float(inlist[0])
num2 = float(inlist[1])


print(math.floor(num1*num2))

Submission status: Wrong Answer

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

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:
import math
A, B = list(map(float,input().split()))
f_B = math.floor(B)
round_B = round(B - f_B, 2)
ans = A * f_B + A * round_B
ans = int(ans)
print(ans)

Submission status: Wrong Answer

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

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 = int(a) * b

print(int(math.floor(ans)))

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:
import math
A,B = map(str,input().split())
A = int(A)
B = int(float(B)*100)
print(math.floor(A*B/100))

Submission status: Wrong Answer

Solution code:
split_str = input().split()

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

b_int_part = int(b)
b_dec_part = b - b_int_part

print(a * b_int_part + int(a * b_dec_part))

Submission status: Wrong Answer

Solution code:
x,y=input().split()
a=int(x)
b=float(y)
c=a*b
ans=int(c//1)
print(ans)

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sun May 31 21:07:49 2020

@author: NEC-PCuser
"""

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

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

Submission status: Wrong Answer

Solution code:
a, b = input().split()
a = int(a)
b = int(float(b) * 100)
result = str(a * b)
if len(result) >= 3:
    print(result[:-2])
else:
    print(0)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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:
# -*- coding: utf-8 -*-
import math
a, b = map(float,input().split())

#print(a, b)
print(math.floor(int(a) * b))
#print(int((a * b) // 1))

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:
# import math
A, B = [x for x in input().split(" ")]
A = int(A)
B = int(float(B) * 100) / 100

print(int(A * B))

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
import sys
import math


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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
input_line1 = input()
numbers = input_line1.split()
temp = int(numbers[0]) * float(numbers[1])
sum_num = int(temp // 1)

print(sum_num)

Submission status: Wrong Answer

Solution code:
import math

a, b = input().split()
a = int(a)
b = float(b)
ans = float(a)*b
print("{:.0f}".format(ans))

Submission status: Wrong Answer

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

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

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
# coding: utf-8


def solve(*args: str) -> str:
    a, b = args[0].split()
    a = int(a)
    b = int(100*float(b))

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


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from collections import defaultdict
from math import gcd
import time
import sys
from collections import Counter
import itertools
import math
# read = sys.stdin.buffer.read
# readline = sys.stdin.buffer.readline
# readlines = sys.stdin.buffer.readlines
input = sys.stdin.readline

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
x=input().split(" ")  
n=float(x[0])  
m=float(x[1]) 
ans=int(n*m)
print(ans)

Submission status: Wrong Answer

Solution code:
import numpy as np
import math
import scipy as sp
import queue
import collections

MOD = 10 ** 9 + 7
INF = 10 ** 9

def main(kwargs):
    a = kwargs["a"]
    b = kwargs["b"]
    res = int(a * b)
    return res

if __name__ == "__main__":
    kwargs = {}

    cin = input().split()
    kwargs["a"], kwargs["b"] = [float(i) for i in cin]

    cout = main(kwargs)
    print(cout)

Submission status: Wrong Answer

Solution code:
def main():
    A, B = (float(i) for i in input().split())
    a = int(A)
    b = int(B * 100)
    print(int(a*b/100))


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:
a,b=map(str,input().split())
print(int(int(a)*float(b)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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:
#import math
#N=int(input())
A,B = map(float,input().split())
#N=int(input())
#A = list(map(int,input().split()))
#S=str(input())
A=int(A)

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

Submission status: Wrong Answer

Solution code:
import math

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

B=B*100

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

Submission status: Wrong Answer

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

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:
A, B = map(float, input().split())
print(int((A * B) // 1))

Submission status: Wrong Answer

Solution code:
import math

nums = input().split(' ')
a = int(nums[0])
b = float(nums[1])

print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
#n = int(input())
#a,b = map(int,input().split())
#a_L = list(map(int,input().split()))

#n = int(input())
a,b = map(float,input().split())
b = int(b*100)
a = int(a)
#a_L = list(map(int,input().split()))

print(int(a*b/100))

Submission status: Wrong Answer

Solution code:
#atcoder template
def main():
    import sys
    imput = sys.stdin.readline
    #文字列入力の時は上記はerrorとなる。
    #ここにコード
    #input
    A, B = map(float, input().split())

    #output
    print(int(A*B))

    #N = 1のときなどcorner caseを確認！
if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys

sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
S = input().split()
A = int(S[0])
B = float(S[1])
B*=100
B = int(B)
ans = int((A*B)/100)


print(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:
def main():
    #n = int(input())
    a = list( map( float, input().split()))
    print(int(a[0]*a[1]))
    
if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:

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

import math

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

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

Submission status: Wrong Answer

Solution code:
###############################################################################
#Imports
import collections
import itertools
from functools import lru_cache
import sys
import math
###############################################################################
#Constants
MOD = int(1e9)+7
###############################################################################
#Helper
def helper():
	pass
###############################################################################
#Solver
def solve():
	a, b = input().split(' ')
	a, b = float(a), float(b)
	deci, frac = str(a * b).split('.')
	print(deci)

###############################################################################
#Driver
t = 1
for _ in range(t):
	solve()
###############################################################################

Submission status: Wrong Answer

Solution code:
import sys
import math
 
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
 
def main():
  a,b = map(float,input().split())
  print(math.floor(a * b))

if __name__ == '__main__':
  main()

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 sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

import math

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

print(a*b//100)

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
from decimal import Decimal
import math
a, b = map(Decimal, map(float, input().split()))

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

Submission status: Wrong Answer

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

print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from decimal import Decimal
A, B = input().strip().split()

ans = Decimal(int(A)) * Decimal.from_float(float(B))

print(int(ans))

Submission status: Wrong Answer

Solution code:
import math

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

b1 = int(b[0])
b2 = int(b[2])
b3 = int(b[3])

ans = a * b1 + a * b2 / 10 + a * b3 / 100
print(math.ceil(ans))

Submission status: Wrong Answer

Solution code:
from math import floor

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

ans = A * B
ans = floor(ans)

print(ans)

Submission status: Wrong Answer

Solution code:
import math
a,b = map(float,input().split())
c = a*b%1
# print(c)
s = a*b-c
print(math.floor(b*a))

Submission status: Wrong Answer

Solution code:
# env/bin/local python3

import math

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

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

Submission status: Wrong Answer

Solution code:
n,m = map(float,input().split())

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

Submission status: Wrong Answer

Solution code:
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd, cos, radians, floor
from functools import lru_cache, reduce
from decimal import *
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)

# UnionFind
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

# ダイクストラ
def dijkstra_heap(s, edge, n):
    #始点sから各頂点への最短距離
    d = [10**20] * n
    used = [True] * n #True:未確定
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        #まだ使われてない頂点の中から最小の距離のものを探す
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d

# 素因数分解
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

# 2数の最小公倍数
def lcm(x, y):
    return (x * y) // gcd(x, y)

# リストの要素の最小公倍数
def lcm_list(numbers):
    return reduce(lcm, numbers, 1)

# リストの要素の最大公約数
def gcd_list(numbers):
    return reduce(gcd, numbers)

# 素数判定
def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True


# limit以下の素数を列挙
def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P

# 同じものを含む順列
def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        # set（集合）型で重複を削除、ソート
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret


# ここから書き始める
getcontext().prec = 100
a, b = map(float, input().split())
a = Decimal(a)
b = Decimal(b)
ans = a * b
# print(type(ans))
print(floor(ans))

Submission status: Wrong Answer

Solution code:
a,b=map(str,input().split())
a=int(a)
c,d=map(int,b.split("."))
print(a*c+int(d*a/100))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(10000000)
from collections import defaultdict
import math

a, b = input().split()
print(int(int(a) * (float(b) + 10**-16)))

Submission status: Wrong Answer

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

a = int(A)
b = int(B * 100)

ab = a * b

AB = str(ab)

print(AB[:-2])

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
data = input().rstrip().split(" ")
calc = float(data[0])*float(data[1])
print(math.floor(calc))

Submission status: Wrong Answer

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

print(int(a * ba / 100))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
x=input().split()
a=int(x[0])
b=float(x[1])
c=str(a*b)
d=[]
i=c.index('.')
print(c[:i])

Submission status: Wrong Answer

Solution code:
import math

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

if __name__ == "__main__":
  main()

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math
import sys
a,b=map(float,input().split())
if a ==0 or b==0:
    print(0)
    sys.exit()
ans=math.floor(a*b)
print(int(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import math

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

ans = a*b
f, i = math.modf(ans)
ans -= f
print(str(ans).split(".")[0])

Submission status: Wrong Answer

Solution code:
import math

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

ab = a*b
#print(ab)
ac = math.floor(ab)
print(ac)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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