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 numpy as np
import re
import math
from collections import defaultdict
from collections import deque
import collections
from fractions import Fraction
from queue import PriorityQueue
import itertools
from copy import deepcopy
import random
from decimal import Decimal
import time
import os
import sys
import datetime
from functools import lru_cache
from functools import reduce
readline=sys.stdin.readline
sys.setrecursionlimit(2000000)
alphabet="abcdefghijklmnopqrstuvwxyz"
numbers="0123456789"
mod=int(10**9+7)
inf=int(10**19)
class Edge():
    def __init__(self,x,y,val=1):
        self.x=x
        self.y=y
        self.val=val
class unionfind():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(n)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):
            self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def yn(b):
    if b:print("yes")
    else:print("no")
def Yn(b):
    if b:print("Yes")
    else:print("No")
def YN(b):
    if b:print("YES")
    else:print("NO")
def ispow(a,b):
    now=b
    while now<a:
        now*=b
    return now==a
def getbin(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def getfacs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod_>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def nextcomb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:return num
def getprimes(n):
    if n==0:return []
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    ret=[]
    for a in range(n+1):
        if(A[a]):ret.append(a)
    return ret
def isprime(num):
    if(num<=1):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(bbool,ret1,ret2):
    if bbool:return ret1
    else:return  ret2
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
def factorize(n):
    b = 2
    ret=defaultdict(int)
    while b * b <= n:
        while n % b == 0:
            n //= b
            ret[b]+=1
        b+=1
    if n > 1:ret[n]+=1
    return ret
def pm(x):
    return x//abs(x)
def inputintlist(): 
    return list(map(int,input().split()))
def istanchouzouka(A):
    f=True
    prev=min(A)-1
    for a in A:
        if prev>=a:
            f=False
        prev=a
    return f
def istanchouhigensyou(A):
    f=True
    prev=min(A)-1
    for a in A:
        if prev>a:
            f=False
        prev=a
    return f
def getallsum(A):
    s=sum(A)
    dp=defaultdict(int)
    dp[0]=1
    for a in range(0,len(A)):
        for b in range(s,-1,-1):
            if b-A[a]>=0:
                dp[b]+=dp[b-A[a]]
    return dp
def yuukoutomukou(edges):
    ret=deepcopy(edges)
    for edge in edges:
        if not edge.x==edge.y:
            ret.append(Edge(edge.y,edge.x,edge.val))
    return ret
def dijkstra(edges,V,start):
    mincost=[inf]*V
    G=[[] for a in range(V)]
    for edge in edges:
        G[edge.x].append([edge.val,edge.y])
    Q=PriorityQueue()
    Q.put([0,start])#[cost,x]
    while not Q.empty():
        nowcost,nowx=Q.get()
        if mincost[nowx]==inf:
            mincost[nowx]=nowcost
            for cost,y in G[nowx]:
                newcost=nowcost+cost
                Q.put([newcost,y])
    return mincost
def warshallfloyd(edges,V):
    mincost=[[inf for b in range(V)] for a in range(V)]
    for a in range(V):mincost[a][a]=0
    for edge in edges:
        mincost[edge.x][edge.y]=min(mincost[edge.x][edge.y],edge.val)#x→yが複数ある場合のためにmin()する
    for k in range(V):
        for s in range(V):
            for t in range(V):
                if mincost[s][k]==inf or mincost[k][t]==inf:continue
                mincost[s][t]=min(mincost[s][t],mincost[s][k]+mincost[k][t])
    return mincost
def bellemanford(edges,V,start):
    mincost=[inf]*V
    mincost[start]=0
    for _ in range(V):
        for edge in edges:
            if mincost[edge.x]==inf:continue
            mincost[edge.y]=min(mincost[edge.y],mincost[edge.x]+edge.val)
    return mincost
def ruisekiwa(A):
    ret=[0]*(len(A)+1)
    for a in range(len(A)):
        ret[a+1]=ret[a]+A[a]
    return ret
def getmd(x1,y1,x2,y2):
    return abs(x1-x2)+abs(y1-y2)
def geted(x1,y1,x2,y2):
    return math.sqrt((x1-x2)**2+(y1-y2)**2)
class fordfulkerson():
    def __init__(self,edges,V,s,t):
        self.V=V
        self.used=[False]*V
        self.G=[[] for a in range(V)]
        self.s=s
        self.t=t
        for edge in edges:
            self.G[edge.x].append({"x":edge.x,"y":edge.y,"cap":edge.val,"rev":len(self.G[edge.y])})
            self.G[edge.y].append({"x":edge.y,"y":edge.x,"cap":0,"rev":len(self.G[edge.x])-1})
    def dfs(self,v,t,f=inf):
        if v==t:return f
        self.used[v]=True
        for a in range(len(self.G[v])):
            x=self.G[v][a]["x"]
            y=self.G[v][a]["y"]
            cap=self.G[v][a]["cap"]
            rev=self.G[y][self.G[x][a]["rev"]]
            if self.used[y] or cap==0:continue
            f2=self.dfs(y,t,min(f,cap))
            if f2>0:
                self.G[v][a]["cap"]-=f2
                rev["cap"]+=f2
                return f2
        return 0
    def maxflow(self):
        flow=0
        while True:
            self.used=[False]*V
            zouka=self.dfs(self.s,self.t)
            if zouka==0:break
            flow+=zouka
        return flow









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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
A,B=input().split()
A=int(A)
S=""
for i in B:
    if i!=".":
        S+=i
S=int(S)
print((A*S)//100)

Submission status: Accepted

Solution code:
import sys
import decimal

sys.setrecursionlimit(10 ** 8)
ni = lambda: int(sys.stdin.readline())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
ns = lambda: sys.stdin.readline().rstrip()

A, B = ns().split()
A = int(A)
B = decimal.Decimal(B)


def solve():
    return int(A * B)


print(solve())

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

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

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    a, b = LS()
    a = int(a)
    if b == '0':
        print(0)
        return
    s = ''
    for c in b:
        if c == '.':
            continue
        s += c
    s = int(s)
    print(a * s//100)


main()

Submission status: Accepted

Solution code:
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def FLIST(n):
    res = [1]
    for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
    return res

A,B=input().split()
AA=int(A)
BB=int(B[0])*100 + int(B[2])*10 + int(B[3])

print((AA*BB)//100)

Submission status: Accepted

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

Submission status: Accepted

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

    a = int(a)
    if len(b) == 4:
        b = int(b[0] + b[2] + b[3])
    else:
        b = int(b[0] + b[1] + b[3] + b[4])

    print(a * b // 100)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(100000)


def main():
    b, c = [i for i in input().strip().split()]
    b = int(b)
    c = int(c.replace(".", ""))

    ans = (b * c) // 100

    return ans


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

Submission status: Accepted

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

Submission status: Accepted

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

a = int(A)
N = len(B)
b = 100 * int(B[:N - 3]) + int(B[N - 2:])

# print (a, b)

ans = a * b // 100

print (ans)

Submission status: Accepted

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


s1 = a*b0
s2 = a*b1
s3 = a*b2

hoge = s1*100+s2*10+s3

if len(str(hoge)) <= 2:
    print(0)
else:
    print(str(hoge)[:-2])

Submission status: Accepted

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

a=int(a)
b=int("".join(b.split(".")))

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

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_DOWN

a, b = input().split()

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

ans = Decimal(a*b).quantize(Decimal("0"), rounding=ROUND_DOWN)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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:
def main():
    A, B = input().split()
    A = int(A)
    B = int(B[:-3] + B[-2:])
    return (A * B)//100
print(main())

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque 
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率

def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 10**9+7
    #w.sort(key=itemgetter(1),reversed=True)  #二個目の要素で降順並び替え
    import decimal
    #N = int(input())
    A,B =  input().split()
    A=decimal.Decimal(A)
    B = decimal.Decimal(B)
    #A = tuple(map(int, input().split())) #1行ベクトル
    #L = tuple(int(input()) for i in range(N)) #改行ベクトル
    #S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列

    print(math.floor(A*B))




if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from decimal import Decimal
a,b = input().split()
d = Decimal(a)
c = Decimal(b)
print((d*c)//1)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

a = int(a)
b_1 = int(b[:-3])*100
b_2 = int(b[-2:])

# print(b_1)
# print(b_2)

print(a*(b_1+b_2)//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:
from decimal import *

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

Submission status: Accepted

Solution code:
a,b=[_ for _ in input().split()]
a=int(a)

b=b.replace(".","")
b=int(b)

print(a*b//100)

Submission status: Accepted

Solution code:
def LI():return list(map(int,input().split()))
def yes():return print("Yes")
def no():return print("No")
from collections import deque, defaultdict, Counter
from heapq import heappop, heappush
import math
from decimal import Decimal
# pi=math.pi
# print(pi)
# yes()
# no()
# n=int(input())

# s=input()
a,b=map(Decimal,input().split())
a=100*a
b=100*b
# print(type(a),type(b))
print(a*b//10000)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from math import gcd

from math import factorial as f

from math import ceil,floor,sqrt
import math

import bisect
import re
import heapq


from copy import deepcopy
import itertools
from itertools import permutations

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))


yes = "Yes"
no = "No"


def main():
    inp = list(input().split())
    a = int(inp[0])
    bstr = ''
    for i in inp[1]:
        if i == '.':
            continue
        bstr+=i
    b = int(bstr)
    ans = a*b
    print(ans//100)


main()

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

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


def solve(A: int, B: int):
    print(A * B // 100)
    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 = int(next(tokens).replace('.', ''))  # type: float
    solve(A, B)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

print(int(A)*int(B.replace(".",""))//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

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

Submission status: Accepted

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

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:
v = list(input().split())
a = int(v[0])
cad = ""
for i in range(len(v[1])):
	if(v[1][i] != '.'):
		cad += v[1][i]
ans = a * int(cad)
ans //= 100
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B = input().split()
A = int(A)
B = int(''.join([s for s in B if s != '.']))
ans = (A*B)//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:
l = input()
l = l.replace('.', " ")
# print(l)
l = [int(i) for i in l.split()]
a, b, c = l
# print(l)
b = b * 100 + c
a *= b
a //= 100
print(a)

Submission status: Accepted

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

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

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

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
AB = input().split()
A = int(AB[0])
B_int = int(AB[1][0])
B_float = int(AB[1][2:])
print(A * (100 * B_int + B_float) // 100)

Submission status: Accepted

Solution code:
import sys, math,os
from io import BytesIO, IOBase
#from bisect import bisect_left as bl, bisect_right as br, insort
#from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(Decimal, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7
from decimal import Decimal


def main():

    a,b=mdata()
    out(int(a*b))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from math import floor
A,B = input().split()
A = int(A)
B = int(B.replace(".", ""))
print(A * B//100)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15

def main():
    L = input().split()
    A = int(L[0])
    B = 100 * int(L[1][0]) + int(L[1][2:4])
    print(A*B//100)
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A,B = input().split()
A = int(A)
B100 = int(B.replace('.',''))
print(A*B100 // 100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B=input().split()
A,B=int(A),int(B[:1]+B[2:])
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:
from collections import Counter
import sys

sys.setrecursionlimit(10 ** 6)

mod = 1000000007
inf = int(1e18)

dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]


def inverse(a):
    return pow(a, mod - 2, mod)


def usearch(x, a):
    lft = 0
    rgt = len(a) + 1
    while rgt - lft > 1:
        mid = (rgt + lft) // 2
        if a[mid] <= x:
            lft = mid
        else:
            rgt = mid
    return lft


def main():
    a, b = input().split()
    a = int(a)
    b = b.split('.')
    if len(b) == 1:
        print(a * int(b[0]))
        return
    k = pow(10, len(b[1]))
    s = a * (int(b[0]) * k + int(b[1])) // k
    print(s)
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:
a, b = input().split()
a = int(a)
bx100 = int(b.replace('.', ''))
print(a * bx100 // 100)

Submission status: Accepted

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

Submission status: Accepted

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

b100 = int(b[0])*100 + int(b[2])*10 + int(b[3])
print(a * b100 // 100)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def divisor(n):
        res = []
        i = 1
        for i in range(1, int(n ** 0.5) + 1):
            if n % i == 0:
                res.append(i)
                if i != n // i:
                    res.append(n // i)
        return res

    @staticmethod
    def round_up(a, b):
        return -(-a // b)

    @staticmethod
    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


MOD = int(1e09) + 7
INF = int(1e15)


def solve():
    S = Scanner.string().split()
    getcontext().rounding = ROUND_DOWN
    A = Decimal(S[0])
    B = Decimal(S[1])
    ans = A * B
    print(ans.__int__())


def main():
    # sys.stdin = open("sample.txt")
    # print('YNEOS'[not solve()::2])
    solve()


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import math
from decimal import  *

getcontext().prec = 400

A, B = input().split()

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


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

Submission status: Accepted

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


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


# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
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 = next(tokens)  # type: int
    B = int(B.replace('.', ''))
    print(solve(A, B))

def test():
    import doctest
    doctest.testmod()

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

Submission status: Accepted

Solution code:
from decimal import *

def main():

    x,y = input().split()

    x,y = Decimal(x),Decimal(y)

    print(int(x*y))

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10 ** 8)

def Z(): return int(input())
def ZZ(): return [int(_) for _ in input().split()]

def main():
    s = input().split()
    a = int(s[0])
    b = int(s[1].replace('.', ''))
    print(a*b//100)

    return

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
AB = input().split()
A = int(AB[0])
B = AB[1].split('.')
B = int(B[0])*100 + int(B[1])
print(A*B//100)

Submission status: Accepted

Solution code:
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

Submission status: Accepted

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

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

res = 0
mul = 1
for c in reversed(b):
    if c == ".":
        continue
    res += a * int(c) * mul
    mul *= 10

print(res // 100)

Submission status: Accepted

Solution code:
A, B = input().split()
A = int(A)
if "." in B:
    b, c = map(int, B.split("."))
else:
    b = int(B)
print(A * (b * 100 + c) // 100)

Submission status: Accepted

Solution code:
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

A, B = input().split()

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

print(A * B // 100)

Submission status: Accepted

Solution code:
#デフォルト
import itertools
from collections import defaultdict
import collections
import math
import sys
from decimal import *
sys.setrecursionlimit(200000)
mod = 1000000007

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

print(math.floor(a * b))

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 functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
from decimal import Decimal

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

# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
    return [ int(s) for s in input().split(" ")]

# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
    return [ int(input()) for _ in range(n)]

# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
    return map(int, open(0).read().split())

def rangeI(it, l, r):
    for i, e in enumerate(it):
        if l <= i < r:
            yield e
        elif l >= r:
            break

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

INF = 999999999999999999999999
MOD = 10**9+7

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

print(int(a*b))