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:
"""
N = list(map(int,input().split()))
S = [str(input()) for _ in range(N)]
S = [list(map(int,list(input()))) for _ in range(h)] 
print(*S,sep="")
"""

import sys
sys.setrecursionlimit(10**6)
input = lambda: sys.stdin.readline().rstrip()
inf = float("inf") # 無限


a,b = input().split()
a = int(a)
b = int(round(float(b) * 100))
temp = str(a * b)[:-2]
if temp == "":
    temp = "0"
print(temp)

Submission status: Accepted

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

a=int(a)

s=""
for i in range(len(b)):
    if(b[i]!="."):
        s+=b[i]

s=int(s)
#print(s)

print(a*s//100)

Submission status: Accepted

Solution code:
from decimal import Decimal
import math

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

print(math.floor(A * B))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, floor
from itertools import accumulate, permutations, combinations, product
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

from decimal import *

A, B = MAP()
a = Decimal(A)
b = Decimal(B)
# print(a, b)
print(floor(a * b))
exit()

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 
#整数input
def ii(): return int(sys.stdin.readline().rstrip()) #int(input())
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) #list(map(int,input().split()))
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]
#文字列input
def ss(): return sys.stdin.readline().rstrip() #input()
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) #list(input().split())
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]

#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？

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

if "." in list(b):
    bi,bf=b.split(".")
    
    ans1=a*int(bi)*100
    
    if len(list(bf))>0:
        cnt=1
        for i in list(bf):
            if cnt==1:
                p=a*int(i)*10
                ans1+=p
                cnt+=1
            elif cnt==2:
                p=a*int(i)
                ans1+=p
    print(ans1//100)
else:
    print(a*int(b))

Submission status: Accepted

Solution code:
def main():
    from decimal import Decimal, ROUND_DOWN
    inStr = input().split()
    A = Decimal(inStr[0])
    B = Decimal(inStr[1])
    ans = (A * B).quantize(Decimal("1"), rounding=ROUND_DOWN)
    print(ans)


main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import decimal
import math

N = list(map(decimal.Decimal, input().split()))
a, b = N[0], N[1]

print (math.floor(a*b))

Submission status: Accepted

Solution code:
from decimal import Decimal, getcontext
getcontext().prec = 21

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

Submission status: Accepted

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

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:

def q3():
    import math
    from decimal import Decimal
    nums = input().split(" ")
    a = Decimal(nums[0])
    b = Decimal(nums[1])
    print(math.floor(a * b))

q3()

Submission status: Accepted

Solution code:
from sys import stdin
from decimal import Decimal

def main():

    input = stdin.readline

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

    num_A = Decimal(A)
    num_B = Decimal(B)
    
    ans = int(num_A * num_B)

    print(ans)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_DOWN

def main():
    A, B = tuple(c for c in input().split(' '))
    A = Decimal(A)
    B = Decimal(B)
    ret = A*B
    print(ret.quantize(Decimal('0'), rounding=ROUND_DOWN))


if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

def main():
    N,M = input().split()
    getcontext().prec = 20
    getcontext().rounding = ROUND_DOWN
    N = Decimal(N)
    M = Decimal(M)
    res = N*M
    print(res.quantize(Decimal('1.'), rounding=ROUND_DOWN))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_FLOOR, getcontext


def main():
    getcontext().rounding = ROUND_FLOOR
    getcontext().prec = 30
    A, B = map(Decimal, input().split())
    print((A * B).quantize(Decimal('0')))

main()

Submission status: Accepted

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

ans=a*b


import math
print(math.floor(ans))

Submission status: Accepted

Solution code:

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

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

Submission status: Accepted

Solution code:

from decimal import Decimal
def main():
    A, B = input().split()
    A = Decimal(A)
    B = Decimal(B)

    ans = A*B
    ans = int(ans)

    print(ans)



if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
import os
import random
import re
import sys
str=input().split()
a=int(str[0])
b=float(str[1])
b=round(b*100)
ans=a*b
print(ans//100)

Submission status: Accepted

Solution code:
s = input().split()
a = int(s[0])
x = int(s[1][:-3])
p = int(s[1][-2])
q = int(s[1][-1])
y = a * (100 * x + 10 * p + q)
y = str(y)
if len(y) <= 2:
    print(0)
else :
    print(y[:-2])

Submission status: Accepted

Solution code:
# Code for C - Multiplication 3
# Use input() to fetch data from STDIN
from decimal import Decimal
from math import floor

[a, b] = list(map(Decimal, input().split()))

print(floor(a * b))

Submission status: Accepted

Solution code:
import math
from decimal import *

a,b = input().split()

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

print(math.floor(a * b))

Submission status: Accepted

Solution code:
import math
A,B = list(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('.',''))

C=str(A*B)

if len(C)<=2:
    result=0
else:
    result=int(C[:len(C)-2])

print(result)

Submission status: Accepted

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

Submission status: Accepted

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

A = int(A)
B_i = int(B[0])
B_f = int(B[2:])

ans1 = A*B_i
ans2 = (A*B_f)//100

ans = ans1 + ans2

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

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

ans = str(Decimal(a * b))
print(ans.split(".")[0])

Submission status: Accepted

Solution code:
from decimal import *

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

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:
import sys
input=lambda: sys.stdin.readline().rstrip()
a,b=map(str,input().split())
a=int(a)
bb=""
for bs in b:
  if bs!=".":
    bb+=bs
bb=int(bb)
print((a*bb)//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
def main():
  A, B = map(float, input().split())
  A = Decimal(str(A))
  B = Decimal(str(B))
  ans = A*B
  print(int(ans))
if __name__ == "__main__":
  main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b=map(str,input().split())
a=int(a)
S=""
for i in range(len(b)):
  if b[i]!=".":
    S=S+b[i]
b=int(S)
print(a*b//100)

Submission status: Accepted

Solution code:
import math

A, B = map(lambda x: x, input().split(" "))

A = int(A)
B = int(B.replace(".", ""))

result = A*B

result = result // 100

print(result)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import collections
import itertools as it
import math
#import numpy as np
 
#  = input()
#  = int(input())
a, b  = map(str, input().split())
a = int(a)
b = b.replace('.', '')
b = int(b)
#  = list(map(int, input().split()))
#  = [int(input()) for i in range(N)]
#
# c = collections.Counter()

print(a * b // 100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# C

n = input().split()

a = int(n[0])
b = int(n[1].replace('.',''))


print(a*b//100)

Submission status: Accepted

Solution code:
import math
from decimal import Decimal


def task(a, b):
    b = b.replace('.', '')
    if b[0] == '0':
        b = b[1:]
    if b[0] == '0':
        b = b[1:]
    b = int(b)
    res = a * b

    if res < 100:
        print(0)
    else:
        print(str(res)[:-2])


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

Submission status: Accepted

Solution code:
AB = list(input().split())
A = int(AB[0])
B = int(AB[1][0]+AB[1][2]+AB[1][3])
ans = str(A*B)
print(ans[:-2] if ans[:-2] else 0)

Submission status: Accepted

Solution code:
from decimal import *

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


print(a*b // 1)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

    ans = a * b

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

Submission status: Accepted

Solution code:
import math

a, b = input().split()
res = int(a) * round(float(b) * 1000)
print(res // 1000)

Submission status: Accepted

Solution code:
from decimal import *

A, B = input().split()

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

Submission status: Accepted

Solution code:
from decimal import *

def main():
    A,B=map(Decimal,input().split())
    print((A*B).quantize(Decimal('0'), rounding=ROUND_FLOOR))
    return

if __name__=='__main__':
    main()

Submission status: Accepted

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

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

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

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

        if x == y:
            return

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

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

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

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

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

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

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

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

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

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

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

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

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

    return arr

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

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

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

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


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

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

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

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

    else:
        ret = []

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

        for i in S:

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

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

        return ret


# ここから書き始める
x = input().split()
# print(x)
a = x[0]
b = x[1]
ans = Decimal(a) * Decimal(b)
ans2 = floor(ans)
print(ans2)

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

from decimal import Decimal

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

print(int(a*b))

Submission status: Accepted

Solution code:
import decimal

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

ans = A * B

print(ans.quantize(decimal.Decimal('1'), rounding=decimal.ROUND_DOWN))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#n = int(input())
a,b = input().split()
#a = list(int(i) for i in input().split())
from decimal import Decimal
import math

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B = [x for x in input().split()]
A = int(A)
tmp = ""
for x in B:
	if x != '.':
		tmp += x
B = int(tmp)
res = A * B
res //= 100
print(res)

Submission status: Accepted

Solution code:
from decimal import *

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
import bisect
#[int(x) for x in input().split()]
#map(int,input().split())
#for _ in range(int(input())):
a,b=input().split()
a=int(a)
b=list(b.split("."))
b=''.join(b)
b=int(b)

print(a*b//100)

Submission status: Accepted

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(input().split())
    a = int(a)
    b = int(b.replace('.', ''))
    ans = a * b
    if ans < 100:
        print(0)
    else:
        print(str(ans)[:-2])

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

Submission status: Accepted

Solution code:
from math import floor

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.replace(".", "")

if B[0] == "0":
    B = B[1:]

if B[0] == "0":
    B = B[1:]

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

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 = input().split()
ans = 0
a = int(a)
b = list(b.replace('.', ''))
ans += a * int(b[0]) * 100
ans += a * int(b[1]) * 10
ans += a * int(b[2])
print(ans // 100)

Submission status: Accepted

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

if A.count("."):
    A_int, A_float = A.split('.')
    if len(A_float) == 1:
        A_float += '0'
    A = 100 * int(A_int) + int(A_float)
else:
    A = int(A) * 100

if B.count("."):
    B_int, B_float = B.split('.')
    if len(B_float) == 1:
        B_float += '0'
    B = 100 * int(B_int) + int(B_float)
else:
    B = int(B) * 100

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

print(result)

Submission status: Accepted

Solution code:
# 

from decimal import Decimal
from sys import stdin
input = lambda: stdin.readline().rstrip()

A, B = map(lambda i: Decimal(i), input().split())
print(int(A * B))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal
n = input().split()
a = int(n[0])
b = int(str(n[1]).replace(".",""))
print(Decimal(int((a*b)//100)))

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

Submission status: Accepted

Solution code:
a, b = input().split()
b1, b2 = b.split('.')
a = int(a)
b1 = int(b1)
b2 = int(b2)
c = int(('{:0=3}'.format(a * b2))[:-2])
print(a * b1 +c)

Submission status: Accepted

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

b100=B[0]+B[2]+B[3]

ans=int(A)*int(b100)
if ans < 100:
    print("0")
else:
    ans_str="{0:d}".format(ans)
    print(ans_str[:-2])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    astr, bstr = [e for e in input().split()]

    b = int(bstr.replace('.', ''))
    ans = int(astr) * b // 100
    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
L = list(input().split(" "))
A = int(L[0])
B = L[1]
B1 = int(B[0])
B2 = int(B[2])
B3 = int(B[3])
B = B1*100+B2*10+B3
C = A*B
print(C//100)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
a,b = list(input().split())

from decimal import Decimal
a = Decimal(a)
b = Decimal(b)
print(int(a*b))

Submission status: Accepted

Solution code:
a,b=input().split()
b1=""
a=int(a)
for i in b :
    if i!=".":
        b1+=i 
b1=int(b1)
x=a*b1
x//=100
print(int(x))

Submission status: Accepted

Solution code:
from fractions import Fraction
n,k=map(str,input().split())
a=int(n)
b=int(k[len(k)-2:])
c=int(k[:len(k)-3])
ans=a*c
t=Fraction(a*b,100)
ans+=int(t)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math
import decimal

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

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

Submission status: Accepted

Solution code:
import math
from decimal import *

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

ans = Decimal(A) * Decimal(B)
ans = ans.quantize(Decimal('1'), rounding=ROUND_DOWN)


print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

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

Submission status: Accepted

Solution code:
import math
from decimal import *

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

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

main()

Submission status: Accepted

Solution code:
from decimal import *

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

print(int(a*b))

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:

a,b = input().split()

a = int(a)
b = int(b[0]+b[2]+b[3])

ans = str(a * b)
if len(ans)>=3:
    ans = ans[:-2]
else:
    ans = 0
print(ans)

Submission status: Accepted

Solution code:
from decimal import *

N, M = input().split()
N = int(N)
M = Decimal(M)

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

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

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

#print(math.floor(A*B))
#print(A*B//1)

A = Decimal(A)
B = Decimal(B)
C = A*B
#print(C)
#print(type(C))
print(int(C))
'''
b = int(B[0])
c = int(B[2])
d = int(B[3])

print(b, c, d)
'''

Submission status: Accepted

Solution code:
from decimal import *

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

Submission status: Accepted

Solution code:
tmp=input().split()
a=int(tmp[0])
b_bef=tmp[1][0:-3]
b_aft=tmp[1][-2:len(tmp[1])]
b_100=int(b_bef+b_aft)
ans=(a*b_100)//100
print(ans)

Submission status: Accepted

Solution code:
import math
from decimal import Decimal,  getcontext

getcontext().prec = 100
A, B = input().split()
a = int(A)
b = Decimal(B)
print(math.floor(a*b))

Submission status: Accepted

Solution code:
from decimal import Decimal
import math


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

res=math.floor(a*b)

print(res)

Submission status: Accepted

Solution code:
from decimal import Decimal
from math import floor

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

Submission status: Accepted

Solution code:
def resolve():
    '''
    code here
    '''
    A, B = [item for item in input().split()]

    B100 = int(B[:-3]+B[-2:])

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


if __name__ == "__main__":
    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:
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

def main():
    a,b=SI().split()
    a=int(a)
    b1,b0=map(int,b.split("."))
    print(a*(b1*100+b0)//100)

main()

Submission status: Accepted

Solution code:
import sys
A, B = sys.stdin.readline().rstrip().split()
import math
A = int(A)
B = B.split(".")
B_y = int(B[0] + B[1])
ans = str(A * B_y)

if len(ans) > len(B[1]):
    print(ans[:-len(B[1])])
else:
    print(0)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# A, B= map(float, input().split())
import math
A, B = input().split()
B = B.replace(".", "")
A = int(A)
B = int(B)

ans = A*B
ans = ans // 100
ans = math.floor(ans)

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal
from decimal import ROUND_FLOOR

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

a, b = Decimal(a), Decimal(b)
print((a*b).quantize(Decimal('0'), rounding=ROUND_FLOOR))

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

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

a = int(a)
b_str = b[0] + b[2] + b[3]

b = int(b_str)

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

Submission status: Accepted

Solution code:
import sys
from decimal import Decimal, ROUND_FLOOR

A,B = map(Decimal, sys.stdin.readline().split())
print((A * B).quantize(Decimal('0'), rounding=ROUND_FLOOR))

Submission status: Accepted

Solution code:
import math
from decimal import Decimal, ROUND_DOWN
def main():
    a,b = list(input().split())
    a = Decimal(a)
    b = Decimal(b)
    ans = a * b
    print(Decimal(ans).quantize(Decimal(1), rounding=ROUND_DOWN))

if __name__=='__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

from decimal import Decimal
num = Decimal(B)

print(int(int(A)*num))

Submission status: Accepted

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

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

b = "".join([b[0], b[2], b[3]])

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

Submission status: Accepted

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

Submission status: Accepted

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

from decimal import *

ans = Decimal(a) * Decimal(b*1000)
ans = Decimal(ans)//1000
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 Decimal
import math
a, b = map(Decimal, input().split())
print(math.floor(Decimal(a)*Decimal(b)))

Submission status: Accepted

Solution code:
from decimal import Decimal

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

print(int(Decimal(a) * Decimal(b)))

Submission status: Accepted

Solution code:
a, b = input().split()
a = int(a)
a1 = a % 10
a2 = a % 100
b0 = int(b[0])
b1 = int(b[2])
b2 = int(b[3])

c1 = a * b0
c2 = a // 10 * b1
c3 = a1 * b1 * 0.1
c4 = a // 100 * b2
c5 = a2 * b2 * 0.01
c6 = int(c3 + c5)
print(c1 + c2 + c4 + c6)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def resolve():
    import sys
    input = sys.stdin.readline
    from decimal import Decimal
    # 整数 1 つ
    # n = int(input())
    # 整数複数個
#    a = int(input().split())
    a, b = map(str, input().split())
    a = Decimal(a)
    b = Decimal(b)
    # 整数 N 個 (改行区切り)
    # N = [int(input()) for i in range(N)]
    # 整数 N 個 (スペース区切り)
    # N = list(map(int, input().split()))
    # 整数 (縦 H 横 W の行列)
    # A = [list(map(int, input().split())) for i in range(H)]

    print(int(a*b))


resolve()

Submission status: Accepted

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