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: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *

##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)

##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力

# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと

##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順

# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順

##### 累乗 #####
# pow(x, y, z) -> x**y % z

##### 割り算の切り上げ #####
# tmp = -(-4 // 3)

##### dict の for文 #####
# for k, v in d.items():
#     print(k, v)

##### 進数の変換 #####
# bin_str = bin(i)[2:]
# oct_str = oct(i)[2:]
# hex_str = hex(i)[2:]

def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

def main():
	getcontext().prec = 20
	A,B  = map(Decimal, input().split())

	ans = A * B

	s = str(ans)
	#print(s)
	S = s.split(".")
	print(S[0])



#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索のリバース
def bisect_left_reverse(a, x):
    if a[0] <= x:
        return 0
    if x < a[-1]:
        return len(a)
    # 二分探索
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] <= x:
            ok = mid
        else:
            ng = mid
    return ok

def bisect_right_reverse(a, x):
    if a[0] < x:
        return 0
    if x <= a[-1]:
        return len(a)
    # 二分探索
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] < x:
            ok = mid
        else:
            ng = mid
    return ok

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索
# 存在しない場合: None 存在する場合: その値
def binary_search(list, item):
    low = 0
    high = len(list) - 1

    while low <= high:
        mid = (low + high) //2
        guess = list[mid]
        if guess == item:
            return mid
        if guess > item:
            high = mid -1
        else:
            low = mid + 1
    return None

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# N 個のボールを K グループに分ける場合のパターン数
def sunuke(N, K, mod=10**9+7):
	if N < K or K-1 < 0:
		return 0
	else:
		return combination(N-1, K-1, mod)

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res

# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
	# comb = Combination(n+r-1, mod)
	# return comb(n+r-1, r)
    return combination(n+r-1, r, mod)


class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  # 10
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        # 階乗のリストと階乗のmod逆元のリストを返す O(n)
        # self.make_modinv_list()が先に実行されている必要がある
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        # 0からnまでのmod逆元のリストを返す O(n)
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# dfs のサンプル
def dfs(graph,parent,counter,edge):
    stk = []
    stk.append(edge)
    while len(stk) > 0:
        p = stk.pop()
        for e in graph[p]:
            if parent[p] == e:
                continue
            else:
                parent[e] = p
                counter[e] += counter[p]
                stk.append(e)

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
	main()

Submission status: Accepted

Solution code:
from decimal import Decimal

tmp = input().split()
A = int(tmp[0])
B = Decimal(tmp[1])
print(int(A*B))

Submission status: Accepted

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

def main():
    inpt = input()
    A = int(inpt.split()[0])
    B = inpt.split()[1]

    B = int(B[0] + B[2:4])

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import math
str_a, str_b = input().split()
a = int(str_a)
b1 = int(str_b[0])
b01 = int(str_b[2])
b001 = int(str_b[3])

product_1 = a * b1
product_01 =  a * b01
product_001 = a * b001


tmp_result = product_1 * 100 + product_01 * 10 + product_001
str_result = str(tmp_result)
if len(str_result) < 3:
    result = 0
else:
    result = str_result[0:-2]

print(result)

Submission status: Accepted

Solution code:
from decimal import Decimal
num_list = list(input().split())
a = Decimal(num_list[0])
b = Decimal(num_list[1])

print(int(a*b))

Submission status: Accepted

Solution code:
import sys
#from collections import defaultdict, deque, Counter
#import bisect
#import heapq
import math
#from itertools import accumulate
#from itertools import permutations as perm
#from itertools import combinations as comb
#from itertools import combinations_with_replacement as combr
#from fractions import gcd
#import numpy as

stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18

def main():
    A, B = map(str, stdin.readline().rstrip().split())
    ans = 0
    ans = int(A) * int(B[-1])
    ans += int(A) * int(B[-2]) * 10
    ans = ans // 100
    ans += int(A) * int(B[-4])
    if len(B)==5:
        ans += int(A) * int(B[-5])
    print(ans)

main()

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

nums = input().split()
nums = np.array(nums, dtype=np.float128)
ans = np.array([nums[0]*nums[1]], dtype=np.uint64)
print(ans[0])

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
b0, b12 = b.split(".")
b1 = b12[0]
b2 = b12[1]
b0 = int(b0)
b1 = int(b1)
b2 = int(b2)

ans0 = a * b0
ans1 = str(a * b1)
ans2 = str(a * b2)
if len(ans1) > 1:
    ans1i = int(ans1[:-1])
else:
    ans1i = 0
if len(ans2) > 2:
    ans2i = int(ans2[:-2])
else:
    ans2i = 0

ans1f=int(ans1)%10
ans2f=int(ans2)%100

if ans1f*10+ans2f>=100:
    ans12i=1
else:
    ans12i=0

# print(int(str(a*b1)[:-1]))
# print(int(str(a*b2)[:-2]))

print(ans0 + ans1i + ans2i+ans12i)

Submission status: Accepted

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

A = decimal.Decimal(A)
B = decimal.Decimal(B)

print(math.floor(A * B))

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
br, bl = map(int, b.split('.'))
x = a*bl//100
print(a*br+x)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B = input().split()
A = int(A)
Bi, Bf = map(int, B.split('.'))
ansi = A*Bi
ansf = A*Bf//100
print(ansi + ansf)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import decimal
li=input().split()
a = int(li[0])
b = decimal.Decimal(li[1])
print(int(a*b))

Submission status: Accepted

Solution code:
a,b = map(float,input().split())
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
b = Decimal(str(b)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
a = Decimal(a)
ans = a*b
print(math.floor(ans))

Submission status: Accepted

Solution code:
def main():
  a, b = input().split()
  
  from decimal import Decimal, ROUND_FLOOR
  
  a = Decimal(a)
  b = Decimal(b)
  
  c = a * b
  c = c.quantize(Decimal('1.'), rounding=ROUND_FLOOR)
  
  print(c)
  

    


if __name__ == "__main__":
  main()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import decimal
A, B = input().split()
decA=decimal.Decimal(A)
decB=decimal.Decimal(B)
ans=decA*decB
print(int(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import decimal, math
a, b = input().split()
a = decimal.Decimal(str(a))
b = decimal.Decimal(str(b))
print((a*b).quantize(decimal.Decimal('0'), rounding=decimal.ROUND_FLOOR))

Submission status: Accepted

Solution code:
import math as mt
from decimal import Decimal
AB =  input().split()
a = int(AB[0])
b = Decimal(AB[1])
c = a*b
d = mt.floor(c)
print(d)

Submission status: Accepted

Solution code:
import math

ab = input().split()
a, b_f = int(ab[0]), float(ab[1])

b = round(b_f * 100)

#a_a = a * b_f

#print(a, b_f)
#print(a, b)
#print(a*b)
a = a * b

#print(a_a)

print(a // 100)

Submission status: Accepted

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

a_1 = int(a)

b_1 = int(b[0])*100
b_10 = int(b[2])*10
b_100 = int(b[3])

ans = a_1 * b_1
ans += (a_1 * b_10)
ans += (a_1 * b_100)

print(ans//100)

Submission status: Accepted

Solution code:
import decimal

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

Bdecimal = decimal.Decimal(b)

#print(Bdecimal)

B100 = Bdecimal * 100

#print(int(B100))

ans = int(a) * int(B100)

ans = ans // 100

print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
from decimal import Decimal
import math
a, b = [x for x in input().split()]
A = int(a)
B = int(b.replace(".", ""))
ans = str(A*B)[:-2]
if len(ans) == 0:
    print(0)
else:
    print(ans)

Submission status: Accepted

Solution code:
import math
from decimal import Decimal, getcontext


A, B = input().split()
print(math.floor(Decimal(A) * Decimal(B)))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import numpy as np
from collections import deque
import collections
import heapq
from decimal import Decimal

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

inputs = input().split(' ')
a,b = int(inputs[0]), Decimal(inputs[1])
print(math.floor(a*b))

Submission status: Accepted

Solution code:

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

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

print((A*B)//100)

Submission status: Accepted

Solution code:
from decimal import Decimal
import math 

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

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

Submission status: Accepted

Solution code:
from decimal import *

sAB = input().split()

ans = int(Decimal(sAB[0]) * Decimal(sAB[1]))

print(ans)

Submission status: Accepted

Solution code:
import sys
import math

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
   
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

print((a*b)//1000)

Submission status: Accepted

Solution code:
# coding:utf-8

import sys
import math
import time
#import numpy as np
import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq
import itertools



sys.setrecursionlimit(10**7)
#N, Q = map(int, input().split())
#G = [list(input()) for i in range(H)]
#INF = V * 10001
#A = [int(i) for i in input().split()]
#AB = [list(map(int, input().split())) for _ in range(K)]

#N = int(input())
AB = input().split()
A = int(AB[0])
B = int(AB[1].replace('.',''))

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

Submission status: Accepted

Solution code:
from decimal import Decimal
import math

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B = open(0).read().split()
A = int(A)
B = int(B.replace('.',''))
print(A*B//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

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

Submission status: Accepted

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

b_sub = list(b_sub)
b = int(b_sub[0])*(10**2) + int(b_sub[2])*10 + int(b_sub[3])
a = int(a)

ans = a*b
ans = list(str(ans))
n = len(ans)

ans_1 = 0
if n >= 3:
  for i in range(1,n-1):
    ans_1 += int(ans[-2-i])*(10**(i-1))
else:
  ans_1 = 0

print(ans_1)

Submission status: Accepted

Solution code:
import sys
from decimal import *
def inpl(): return list(map(str, sys.stdin.readline().split()))

ab = inpl()

print(int(Decimal(ab[0])*Decimal(ab[1])))

Submission status: Accepted

Solution code:
# C - Multiplication 3

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

Submission status: Accepted

Solution code:
import fractions
import decimal

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

Submission status: Accepted

Solution code:
import math
import decimal

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

print(math.floor(A * B))

Submission status: Accepted

Solution code:
from decimal import *
getcontext().prec = 18

a, b = input().split()
ans = int(a) * Decimal(b)
print(int(str(ans)[:-3]))

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
from decimal import *

temp1 = input().split(" ")
a = Decimal(temp1[0])
b = Decimal(temp1[1])

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

A, B = input().split()

A = int(A)
B = Decimal(B)

print(math.floor(A*B))

Submission status: Accepted

Solution code:
import math
import decimal

a,b = map(decimal.Decimal,input().split())

print(math.floor(a*b))

Submission status: Accepted

Solution code:
#!/usr/bin/python3
# -*- coding: utf-8 -*-
a, b = input().split()
a = int(a)
b = int(b[0] + b[2:])
s = str(a * b)
if len(s) < 3:
    print(0)
else:
    print(int(s[:len(s) - 2]))

Submission status: Accepted

Solution code:
import math
a, b = input().split()
a = int(a)
b = int(b.replace(".", ""))
ans = 0
for i in range(4):
    a_sub = a//(10**(4*i))%(10**4)
    # print(a_sub, b, a_sub*b*(10**(4*i))//100)
    ans += a_sub*b*(10**(4*i))//100

print(ans)

Submission status: Accepted

Solution code:
import sys
from decimal import Decimal


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


sys.setrecursionlimit(20000000)

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


def main():
    A, B = map(str, input().split())
    A = int(A)
    B = int(Decimal(B) * 100)
    c = str(A * B)
    answer = 0
    for i in range(len(c) - 2):
        answer = answer * 10 + int(c[i])

    print(answer)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    from sys import setrecursionlimit, stdin
    from os import environ
    from collections import defaultdict, deque, Counter
    from math import ceil, floor, gcd
    from itertools import accumulate, combinations, combinations_with_replacement
    setrecursionlimit(10**6)
    dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in environ else lambda *x: 0
    input = lambda: stdin.readline().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    P = 10**9+7
    INF = 10**9+10
    from decimal import Decimal
    a,b = map(Decimal,input().split())
    print(int(a*b))
    # print(int(a*(b*10**2))//10**2)
    # print(int(a),int(b*10**2))
    # print(int(a)*int(b*10**2)//10**2)
    
main()
#999999999999999 9.99

Submission status: Accepted

Solution code:
import sys
a,b = map(str, input().split()) #a1 a2 a3 // b1 b2 b3
keta=len(b)-b.find('.')

if keta==3:
  print(int(a)*int(b.replace(".",""))//100)
elif keta==2:
  print(int(a)*int(b.replace(".",""))//10)
else:
  print(int(a)*int(b))

Submission status: Accepted

Solution code:
import math
a, b = input().split()
a = int(a)
bList = b.split('.')
b = int(bList[0]) * 100 + int(bList[1])
print(a*b // 100)

Submission status: Accepted

Solution code:
import sys
import math
from decimal import Decimal, ROUND_DOWN

if(__name__ == "__main__"):


    AList_Str = input().strip().split()
    """
    A = int(AList_Str[0])
    B = float(AList_Str[1])
    """
    A = int(AList_Str[0])
    B = float(AList_Str[1])
    C = Decimal(AList_Str[1])*A
    Multiply = C.quantize(Decimal('1.'), rounding = ROUND_DOWN)
    print(Multiply)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal
a,b = input().split(" ")
# print(a,b)
a = Decimal(a)
b = Decimal(b)

mul = a * b
mul_floor = math.floor(a * b)
# print(mul)
print(mul_floor)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *
a, b = [ Decimal(f) for f in input().split()]
r = a * b
getcontext().rounding = ROUND_DOWN
print('{:.0f}'.format(r))

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

Submission status: Accepted

Solution code:
S = input().split()
import decimal
x = decimal.Decimal(S[0])
y = decimal.Decimal(S[1])

print(int(x*y))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
a,b=input().split()
a=int(a)
L=list(b)
if "." in L and L[0]==0:
  c=L[2]+L[3]
  c=int(c)
  print(c*a//100)
elif  "." in L and L[0]!=0:
  c=L[0]+L[2]+L[3]
  c=int(c)
  print(c*a//100)

Submission status: Accepted

Solution code:
A,B=input().split()
a=0
A=int(A)
B=B[::-1]
b=0
for i in range(len(B)):
  c=pow(10,b)
  if B[i]!='.':
    b+=1
    a+=(int(B[i])*c*A)
count=0
for j in range(len(B)):
  if B[j]=='.':
    break
  count+=1
a=a//pow(10,count)
a=int(a)
print(a)

Submission status: Accepted

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

tmp = b.split('.')
b = ''.join(tmp)
ans = []
for i in reversed(range(len(b))):
   x = 0
   cnt = 0
   for j in reversed(range(len(a))):
      x += int(a[j]) * int(b[i]) * pow(10, cnt)
      cnt += 1
   ans.append(x)

tmp = [ans[i] * pow(10, i) for i in range(len(ans))]
print(sum(tmp)//100)

Submission status: Accepted

Solution code:
from decimal import Decimal
from fractions import Fraction

import math
#import numpy as np
#n = int(input())
a,b = map(float,input().split())

#print(a)
#print(b)

aa = math.floor(a)

d1 = Decimal(str(a))
d2 = Decimal(str(b))

#print(str(d1)+' + '+str(d2)+' = '+str(Decimal(str(d1*d2))))
ans = math.floor(d1*d2)
print(ans)

Submission status: Accepted

Solution code:
from decimal import *

str = input().split()
A = Decimal(str[0])
B = Decimal(str[1])

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

Submission status: Accepted

Solution code:
from decimal import Decimal


def main():
    tmp = input().split()
    A = int(tmp[0])
    B = Decimal(tmp[1])
    A = Decimal(A)
    B = Decimal(B)
    print(int(A*B))

    
if __name__ == '__main__':
    main()

Submission status: Accepted

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

a = int(a)
b = Decimal(b)
b*=100
ans = a*b
if ans < 100:
    print(0)
else:
    print(ans//100)

Submission status: Accepted

Solution code:
import decimal
import math
def main():
    A, B = input().split()
    A = decimal.Decimal(A)
    B = decimal.Decimal(B)
    print(math.floor(A*B))

if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd, floor
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#import numpy as np
from decimal import *
 
A, B = MAP()
A = int(A)
b = ""
for x in B:
	if x != ".":
		b += x

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

Submission status: Accepted

Solution code:
def main():
    A, B = input().split(" ")
    A = int(A)
    B = int(B.replace(".", ""))

    result = str(A*B)
    
    if len(result) < 2:
        print(0)
    else:
        print(result[:-2])
if __name__=="__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

if int(b[0])==0:
    if int(b[2])==0:
        b100 = int(b[3])
    else:
        b100 = int(b[2]+b[3])
else:
    b100 = int(b[0]+b[2]+b[3])
    
ab = str(a*b100)

if len(ab)>=3:
    print(ab[:-2])
else:
    print(0)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b = map(str,input().split())
a2 = int(a)
b2 = 100*int(b[0:1])+10*int(b[2:3])+int(b[3:4])
if a2 == 0 or b2 == 0:
    ans = 0
else:
    tmp = str(a2*b2)
    l = len(tmp)
    if l <= 2:
        ans = 0
    else:
        ans = int(tmp[0:l-2])
print(ans)

Submission status: Accepted

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

A, B = input().split()
B2 = ''

for Bi in B:
    if Bi!='.':
        B2 += Bi
    
C = int(A)*int(B2)
#print(C)
print(C//100)

Submission status: Accepted

Solution code:
A,B=input().split()
B=B[0]+B[2:]
i=len(B)-1
ans=str(int(A)*int(B))
print(ans[:-i] if ans[:-i]!='' else 0)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *

a, b = input().split()

a = str(a)
b = str(b)

c = str(Decimal(a) * Decimal(b))
cc = Decimal(c)//Decimal(1)

print(int(cc))

Submission status: Accepted

Solution code:
import math

As,Bs=input().split()
if As=="0" or Bs=="0.00":
    print("0")
else:
    A=int(As)
    Bs=Bs.replace('.','')
    B=int(Bs)
    ans=int(A)*int(B)
    anss=str(ans)
    if len(anss)<3:
        print("0")
    else:
        print(anss[:-2])

Submission status: Accepted

Solution code:
from decimal import *
a = input().split()
print(int(int(a[0]) * Decimal(a[1])))

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:
import math
import decimal

n,k =input().split()

a=decimal.Decimal(n) * decimal.Decimal(k)

print(math.floor(a))

Submission status: Accepted

Solution code:
from fractions import Fraction

a,b= map(str, input().split())
c=''
for i in range(len(b)):
    if b[i]!='.':
        c+=b[i]

a = int(a)
c= int(c)


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

Submission status: Accepted

Solution code:
from decimal import Decimal

a, b = list(input().split())
ans = Decimal(a) * Decimal(b)
ans = str(ans).split('.')[0]
print(int(ans))

Submission status: Accepted

Solution code:
import decimal

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

print(int(a*b))

Submission status: Accepted

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

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

    res = a * b

    print(int(res // 100))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
x,y=input().split()
a=int(x)
y=y.replace('.','')
b=int(y)
z=(a*b)//100
print(z)

Submission status: Accepted

Solution code:
from decimal import *
def resolve():
    AB = input().split()
    A = Decimal(AB[0])
    B = Decimal(AB[1])
    print(int(A*B))
resolve()

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

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

print(int(A*B))

Submission status: Accepted

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

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

Submission status: Accepted

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

import sys
import decimal
import math
"""
def input():
    return sys.stdin.readline()
"""

def resolve():
    input_list = list(input().split())

    for i, n  in enumerate(input_list):
        if i == 0:
            a = int(n)
        else:
            b = float(n)

    dec_a = decimal.Decimal(a)
    dec_b = decimal.Decimal(b)
    dec_b = round(dec_b, 3)
    ans = dec_a * dec_b


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

if __name__ == "__main__":
    resolve()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a,b=input().split()
a=int(a)
b=int(b[:1] + b[-2:])
r=a*b
if r < 100:
    print(0)
else:
    print(str(r)[:-2])

Submission status: Accepted

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

a = int(A)
b = decimal.Decimal(B)

X = (a * b)//1

print(int(X))

Submission status: Accepted

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

Submission status: Accepted

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

pro = str(A*B)

print(Decimal(str(pro)).quantize(Decimal('0'), rounding=ROUND_DOWN))

Submission status: Accepted

Solution code:
from decimal import Decimal
L,R=map(str,(input().split()))
L=Decimal(L)
R=Decimal(R)
ans=L*R
print(int(ans))

Submission status: Accepted

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

A = int(input_list[0])
B = float(input_list[1])

B_100 = int(round(B * 100))

result = A * B_100 // 100

print(result)