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

Solution (Python):
import sys,bisect,string,math,time,functools,random,fractions
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
rep=range
def Golf():n,*t=map(int,open(0).read().split())
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def RA():return map(int,open(0).read().split())
def GI(V,E,ls=None,Directed=False,index=1):
    org_inp=[];g=[[] for i in range(V)]
    FromStdin=True if ls==None else False
    for i in range(E):
        if FromStdin:
            inp=LI()
            org_inp.append(inp)
        else:
            inp=ls[i]
        if len(inp)==2:
            a,b=inp;c=1
        else:
            a,b,c=inp
        if index==1:a-=1;b-=1
        aa=(a,c);bb=(b,c);g[a].append(bb)
        if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'

    mp=[boundary]*(w+2);found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
    mp+=[boundary]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def accum(ls):
    rt=[0]
    for i in ls:rt+=[rt[-1]+i]
    return rt
def bit_combination(n,base=2):
    rt=[]
    for tb in range(base**n):s=[tb//(base**bt)%base for bt in range(n)];rt+=[s]
    return rt
def gcd(x,y):
    if y==0:return x
    if x%y==0:return y
    while x%y!=0:x,y=y,x%y
    return y
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)
 
YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
l_alp=string.ascii_lowercase

read=sys.stdin.buffer.read
readline=sys.stdin.buffer.readline
input=lambda: sys.stdin.readline().rstrip()


class Tree:
    def __init__(self,inp_size=None,ls=None,init=True,index=0):
        self.LCA_init_stat=False
        self.ETtable=[]
        if init:
            if ls==None:
                self.stdin(inp_size,index=index)
            else:
                self.size=len(ls)+1
                self.edges,_=GI(self.size,self.size-1,ls,index=index)
        return
 
    def stdin(self,inp_size=None,index=1):
        if inp_size==None:
            self.size=int(input())
        else:
            self.size=inp_size
        self.edges,_=GI(self.size,self.size-1,index=index)
        return
    
    def listin(self,ls,index=0):
        self.size=len(ls)+1
        self.edges,_=GI(self.size,self.size-1,ls,index=index)
        return
 
    def __str__(self):
        return  str(self.edges)
 
    def dfs(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
        q=deque()
        q.append(x)
        v=[-1]*self.size
        v[x]=root_v
        while q:
            c=q.pop()
            for nb,d in self.edges[c]:
                if v[nb]==-1:
                    q.append(nb)
                    v[nb]=func(v[c],nb,d)
        return v
 
    def EulerTour(self,x):
        q=deque()
        q.append(x)
        self.depth=[None]*self.size
        self.depth[x]=0
        self.ETtable=[]
        self.ETdepth=[]
        self.ETin=[-1]*self.size
        self.ETout=[-1]*self.size
        cnt=0
        while q:
            c=q.pop()
            if c<0:
                ce=~c
            else:
                ce=c
                for nb,d in self.edges[ce]:
                    if self.depth[nb]==None:
                        q.append(~ce)
                        q.append(nb)
                        self.depth[nb]=self.depth[ce]+1
            self.ETtable.append(ce)
            self.ETdepth.append(self.depth[ce])
            if self.ETin[ce]==-1:
                self.ETin[ce]=cnt
            else:
                self.ETout[ce]=cnt
            cnt+=1
        return
    
    def LCA_init(self,root):
        self.EulerTour(root)
        self.st=SparseTable(self.ETdepth,init_func=min,init_idl=inf)
        
        self.LCA_init_stat=True
        return
    
    def LCA(self,root,x,y):
        if self.LCA_init_stat==False:
            self.LCA_init(root)
        xin,xout=self.ETin[x],self.ETout[x]
        yin,yout=self.ETin[y],self.ETout[y]
        a=min(xin,yin)
        b=max(xout,yout,xin,yin)
        id_of_min_dep_in_et=self.st.query_id(a,b+1)
        return self.ETtable[id_of_min_dep_in_et]




class SparseTable: 
    def __init__(self,ls,init_func=min,init_idl=float('inf')):
        self.func=init_func
        self.idl=init_idl
        self.size=len(ls)
        self.N0=self.size.bit_length()
        self.table=[ls[:]]
        self.index=[list(range(self.size))]
        self.lg=[0]*(self.size+1)
        
        for i in range(2,self.size+1):
            self.lg[i]=self.lg[i>>1]+1
 
        for i in range(self.N0):
            tmp=[self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) for j in range(self.size)]
            tmp_id=[self.index[i][j] if self.table[i][j]==self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) else self.index[i][min(j+(1<<i),self.size-1)] for j in range(self.size)]
            self.table+=[tmp]
            self.index+=[tmp_id]
    
    
    def query(self,l,r):
        if r>self.size:r=self.size
        
        N=self.lg[r-l]
        return self.func(self.table[N][l],self.table[N][max(0,r-(1<<N))])
    
    
    def query_id(self,l,r):
        if r>self.size:r=self.size
        
        N=self.lg[r-l]
        a,b=self.index[N][l],self.index[N][max(0,r-(1<<N))]
        if self.table[0][a]==self.func(self.table[N][l],self.table[N][max(0,r-(1<<N))]):
            b=a
        return b
    
    
    def right_bound(self,pos,x):
        k=(self.size-pos).bit_length()
        for j in range(k)[::-1]:
            nx=pos+(1<<j)
            if nx<n and self.query(pos,nx+1)<=x:
                pos+=(1<<j)
        return pos
    
    
    def left_bound(self,pos,x):
        k=pos.bit_length()
        for j in range(k)[::-1]:
            nx=pos-(1<<j)
            if 0<=nx and self.query(nx,pos+1)<=x:
                pos-=(1<<j)
        return pos

    def __str__(self):
        return str(self.table[0])
 
    def print(self):
        for i in self.table:
            print(*i)
 



def primeFactor(N):
    i,n=2,N
    ret={}
    d,sq=2,99
    while i<=sq:
        k=0
        while n%i==0:
            n,k,ret[i]=n//i,k+1,k+1
        if k>0 or i==97:
            sq=int(n**(1/2)+0.5)
        if i<4:
            i=i*2-1
        else:
            i,d=i+d,d^6
    if n>1:
        ret[n]=1
    return ret




def PrimeNumSet(N):
    Max = int(N**0.5)
    seachList = [i for i in range(2,N+1)]
    primeNum = []
    while seachList:
        if seachList[0] <= Max:
            break
        primeNum.append(seachList[0])
        tmp = seachList[0]
        seachList = [i for i in seachList if i % tmp != 0]
    primeNum.extend(seachList)
    return primeNum



def LCM(b,mo=10**9+7):
    prs=PrimeNumSet(max(b))
    M=dict(zip(prs,[0]*len(prs)))
    for i in b:
        dc=primeFactor(i)
        for j,k in dc.items():
            M[j]=max(M[j],k)
    
    r=1
    for j,k in M.items():
        if k!=0:
            r*=pow(j,k,mo)
            r%=mo
    return r

 
show_flg=False
show_flg=True
ans=0


a,b=input().split()
a=int(a)
c=b[:-3]+b[-2:]
c=int(c)


ans=a*c//100

print(ans)

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

Solution (Python):
def resolve():
    a, b = input().split()
    a = int(a)
    b = int((float(b) + 0.001) * 100)
    print(a * b // 100)


if __name__ == '__main__':
    resolve()

Solution (Python):

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

print(math.floor(a*b))

Solution (Python):
a, b = input().split()
a = int(a)
b = int(b.replace('.', ''))
c = str(a * b)[:-2]
if c == '':
    print(0)
else:
    print(c)

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

Solution (Python):
import sys
input = sys.stdin.readline
import numpy as np
from decimal import *

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

print(int(a*b))

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

Solution (Python):
import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    sys.setrecursionlimit(10**7)
    INF = 10**18
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

Solution (Python):
from __future__ import division, print_function

''' Hey stalker :) '''
INF = 10 ** 10
TEST_CASES = False


def main():
    a, b = input().split()
    b1, b2 = b.split(".")
    print(int(a)*int(b1) + (int(b2)*int(a))//100)

''' FastIO Footer: PyRival Library, Thanks @c1729 and contributors '''
import os
import sys
from bisect import bisect_left, bisect_right
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)



input = lambda: sys.stdin.readline().rstrip("\r\n")
get_int = lambda: int(input())
get_list = lambda: list(map(int, input().split()))
if __name__ == "__main__":
    if TEST_CASES:
        [main() for _ in range(int(input()))]
    else:
        main()

Solution (Python):
import sys
import math
from decimal import *

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

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

Solution (Python):
from math import trunc
from decimal import Decimal
a, b = [Decimal(i) for i in input().split()]

print(trunc(a * b))

Solution (Python):


def submit():
    a_str, b_str = input().split()
    a = int(a_str)

    b = 0
    for bc in b_str:
        if bc == ".":
            continue
        b *= 10
        b += int(bc)

    print((a * b) // 100)

submit()

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(200000)
from decimal import *


def read():
    A, B = input().strip().split()
    return Decimal(A), Decimal(B)


def solve(A, B):
    x = A * B
    return x.quantize(Decimal("1."), rounding=ROUND_FLOOR)


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))

Solution (Python):
a, b = input().split()
a = int(a)
b1, b2 = map(int, b.split('.'))

print(a*b1 + (a*b2)//100)

Solution (Python):
inp = input().split()

a = int(inp[0])
b = 100*int(inp[1][:-3]) + int(inp[1][-2:])

print(a*b//100)

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

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

Solution (Python):
a,b=map(str,input().split())
a=int(a)
n=len(b)
c=int(b[:n-3]+b[n-2:])
print(a*c//100)

Solution (Python):

from sys import stdin
input = stdin.readline
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

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

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

print(a*b//100)

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

A = int(A)

B1, B2, B3 = int(B[0]), int(B[2]), int(B[3])


A1 = A*B1*100
A2 = A*B2*10
A3 = A*B3*1

ans = (A1+A2+A3) // 100

print(ans)

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    a, b = input().split()
    c, d = int(a), int(b[0] + b[-2:])

    print(c * d // 100)


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
a,b=input().split()
a=int(a)
s=b.split('.')
z=s[0]+s[1]
z=int(z)
z=a*z
z//=100
print(z)

Solution (Python):
from decimal import Decimal

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

print(int(a * b))

Solution (Python):
import decimal

A, B = input().split()

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

print(int(A * B))

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

Solution (Python):
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

s = rs()
A, B = s.split()
A = int(A)
B = int(B.replace('.',''))

print(A*B//100)

Solution (Python):


import decimal
import math


def prod_floor(a, b):
    return math.floor(a * b)


def main():
    decimal.getcontext().prec = 26
    a, b = (decimal.Decimal(x) for x in input().split())
    res = prod_floor(a, b)
    print(res)


if __name__ == '__main__':
    main()

Solution (Python):
s, t = input().split()
a = int(s)


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

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
import math


def main():
    A, B = input().split()
    A = int(A)
    B1, B2 = map(int, B.split("."))

    tot = A*B1
    tot += (A*B2)//100
    print(tot)

    return


if __name__ == '__main__':
    main()

Solution (Python):
A, B = input().split()
b, c = B.split('.')
ans = int(A)*(int(b)*100+int(c))//100
print(ans)

Solution (Python):


import sys
readline = sys.stdin.readline
read = sys.stdin.read


a,b = read().split()
a = int(a)
b = int(b.replace(".",""))

print(a*b//100)

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

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


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


if __name__ == '__main__':
    resolve()

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

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

Solution (Python):
import math
a,b=map(str,input().split())
a=int(a)
d=int(b[0])*100+int(b[2])*10+int(b[3])
c=(a*d)//100
if (c+1)*100<=(a*d):
  c+=1
print(c)

Solution (Python):
def c_multiplication_3():
    from decimal import Decimal
    I = input().split()
    A = Decimal(I[0])
    B = Decimal(I[1])
    return A * B // 1

print(c_multiplication_3())

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

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product, combinations_with_replacement
import sys
import bisect
import string
import math
import time
from decimal import *


def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def print_matrix(mat):
    for i in range(len(mat)):
        print(*['IINF' if v == IINF else "{:0=4}".format(v) for v in mat[i]])


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False



def main():
    A, B = MS()
    getcontext().prec = 28

    a = Decimal(A) * Decimal(B)

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


if __name__ == '__main__':
    main()

Solution (Python):
from decimal import *

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

c = a*b

n = 0
ans =c.quantize(Decimal(str(10**(n*-1))), rounding = ROUND_DOWN)
print(ans)

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

Solution (Python):

import decimal

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

Solution (Python):
from decimal import Decimal

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

Solution (Python):
import math
import decimal

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

print(math.floor(a*b))

Solution (Python):
import sys
import re
import random

from math import sqrt,log,floor
from fractions import gcd  
from collections import Counter, defaultdict

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



def read_int():
  return int(input())

def read_ints():
  
  return [int(x) for x in input().split()]

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

def read_fields():
  return input().rstrip().split()

def print_array(ar):
  n = len(ar)
  for i in range(n-1):
    print(ar[i], end=' ')
  print(ar[-1])

def say_bool(val, strs=['Yes','No']):
  print(strs[int(val)])

def say_Yes(val):
  say_bool(val, ['Yes', 'No'])

def say_YES(val):
  say_bool(val, ['YES', 'NO'])

def say_Alice(val):
  say_bool(val, ['Alice', 'Bob'])

def say_TAKAHASHI(val):
  say_bool(val, ['TAKAHASHI', 'AOKI'])




MOD=1000000007

def ADD(x, y):
  return (x + y) % MOD

def SUB(x, y):
  return (x - y + MOD) % MOD

def MUL(x, y):
  return x * y % MOD

def POW(x, e):
  v = 1
  while e:
    if e & 1:
      v = MUL(v, x)
    x = MUL(x, x)
    e >>= 1
  return v

def INV(x):
  return POW(x, MOD-2)

def DIV(x, y):
  return MUL(x, INV(y))







def solve(a,b):
    b = int(round(b*100))
    return a * b // 100

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


a=int(a)
b=float(b)


print(solve(a,b))

Solution (Python):



from fractions import Fraction


def main():
    a_s, b_s = input().split()
    a, b = int(a_s), Fraction(b_s)

    print(int(a * b))


if __name__ == '__main__':
    main()

Solution (Python):
from decimal import *
getcontext().prec = 32
a, b = list(map(Decimal, input().split()))
print(int(a*b))

Solution (Python):
input = raw_input

nums = input().split(" ")

ds = [0, 0]
for i, num in enumerate(nums):
    if "." in num:
        d = num[::-1].index(".")
        ds[i] = d
        num = int(num.replace(".", ""))
    else:
        num = int(num)

    if i == 0:
        a = num
    else:
        b = num

out = a * b
sd = sum(ds)
out = out // (10 ** sd)

print(out)

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


A = int(A)
x, y = map(int, B.split('.'))

print(A*(100*x+y)//100)

Solution (Python):


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

Solution (Python):
from decimal import Decimal

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

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

Solution (Python):
from decimal import Decimal

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

Solution (Python):
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())

Solution (Python):
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()

Solution (Python):
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)

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

Solution (Python):
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()

Solution (Python):
import numpy as np
from decimal import *
input = input().split(" ")
a, b = Decimal(input[0]), Decimal(input[1])
print(np.floor(a*b))