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 bisect
import collections
import sys

sys.setrecursionlimit(1000000)
ACMOD = 1000000007
INF = 1 << 62



def solve(A: int, B: float):
    print(int(A*B))
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = float(next(tokens))  # type: float
    solve(A, B)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
import math
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    a, b = map(float, input().split())
    res = math.floor(a * b)
    print(res)


if __name__ == '__main__':
    resolve()

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")

#solve
def solve():
    a, b = LF()
    print(int(a*b))
    return


#main
if __name__ == '__main__':
    solve()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from math import floor


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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
from collections import *

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

Submission status: Wrong Answer

Solution code:
import bisect
import collections
import copy
import functools
import heapq
import math
import sys
from collections import deque
from collections import defaultdict
input = sys.stdin.readline
MOD = 10**9+7

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

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(float, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))
import math
A, B = mi()

print(math.floor(A*B))

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

Submission status: Wrong Answer

Solution code:
from math import floor

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

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

Submission status: Wrong Answer

Solution code:
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0

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

print(int(a*b))

Submission status: Wrong Answer

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

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

print(int(a*b))

Submission status: Wrong Answer

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

from math import floor

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

Submission status: Wrong Answer

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

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

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

Submission status: Wrong Answer

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

import sys
sys.setrecursionlimit(300000)


def solve(A: int, B: float):
    ret = (B * 100 * A) // 100
    print(int(ret))
    return

def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = float(next(tokens))  # type: float
    solve(A, B)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *                    # ll = deepcopy(l)
from heapq import *                    # heappush(hp,x)
from string import *                # alpha = ascii_lowercase
from random import *                # l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *                # bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin                # bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize                # minn = -maxsize
from operator import *                # d = sorted(d.items(), key=itemgetter(1))
from itertools import *                # pre = [0] + list(accumulate(l))
from collections import Counter        # d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''

'''

def solve(l):
	a,b = l
	p = a*b
	return floor(p)
	

l = list(map(float, stdin.readline().rstrip().split()))
ans = solve(l)
print(ans)

Submission status: Wrong Answer

Solution code:
from math import floor

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

Submission status: Wrong Answer

Solution code:
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()
getcontext().prec = 400
A,B=input().split()
A=int(A)
B=float(B)

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
"""
じょえチャンネルおもしろいよ～～～
https://www.youtube.com/channel/UCRXsI3FL_kvaVL9zoolBfbQ
"""
a,b=map(float,input().split())
b*=100
a=int(a)
b=int(b)
print(a*b//100)

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:
S=lambda:input()
I=lambda:int(input())
L=lambda:list(map(float,input().split()))
LS=lambda:list(map(str,input().split()))
 
def main():
    a,b=L()
    print(int(a*b//1))
 
if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

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
import numpy as np

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


print(int(a*b))

Submission status: Wrong Answer

Solution code:
mod = 1000000007
eps = 10**-9


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

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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

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

#Solve
if __name__ == "__main__":
    solve()

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
#%%code
def resolve():
    A,B=pin(float)
    print(int(A*B))
#%%submit!
resolve()

Submission status: Wrong Answer

Solution code:
"""
じょえチャンネルおもしろいよ～～～
https://www.youtube.com/channel/UCRXsI3FL_kvaVL9zoolBfbQ
"""
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))

Submission status: Time Limit Exceeded

Solution code:
c=input("").split(" ")
a=int(c[0])
if(a>10000000000000):
  while(True):
    None
e=100*int(c[1][0])+10*int(c[1][2])+int(c[1][3])

d=a*e
ff=d%100
d-=ff
print(int(d/100))

Submission status: Time Limit Exceeded

Solution code:
from decimal import *
A,B = map(str,input().split())
A = int(A)
B = float(B)
ans = 0

for i in range(1,A+1):
    ans += B

print(int(ans))

Submission status: Time Limit Exceeded

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

ans=0
while product>=1:
    ans+=1
    product=product-1

print(ans)

Submission status: Time Limit Exceeded

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

multi = a*b
i=1
test = 1

if (0<=multi) and (multi<1):
    test = 0

while True:
    if test == 0:
        i=0
        break
    elif (i<=multi) and (multi<i+1):
        break
    else:
        i = i*10
while True:
    if i ==0:
        break
    if (i<=multi) and (multi<i+1):
        break
        i=i+1

print(i)

Submission status: Time Limit Exceeded

Solution code:
import math

a, b = map(float, input().split())
times = 0
a = int(a)
if a == 0 or b == 0:
    print(0)
else:
    for k in range(0, a):
        times += b
    new_times = math.floor(times)
    print(new_times)

Submission status: Time Limit Exceeded

Solution code:
a,b = map(float,input().split())
a = int(a)
ans = 0
for i in range(a) :
    ans += b
print(int(ans))

Submission status: Time Limit Exceeded

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

multi = a*b
i=0

while True:
    if i<=multi and multi<i+1:
        break
    i=i+1

print(i)

Submission status: Accepted

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

import decimal
#import
#import math
#import numpy as np
#= int(input())
#= input()
A, B = map(decimal.Decimal, input().split())

print(int(A * B))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(A*B//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
#from operator import itemgetter
#from heapq import heappush, heappop
#import numpy as np
#from scipy.sparse.csgraph import breadth_first_order, depth_first_order, shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
import sys

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

stdin = sys.stdin

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

from decimal import Decimal
a, b = map(Decimal, input().split())
print(int(a*b))

Submission status: Accepted

Solution code:
from decimal import Decimal
a, b = map(Decimal, input().split())
print(int(a*b))

Submission status: Accepted

Solution code:
import re
a,b,c=map(int, re.split("[ .]",input()))
print(a*(b*100+c)//100)

Submission status: Accepted

Solution code:
import sys
from collections import deque, defaultdict, Counter
from itertools import accumulate, product, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush
from math import ceil, floor, sqrt, gcd, inf
from copy import deepcopy
import numpy as np
import scipy as sp

INF = inf
MOD = 1000000007

a, b = input().split()

tmp = 0
res = 0

a = int(a)
b = int(b.replace(".", ""))
res = a * b // 100

print(res)

Submission status: Accepted

Solution code:
import math
l = input().split(" ")
a = int(l[0])

b = (l[1].split("."))
c = int(b[0])
d = int(b[1])

e = a*(c*100 + d)//100
print(e)

Submission status: Accepted

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

a = int(a)
b1, b2 = b.split('.')

ans = a * (int(b1) * 100 + int(b2)) // 100
print(ans)

Submission status: Accepted

Solution code:
a, b = map(str, input().split())
i, f = b.split(".")[0], b.split(".")[1][0:2]
b = int(i) * 100 + int(f)
print(int(a) * b // 100)

Submission status: Accepted

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

Submission status: Accepted

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

a = int(a)
b = int(b.replace('.',''))

print(a*b//100)

Submission status: Accepted

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

a = int(a)
b1, b2 = b.split('.')

ans = a * (int(b1) * 100 + int(b2)) // 100
print(ans)

Submission status: Accepted

Solution code:
line = input().split()
a = int(line[0])
b = round(float(line[1])*100)

print(a*b//100)

Submission status: Accepted

Solution code:
from decimal import Decimal
a, b = map(Decimal,input().split())
score=a*b
score = int(score)
print(score)

Submission status: Accepted

Solution code:
import decimal as d
a,b=input().split()
print(int(int(a)*d.Decimal(b)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

a, b = input().split()

a = Decimal(a)
b = Decimal(b)

print(int(a*b))

Submission status: Accepted

Solution code:
from decimal import *

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

Submission status: Accepted

Solution code:
from decimal import *
import math

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B = input().split()
A = int(A)
B = B[0]+B[2:]

if A*int(B) >= 100:
  print(str(A*int(B))[:-2])
else:
  print(0)

Submission status: Accepted

Solution code:
import math
import decimal
A,B = input().split(' ')
answer = math.floor(int(A)*decimal.Decimal(B))
print(answer)

Submission status: Accepted

Solution code:
def main():

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


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a,b=input().split()
b=b.replace('.','')
a,b=list(map(int,[a,b]))
ans=a*b
print(ans//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from math import floor
from fractions import Fraction
a,b = input().split()
a = int(a)
b = Fraction(b)

print(floor(a*b))

Submission status: Accepted

Solution code:
def sep():
    return map(int,input().strip().split(" "))
def lis():
    return list(sep())

a,b=input().strip().split(" ")
b=b.replace('.','')
b=int(b)
ans=int(a)*b
print(ans//100)

Submission status: Accepted

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

print((a*b)//100)

Submission status: Accepted

Solution code:

def ri():
    return int(input())


def rii():
    return [str(v) for v in input().split()]

A, B = rii()
A = int(A)
B, F = [int(v) for v in B.split(".")]
B = 100 * B + F

print((A * B) // 100)

Submission status: Accepted

Solution code:
import math
import decimal

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

Submission status: Accepted

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

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

ans_b = A*B

print(int(ans_b//100))

Submission status: Accepted

Solution code:
A, B = input().split()
A = int(A)
B = int(''.join([b for b in B if b != '.']))

print(A * B // 100)

Submission status: Accepted

Solution code:
x,y = list(input().split())
x = int(x)
y = int(y[0]+y[2]+y[3])
print(x*y//100)

Submission status: Accepted

Solution code:
x, y = input().split()
y = float(y) * 100 + 0.01
ans = int(x) * int(y)
print(ans//100)

Submission status: Accepted

Solution code:
from decimal import Decimal
from decimal import ROUND_FLOOR

A, B = [Decimal(i) for i in input().split()]

print((A*B).quantize(Decimal(0), rounding=ROUND_FLOOR))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a=input().split()
a1=int(a[0])
a2=a[1]
a3=a2[0]+a2[2:]
a3=int(a3)
print((a1*a3)//100)

Submission status: Accepted

Solution code:
sa, sb = input().split()
a = int(sa)
bi,bf = map(int,sb.split("."))
b = bi * 100 + bf
print((a*b)//100)

Submission status: Accepted

Solution code:
import decimal
a, b = input().split()
x=decimal.Decimal(a)
y=decimal.Decimal(b)
ans = int(x * y) 
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

    print(int(a) * int(b.replace(".", "")) // 100)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# C
from decimal import Decimal
A,B = map(Decimal,input().split())
ans = A * B

print(int(ans))

Submission status: Accepted

Solution code:
from decimal import Decimal

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

ans = A * B

print(int(ans))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
from decimal import Decimal  
import math

a, b = input().split()

a = int(a)
b = Decimal(b)

x = a * b

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b = map(str, input().split())
a = int(a)
li_b = []
for i in range(4):
    B = b[i]
    if B!=".":
        li_b.append(int(B))
b = 100*li_b[0] + 10*li_b[1] + li_b[2]

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

Submission status: Accepted

Solution code:
A, B=(input().split())
A=int(A)
C=int(B[0])*100+int(B[2])*10+int(B[3])
print(int(A*C//100))

Submission status: Accepted

Solution code:
import math
from decimal import *
a,b=map(str,input().split())
ans=(Decimal(a)*Decimal(b))//1
print(ans)

Submission status: Accepted

Solution code:
#n = int(input())
#a, b = map(int, input().split())
#al = list(map(int, input().split()))
#al=[list(input()) for i in range(n)]

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

a = int(a)
b = int(b[0]+b[2:])
print(a*b//100)

Submission status: Accepted

Solution code:
import math


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

    print((int(a)*int(b.replace('.', ''))) // 100)

    return


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
A, B =map(float,input().split())
A = int(A)
B = int((B+sys.float_info.epsilon*5)*100)
ans = A*B//100
print(ans)

Submission status: Accepted

Solution code:
import math

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

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

ans = a * b

ans = ans // 100

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B = input().split()
A = int(A)
B1, B2 = B.split('.')
B = int(B1)*10**len(B2)+int(B2)
print((A*B)//10**len(B2))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import decimal

a, b = input().split()
a = int(a)
b = decimal.Decimal(b)
c = b * 100
x = a * int(c)
print(x//100)

Submission status: Accepted

Solution code:
import decimal
A,B = map(decimal.Decimal,input().split())
num = A*B
print(int(num)//1)

Submission status: Accepted

Solution code:
# coding=utf-8
from math import floor, ceil, sqrt, factorial, log, gcd
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heappushpop, heapify
import copy
import sys
INF = float('inf')
mod = 10**9+7
sys.setrecursionlimit(10 ** 6)


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

# 1 2 3
# a, b, c = LI()


def LI(): return list(map(int, sys.stdin.buffer.readline().split()))

# a = I()


def I(): return int(sys.stdin.buffer.readline())

# abc def
# a, b = LS()


def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()

# a = S()


def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')

# 2
# 1
# 2
# [1, 2]


def IR(n): return [I() for i in range(n)]

# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]]


def LIR(n): return [LI() for i in range(n)]

# 2
# abc
# def
# [abc, def]


def SR(n): return [S() for i in range(n)]

# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]]


def LSR(n): return [LS() for i in range(n)]

# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]]


def SRL(n): return [list(S()) for i in range(n)]


a, b = LS()
print(int(a) * int(b.replace('.', '')) // 100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
b1, b2 = b.split('.')
b3 = int(b1)*100 + int(b2)

print(a*b3//100)

Submission status: Accepted

Solution code:

M, N = input().split()   # 2つ整数の読み取り
A=int(M)
B=N.replace(".","")
B=int(B)

C=A*B//100
print(C)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A_B = list(input().split())
A = int(A_B[0])
B = int(float(A_B[1]) * 100 + 0.001)

print(A * B // 100)

Submission status: Accepted

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

def main():
    a, b = input().split()
    c, d = b.split(".")
    if len(d) == 1:
        d = d + '0'
    
    p, q = int(a), int(c) * 100 + int(d)
    ans = p * q // 100

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

Submission status: Accepted

Solution code:
import sys
from decimal import *
import math

input = sys.stdin.readline


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from decimal import Decimal
from math import floor


def main():
    a, b = map(Decimal, input().split())
    print(floor(a * b))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def LS():
    return list(input().split())


A, B = LS()
A = int(A)
B = B.replace(".", "", 1)
B = int(B)
ans = A*B
ans //= 100
print(ans)

Submission status: Accepted

Solution code:
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
#mod = 998244353
from sys import stdin
readline = stdin.readline
def readInts():
  return list(map(int,readline().split()))
def readTuples():
    return tuple(map(int,readline().split()))
def I():
    return int(readline())
a,b = map(decimal.Decimal,input().split())
print(int(a*b))

Submission status: Accepted

Solution code:
A, B = input().split()
A = int(A)
i, d = map(int, B.split("."))
B_m = i * 100 + d
ans = A * B_m // 100
print(ans)

Submission status: Accepted

Solution code:
a, b = input().split()
c, d = b.split('.')
e = int(c) * 100 + int(d)
f = int(a) * e
print(f // 100)

Submission status: Accepted

Solution code:
def main():
    from decimal import Decimal
    N, M = (Decimal(i) for i in input().split())
    print(int(N * M))


if __name__ == '__main__':
    main()