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:
#!/usr/bin/env python3
import sys

input = sys.stdin.readline


def S():
    return input().rstrip()


def I():
    return int(input())


def MI():
    return map(float, input().split())


a, b = MI()

print(int(a * b))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
arr = [float(s) for s in input().split()]
a = arr[0]
b = arr[1]
res = a * b
print(int(res))

Submission status: Wrong Answer

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

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:
import math
A, B = input().rstrip().rsplit()
A = int(A)
B = float(B)

print(math.floor(A*B))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
import math

A, B = (float(x) for x in input().split())
print(math.floor(A*B))

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

ans = ((a * _b) // 100)

print(ans)

Submission status: Wrong Answer

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

import math
from decimal import Decimal

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:

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

if __name__ == "__main__":
    resolve()

Submission status: Wrong Answer

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

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:
ab = input('')
a = int(ab.split(' ')[0])
b = float(ab.split(' ')[1])
import math
result =  math.floor(a*b)

print(int(result))

Submission status: Wrong Answer

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

ai = int(a)
bf = float(b)
 
from math import floor
print(floor(ai*bf))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy

# If you use recursive call, uncomment this code
#sys.setrecursionlimit(10**6)

def main():
    N,M = input().split()
    N = int(N)
    M = float(M)
    print(floor(N*M))

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
def N(): return int(input())
def NM():return map(int,input().split())
def L():return list(NM())
def LN(n):return [N() for i in range(n)]
def LL(n):return [L() for i in range(n)]
l=list(input().split())
a=int(l[0])
b=int(float(l[1])*100)
print(a*b//100)

Submission status: Wrong Answer

Solution code:
import sys

a,b=[float(x) for x in input().rstrip().split()]

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

Submission status: Wrong Answer

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

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

d=c//1
print(int(d))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
import math
def input(): return sys.stdin.readline().rstrip()

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

print(ans)

Submission status: Wrong Answer

Solution code:

def main():
  a, b = map(float, input().split())
  
  from math import floor
  
  print(floor(a*b))
    


if __name__ == "__main__":
  main()

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:
a, b = map(float, input().split())
val = a*b
ind = str(val).index(".")
print(str(val)[:ind])

Submission status: Wrong Answer

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

result = (int(A * 100) * int(B * 100)) // 10**4

print(result)

Submission status: Wrong Answer

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

print(ans)

Submission status: Wrong Answer

Solution code:
import sys
from functools import lru_cache
import math 
#read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def read():
  return float(readline())
def reads():
  return map(float, readline().split())
def mp(arg):
  return map(int,arg.split())
a,b=reads()
m=a*b
print("{}".format(int(math.floor(m))))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math


def task(a, b):
    print(math.floor(a * b))


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

Submission status: Wrong Answer

Solution code:
import math

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

print(math.floor(A * B))

Submission status: Wrong Answer

Solution code:
s = input()
a = [float(x.strip()) for x in s.split(' ')]
print(int(a[0]*a[1]))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import decimal

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


print((A*B) // 100)

Submission status: Wrong Answer

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

#print(A, B)

print(math.floor(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a = list(input().split())

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

Submission status: Wrong Answer

Solution code:
from sys import stdin
A, B = [float(x) for x in stdin.readline().rstrip().split()]
print(int(A * B))

Submission status: Wrong Answer

Solution code:
import numpy as np
A, B = np.array(list(map(float, input().split())))
print(int(A*B))

Submission status: Wrong Answer

Solution code:
MOD = 10 ** 9 + 7
# MOD = 998244353

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

Submission status: Wrong Answer

Solution code:
# coding: utf-8
import sys

stdin = sys.stdin
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))


def main():
    a,b = list(map(float, stdin.readline().split()))
    a = int(a)
    b = int(b*100)
    print(int(a*b)//100)
    return


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
ab = list(input().split())
a = int(ab[0])
b = ab[1]
ans = 0
ans += a*int(b[0])
ans += a*int(b[2])*0.1
ans += a*int(b[3])*0.01
import math
anss = math.floor(ans)
print(anss)

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
ans = str(int(a) * int(b * 100))
n = len(ans)
if ans[:n - 2] == '':
    print(0)
else:
    print(ans[:n - 2])

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
A, B = sys.stdin.readline().rstrip().split()
import math
A = int(A)
B = float(B)
B_y = float(B * 100)
B_x = 100
ans = math.floor(A * B_y / B_x)
print(ans)

Submission status: Wrong Answer

Solution code:
import bisect
import copy
import heapq
import math
import sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
sys.setrecursionlimit(500000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

def main():
    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
n, m = map(str, input().split())
answer = int(n) * float(m)
print(math.floor(answer))

Submission status: Wrong Answer

Solution code:

ans=1
a = list(map(float,input().split()))
if 0 in a:
    print(0)
    exit()
for i in a:
    ans*=i

print(int(ans//1))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

b *= 100

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

print(ans)

Submission status: Wrong Answer

Solution code:
a, b = input().split()
#一行で入力された数値をそれぞれの変数に
#3つ以上も可
a_i = int(a)
b_d = float(b)
print(int(a_i*b_d))

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

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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

Solution code:
# coding: utf-8
# Your code here!
import math
a, b = input().split()
a = int(a)
b = float(b)
mul = math.floor(a * b)
print(mul)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

print((B100*A)//100)

Submission status: Wrong Answer

Solution code:
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
#import numpy as np
INF = float("inf")
#d = defaultdict(int)
#d = defaultdict(list)
#N = int(input())
#A = list(map(int,input().split()))
#S = list(input())[:-1]
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = [int(input()) for _ in range(N)]
#S = [list(input())[:-1] for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
A,B = map(float,input().split())
C = 100*B
d = A*C
e = int(d // 100)
print(e)

Submission status: Wrong Answer

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

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:
def main():
    from decimal import Decimal
    A, B = (float(i) for i in input().split())
    a = Decimal(A)
    b = Decimal(B)
    print(int(a*b))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

import sys
sys.setrecursionlimit(10**7)
from pprint import pprint as pp
from pprint import pformat as pf
# @pysnooper.snoop()
#import pysnooper # debug

import math
#from sortedcontainers import SortedList, SortedDict, SortedSet # no in atcoder
import bisect


if __name__ == '__main__':
    a, b = list(map(float, input().split()))
    a = int(a)
    b = int(b * 100)
    ans = math.floor((a * b) / 100)

    #print('ans') # debug
    print(ans)

    #print('\33[32m' + 'end' + '\033[0m') # debug

Submission status: Wrong Answer

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

ans = int(a * b)

print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import collections
from collections import defaultdict
import math
import numpy as np
import re
import itertools
import bisect
import pprint
from collections import deque

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

print(math.floor(a*b))

Submission status: Wrong Answer

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

ans = int(A)*float(B)

print(int(ans))

Submission status: Wrong Answer

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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math

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

Submission status: Wrong Answer

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

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
a, b = list(map(float, input().split()))
# a = list(map(int, input().split()))
# data = [list(map(int, input().split())) for i in range(n)]
# k = int(input())
#p = list(map(int, input().split()))
# ab_sorted = sorted(ab, key=lambda x: x[0])
# py = [list(map(int, input().split())) for i in range(m)]
print(int(a*b//1))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

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

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

print(ans)

Submission status: Wrong Answer

Solution code:

def main():
    A, B = input().split(' ')
    print(int(int(A)*float(B)//1))

if __name__ == "__main__":
    main()

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:
# -*- coding: utf-8 -*-
# 標準入力の取得
A, B = list(map(float, input().split()))

# 求解処理
result = int(A * B)

# 結果出力
print(result)

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 sys
import math


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


sys.setrecursionlimit(20000000)

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


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


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import sys
import math

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

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

Submission status: Wrong Answer

Solution code:
'''input
1000000000000000 9.99
'''

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
SA, SB = input().split()
A = int(SA)
B100 = int(float(SB) * 100)
ans = A* B100 // 100
print(ans)

Submission status: Wrong Answer

Solution code:
# coding: utf-8
# Your code here!
import math
a,b = map(float, input().split())
ans = a*b
print(math.floor(ans))

Submission status: Wrong Answer

Solution code:
import sys

def main():
    a, b = map(float, sys.stdin.readline().split())
    c = a * b 
    print(int(c))
if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math
b = [float(x) for x in input().split()]
print(math.floor(b[0]*b[1]))

Submission status: Wrong Answer

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

    ans = a*b//1

    return int(ans)
    

print(solve())

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from math import trunc
l=list(map(float,input().split()))
a=l[0]
b=l[1]
p = a * b
print(trunc(p))

Submission status: Wrong Answer

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

A = int(A)

import math

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

Submission status: Wrong Answer

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

import sys
import math
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

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

ans = int(A * B) 

print(ans)

Submission status: Wrong Answer

Solution code:
import math
A, B = map(float, input().split())
print("{}".format(int(math.floor(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:
A = [float(i) for i in input().split()]

ans = int(A[0])
ans *= int(A[1]*100)
ans = ans//100
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:
#n = int(input())
a,b = input().split()
#a = list(int(i) for i in input().split())

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

Submission status: Wrong Answer

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

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

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

Submission status: Wrong Answer

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

print(str(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:
import math
#=input()
#=int(input())
a,b=map(float,input().split())
#=list(map(int,input().split()))
#=[list(map(int,input().split())) for _ in range()]

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

Submission status: Wrong Answer

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

print(round(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())
c = a * b
cl = list(str(c))
s = ""
for i in range(len(cl)):
    if cl[i] == '.':
        break
    else:
        s += cl[i]
print(s)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
def solve(a,b):
    return int(a*b)

if __name__ == '__main__':
    a,b = map(float,input().split())
    print(solve(a,b))

Submission status: Wrong Answer

Solution code:
import sys

# 実行環境(0:vscode, 1:atcoder)
MODE = 1

# 入力の次元
DIMENSION = 1

# int型に変換
INT_TYPE = 0

if not (MODE):
    with open("input.txt", "r") as f:
        s = f.read()
else:
    s = sys.stdin.read()

if DIMENSION == 0:
    if INT_TYPE == 1:
        s = int(s)
elif DIMENSION == 1:
    if INT_TYPE == 0:
        s = s.split()
    elif INT_TYPE == 1:
        s = [int(x) for x in s.split()]
elif DIMENSION == 2:
    if INT_TYPE == 0:
        s = [x.split() for x in s.splitlines()]
    elif INT_TYPE == 1:
        s = [[int(y) for y in x.split()] for x in s.splitlines()]

A = float(s[0])
B = float(s[1])

print(int(A * B))

Submission status: Wrong Answer

Solution code:
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations, combinations_with_replacement
from heapq import heappop, heappush
from fractions import gcd
# input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

def main():
    s = list(input().split())
    a = int(s[0])
    b = float(s[1])
    b *= 100
    print(math.ceil(a*b//100))
    
if __name__ == "__main__":
    main()

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

ans = a[0]*a[1]

print(int(ans))

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
 
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
 
a, b = map(float, input().split())
a = int(a)
b = int(float(b)*100)
print(a*b // 100)

Submission status: Wrong Answer

Solution code:
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left
from functools import reduce
# input = sys.stdin.readline 
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_list(N): return [s_list() for _ in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7

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

    print(floor(a*b))
            
if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
a, b = map(float, input().split())
a *= 1000
b *= 1000
ans = int((a * b) // 1000000)
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:
A, B = input().split()

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

print(str((A * B) / 10000).split('.')[0])

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 sys
def FI(): return list(map(float,sys.stdin.readline().rstrip().split()))
A,B = FI()
B *= 100
A,B = int(A),int(B)
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:
A, B = map(float, input().split())
print(str(A*B).split(".")[0])

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)
if A == 0 or B == 0 :
    print(0)
else:
    ans = math.floor(A*B)
    print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

A = int(A)
B = float(B)
if A==0 or B==0.0:
    print('0')
    exit()
print(int(A*B))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import math

li = [float(s) for s in input().split()]

ans = int(math.floor(li[0]*li[1]))

print(ans)