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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# 0や1のケースに注意
# index out of range
# 貪欲

def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    import math
    #from math import gcd

    #inf = 10**17
    #mod = 10**9 + 7

    c = input().rstrip().split()
    a = int(c[0])
    b = float(c[1])
    print(int(a*b))

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import sys
from math import floor
def input(): return sys.stdin.readline().strip()
mod = 10**9+7

def main():
    a, b = map(float, input().split())
    A = int(a)
    B = int(b * 100)
    x = A * B
    print(x // 100)


    

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
#Multiplication 3
def ABC_169_C():
    A,B= map(float, input().split())
    print(int((A*B)%10000000000000007))

if __name__ == '__main__':

    ABC_169_C()

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 = [ float(v) for v in input().split() ]
print(int((a * b)))

Submission status: Wrong Answer

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

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
#from math import gcd
import bisect
from collections import defaultdict
from collections import deque
from functools import lru_cache


#############
# Constants #
#############

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

#############
# Functions #
#############

######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]

######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()

#####Shorten#####
def DD(arg): return defaultdict(arg)


#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
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

#####MakeDivisors######
def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors

#####MakePrimes######
def make_primes(N):
  max = int(math.sqrt(N))
  seachList = [i for i in range(2,N+1)]
  primeNum = []
  while seachList[0] <= max:
    primeNum.append(seachList[0])
    tmp = seachList[0]
    seachList = [i for i in seachList if i % tmp != 0]
  primeNum.extend(seachList)
  return primeNum

#####GCD#####
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#####BitCount#####
def count_bit(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count

#####ChangeBase#####
def base_10_to_n(X, n):
  if X//n:
    return base_10_to_n(X//n, n)+[X%n]
  return [X%n]

def base_n_to_10(X, n):
  return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))

#####IntLog#####
def int_log(n, a):
  count = 0
  while n>=a:
    n //= a
    count += 1
  return count

#############
# Main Code #
#############
A,B = SL()
A = int(A)
B1 = int(B[0])
B2 = int(B[2])
B3 = int(B[3])

a = A//1000
kuriagari = a*float(B)
kuriagari = int((kuriagari-int(kuriagari)))

print(A*B1+A*B2//10+A*B3//100 + kuriagari)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
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=[x for x in input().split()]
x=float(b).as_integer_ratio()
print((int(a)*x[0])//x[1])

Submission status: Wrong Answer

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

print(math.floor(round(int(A) * float(B), 10)))

Submission status: Wrong Answer

Solution code:
import math
S=list(map(str, input().split()))
a=S[0]
b=S[1]
print(math.floor(int(a)*float(b)))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

print(a * b // 100)

Submission status: Wrong Answer

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

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

print(int(a * b))

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
def main():
    A, B = map(float, input().split())
    ans = int(A) * int(B*100)
    ans = ans//100
    print(ans)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math

def main():
    A,B = [float(x) for x in input().split()]
    print(math.floor(A*B))

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(float,input().split())

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

Submission status: Wrong Answer

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

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

int_float = str(A * B).split(".")
print (int_float[0])

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


# ここから書き始める
def fl(x):
    digits = 5
    form = '%.'+str(digits-1)+'e'
    return float((form % x))

a, b = map(float, input().split())
a = int(a)
b = fl(b)
print(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:
a,b = map(float, input().split())
ans = int(a*b)
  
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:
import math
a, b = input().split()
a = float(a)
b = float(b)
print(math.floor(a*b))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

ans = math.floor(A * B)

print(ans)

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

Submission status: Wrong Answer

Solution code:
import sys
import decimal
from decimal import Decimal

sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7


def input():
    return sys.stdin.readline().strip()


def main():
    A, B = map(float, input().split())
    A = Decimal(A)
    B = Decimal(B)
    ans = A * B
    ans = ans.quantize(decimal.Decimal("1"), rounding=decimal.ROUND_FLOOR)
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import sys
import math
A,B = map(float,input().split())
A = int(A)
if A == 0 or B == 0 :
    print(0)
else:
    ans = A*B
    i = math.floor(ans)-1
    while True : 
        if i <= ans and i+1 > ans:
            print(i)
            sys.exit(0)
        i += 1

Submission status: Wrong Answer

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

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())
print(math.floor(A*B))

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())
b=(A*B)//1
b=int(b)
print(b)

Submission status: Wrong Answer

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

c=int(c)
print(c)

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:
from decimal import Decimal
a,b = map(float,input().split())
a = Decimal(a)
b = Decimal(b)
c = a*b
c = int(c)
print(c)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

list1 = input().split()
N = int(list1[0])
M = float(list1[1])

print(math.floor(N*M))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

B=math.floor(B*10**2)/(10**2)
print(math.floor(A*B))

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

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:
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:
temp = input().split()
a = int(temp[0])
b = int(float(temp[1])*100)
print(int(a*b//100))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

a = int(a)

c = a * b

print(math.floor(c))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

a,b = int(a),float(b)
b *= 100
b = int(b)
if(a==0 or b==0):
    print(0)
    exit()
ans = (a*b)//100
print(ans)

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
nums = input()
s = nums.split(" ")

ans = str(float(s[0]) * float(s[1]))
index = ans.find(".")

print(int(ans[:index]))

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

Submission status: Wrong Answer

Solution code:
import math
n, m = map(float,input().split())
ans = math.floor(n*m)
ans = int(ans)
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
def default():
    a=input()
    a=a.split()
    a[0]=float(a[0])
    a[1]=float(a[1])
    answer=a[0]*a[1]
    answer=int(answer)
    print(answer)
if(__name__=="__main__"):
    default()

Submission status: Wrong Answer

Solution code:
a,b=input().split()
a=int(a)
b=float(b)
B=int(b*100)
c=a*B
if len(str(c))<=2:
  print(0)
else:
  d=str(c)[:len(str(c))-2]
  print(int(d))

Submission status: Wrong Answer

Solution code:
import math

a, b = input().split()

c = float(a) * float(b)

print(math.floor(c))

Submission status: Wrong Answer

Solution code:
import math

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

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:
from decimal import *

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

Submission status: Wrong Answer

Solution code:
def main():
    inStr = input().split()
    A = int(inStr[0])
    B = float(inStr[1])
    B_int = int(B * 100)
    ans = (A * B_int) // 100
    print(ans)


main()

Submission status: Wrong Answer

Solution code:

def main():
    import sys
    def input():
        return sys.stdin.readline()[:-1]

    A,B=map(float,input().split())
    c=int(A*B)
    print(c)
if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

print(int(int(li[0])*float(li[1])))

Submission status: Wrong Answer

Solution code:
import math

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

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

Submission status: Wrong Answer

Solution code:
A,B=map(float,input().split())
s=str(int(A)*int(B*100))
if len(s)<=2:
    print(0)
else:
    print(s[0:-2])

Submission status: Wrong Answer

Solution code:
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(float,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b = M()
ab = a*b
print(math.floor(ab))

Submission status: Wrong Answer

Solution code:
import math

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

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

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:
l=list(input().split())
x=int(l[0])
y=float(l[1])
k=str(x*y)
for i in k:
    if(i=='.'):
        print("")
        break 
    else:
        print(i,end="")

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
a, b= list(map(float, input().split()))
a_=int(a)
b_=int(b*100)
seisu=str(a_*b_)
if len(seisu) < 3:
    print(0)
    exit()
print(seisu[0:len(seisu)-2])

Submission status: Wrong Answer

Solution code:
s=input().replace(" ","*")
t=eval(s)
t=int(t)
print(t)

Submission status: Wrong Answer

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

print(Decimal(str(A*B)).quantize(Decimal("0"),rounding=ROUND_DOWN))

Submission status: Wrong Answer

Solution code:
import math

def main():
  a, b = input().split()
  a = int(a)
  b = float(b)
  ans = a * b
  ans = math.floor(ans)
  print(ans)
 
 
if __name__ == '__main__':
  main()

Submission status: Wrong Answer

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

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


# ここから書き始める
def fl(x):
    digits = 5
    form = '%.'+str(digits-1)+'e'
    return float((form % x))

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

aa = int(a)
bb = int(b*100)

ans = (aa * bb) //100

print(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:
s = input()
a, b = s.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)
B = B*100
print(int(A*B/100))

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

Solution code:
line = input()
nums = line.split(" ")
a = int(nums[0])
b = float(nums[1])
print(int(a*b))

Submission status: Wrong Answer

Solution code:
import math

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

ans = math.floor(A*B)
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from decimal import Decimal

A, B = input().split()

A = Decimal(A)
B = Decimal(int(float(B) * 100))

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
'''
    handle - pruvi007
    questionName - 
    Contest - 
    Topic - 
    Platform - 
'''
from sys import stdin, stdout
from collections import defaultdict

def main():
    a = stdin.readline().split('\n')[0]
    A,B = a.split()
    A = int(A)
    B = float(B)
    import math
    print( math.floor(A*B) )

main()

Submission status: Wrong Answer

Solution code:
def LI():
    return list(map(float, input().split()))

a, b = LI()
a = int(a)
def main():
    ans = a * b
    ans = int(ans)
    print(ans)

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

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

def solve(n):
    pass

def main():
    a,b = invr()
    result = a * b
    print(str(int(result)))

main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
A,B=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=str(a*b).split(".")
print(int(A[0]))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

import math
print(math.floor(a*b))

Submission status: Wrong Answer

Solution code:
a, b = raw_input().split(' ')
b = float(b)
a = int(a)
p  =  (b- float(int(b))) * 100

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

Submission status: Wrong Answer

Solution code:
from decimal import Decimal

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

Submission status: Wrong Answer

Solution code:
import math
import numpy as np

def main():
    #n = int(input())
    a = list( map( float, input().split()))
    print(math.floor(a[0]*a[1]))
    
if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
def mp(): return map(int, input().split())
def lmp(): return list(map(int, input().split()))

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

Submission status: Wrong Answer

Solution code:
import math

a,b = map(float, input().split())
a = int(a)
b = round(b, 2)
ans = math.floor(a*b)
ans = int(ans)
print(ans)

Submission status: Wrong Answer

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

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

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
#from decimal import *
import math

A, B = map(str,input().split())
A = int(A)
B = float(B)
#print(A, B)
#print(A%10)

print(math.floor(A*B))
#print(A*B//1)
'''
A = Decimal(A)
B = Decimal(B)
C = A*B
'''

'''
b = int(B[0])
c = int(B[2])
d = int(B[3])

print(b, c, d)
'''

Submission status: Wrong Answer

Solution code:
nums = input().split()
a = int(nums[0])
b = float(nums[1])

print(int(a*b))

Submission status: Wrong Answer

Solution code:
A, B = map(float, input().split())
ans = list(str(A * B))
dot = ans.index(".")
ans =  "".join(map(str, ans[:dot]))
print(int(ans))

Submission status: Wrong Answer

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

A=int(A)

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

Submission status: Wrong Answer

Solution code:
import math

if __name__ == "__main__":
    a, b = list(input().split())
    a = int(a)
    b = float(b)

    print(int(a*b))