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):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, cos, radians, pi, sin
from operator import mul
from functools import reduce
from operator import mul
from decimal import Decimal

mod = 10 ** 9 + 7
INF = 10 ** 13
sys.setrecursionlimit(2147483647)
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]



a, b = LS()
a = Decimal(a)
b = Decimal(b)
print(int(a * b))

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

import math

a,b = nn()
c,d = b.split('.')
a,b = int(a),int(c)*100+int(d)

print(a*b//100)

Solution (Python):
import math
from decimal import Decimal

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

result = math.floor(A * B)

print(result)

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

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

print(math.floor(a * b))

Solution (Python):
import sys
import math
from collections import deque
import heapq
import itertools
from decimal import Decimal
MAX_INT = int(10e25)
MIN_INT = -MAX_INT
mod = 1000000000+7
sys.setrecursionlimit(1000000)
def IL(): return list(map(float,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

a,b = SL()

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

print(ans)

Solution (Python):
str_A,str_B = input().split()

A = int(str_A)
B = int(str_B[0])*100+int(str_B[2:])




print((A*B)//100)

Solution (Python):
t = input().split()
a = int(t[0])
b = round(float(t[1]) * 100)
print(a * b // 100)

Solution (Python):
a, b = input().split()
a = int(a)
b = b.split('.')
b = int(b[0] + b[1])
ans = str(a * b)
if len(ans) <= 2:
    print(0)
else:
    print(ans[:-2])

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

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

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

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

    decimal_digit = len(B) - 2
    B_int = int("".join(B.split('.')))

    tmp = A * B_int
    tmp = str(tmp)
    
    if int(tmp) <= decimal_digit:
        print("0")
    else:
        print(tmp[:len(tmp)-decimal_digit])

if __name__ == '__main__':
    solve()

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

Solution (Python):
temp = input().split()
a = int(temp[0])
b = int(float(temp[1])*100+0.01)
print(int(a*b//100))

Solution (Python):
from decimal import Decimal, ROUND_FLOOR

a, b = map(Decimal, input().split())
print((a*b).quantize(Decimal('1'), rounding=ROUND_FLOOR))

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


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    import decimal
    a, b = map(float, input().split())

    i = decimal.Decimal(str(a))
    j = decimal.Decimal(str(b))
    k = i * j
    x = int(k)
    print(x)

if __name__ == '__main__':
    main()

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)
b = int(b[:-3]+b[-2:])
print(a*b//100)

Solution (Python):
import math
a,b=input().split()
a=int(a)
b=int(b.replace(".",""))
if len(str(a*b))>2:
    print(str(a*b)[:-2])
else:
    print(0)

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

if "." in B:
    keta = (len(B) - B.index(".") - 1)
    B_fix = int(B.replace(".",""))
    print(A * B_fix // (10**keta))
else:
    print(A * B)

Solution (Python):
from decimal import Decimal

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

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

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

Solution (Python):
import math
     
s = input().split()

s[1] = s[1].replace(".", "")
     
num = int(s[0]) * int(s[1])
     
print(num // 100)

Solution (Python):


def main():
    A, B = input().split()
    A = int(A)
    B = float(B)
    B = int(B*100 + 0.5)
    result = str(A*B)[:-2] or '0'
    print(result)

if __name__ == '__main__':
    main()

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

Solution (Python):
from decimal import Decimal

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

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

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

Solution (Python):
import sys
import numpy as np
import math
import random
from decimal import Decimal
import itertools
import re
from collections import deque, Counter
from functools import lru_cache

sys.setrecursionlimit(2147483647)
INF = 10**13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007

def main():
	a, b = LS()
	ad = Decimal(a)
	bd = Decimal(b)
	product = ad * bd
	print(int(product))




if __name__ == '__main__':
    main()

Solution (Python):
import itertools
from functools import cmp_to_key
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

string = readline().decode().replace(".", "")
A, B = [int(i) for i in string.split()]

ret = A*B
ret = ret//100

print(ret)

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

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

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



print(int(A * B))

Solution (Python):
import math
from collections import deque
from collections import defaultdict



def readInt():
	return int(input())
def readInts():
	return list(map(int, input().split()))


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

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


ans = (a*c)//1000

print(ans)

Solution (Python):
def mapint_inp():
    return map(int, input().split())

def intinp():
    return int(input())

import decimal

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

print((A*B).quantize(decimal.Decimal('1'), rounding=decimal.ROUND_FLOOR))

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

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


a, b = input().split()

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

print(int(a*b))

Solution (Python):
import math
from decimal import *

def main():
    a, b = input_list()
    print(int(a*b))

def yogen(a, b, angle):
    coss = math.cos((angle/180)*math.pi)
    return math.sqrt(a**2 + b**2 - 2*a*b*coss)


def get_angle(hour, minute):
    h = (hour * 360) / 12 + (minute * 360) / (12 * 60)
    m = (minute * 360) / 60
    angle = abs(h-m)
    return min(angle, 360-angle)

def has(v, l):
    for vl in l:
        if v == vl:
            return True
    return False

def input_list():
    return list(map(Decimal, input().split()))


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
from decimal import Decimal as d,ROUND_FLOOR as r

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

print((a*b).quantize(d('0'),rounding=r))

Solution (Python):
import math


def main():
    s, t = input().split()
    A = int(s)
    b, c = map(int,t.split("."))
    ans = A*b + A*c//100
    print(ans)
 
 
if __name__ == '__main__':
    import sys
    sys.setrecursionlimit(10000)
    main()

Solution (Python):
SA, SB = input().split()
A = int(SA)
sb1, sb2 = SB.split('.')
if len(sb2) == 1: sb2+="0"
B100 = int(sb1)*100 + int(sb2)
ans = A * B100 // 100
print(ans)

Solution (Python):
import math
import decimal
a, b = input().split()
a = decimal.Decimal(a)
b = decimal.Decimal(b)
ans = a * b

print(math.floor(ans))

Solution (Python):

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

Solution (Python):
import math
import decimal

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

Solution (Python):
a, b = input().split()
a = int(a)
x, y = b.split(".")
x = int(x)
y = int(y)
print(int(a*x+a*y//100))

Solution (Python):
import numpy as np

A, B = input().split()

A = np.int64(A)

B1 = np.int64(B[0])

B2 = np.int64(B[2:4])

res = (A * B1) + (A * B2) // 100







print(res)

Solution (Python):

MOD = 10 ** 9 + 7
INFI = 10**10

import math
from collections import deque
import itertools
import heapq

from fractions import Fraction
import copy
from functools import lru_cache



def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default




def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)



def main():
    n=list(input().split())
    a=int(n[0])
    b=int((str(n[1][0])+str(n[1][2:4])))

    ans=a*b//100
    temp=float(n[1])
 
    print(ans)










if __name__ == "__main__":

    main()

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

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

b1,b2 = map(int,B.split("."))
B = 100*b1 + b2
print((A*B)//100)

Solution (Python):
from decimal import Decimal

s = input().split()

a = int(s[0])
b = Decimal(s[1])

print(int(a * b))

Solution (Python):
from decimal import Decimal
from decimal import ROUND_FLOOR
a, b = input().split(" ")
a = Decimal(a)
b = Decimal(b)
m = a * b

print(m.quantize(0, rounding=ROUND_FLOOR))

Solution (Python):
A, B = map(str, input().split())
A = int(A)
ans = A * int(B[0])
ans2 = A * int(B[2]) // 10
ans3 = (A * int(B[2]) - ans2 * 10) / 10
ans4 = A * int(B[3]) // 100
ans5 = (A * int(B[3]) - ans4 * 100) / 100

print(int(ans + ans2 + ans4) + int(ans3 + ans5))

Solution (Python):
from decimal import Decimal, ROUND_DOWN

A, B = input().split()
X = Decimal('0')

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

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

print(X)

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

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

print(ans)

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

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

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

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

Solution (Python):
import math

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

Solution (Python):
from decimal import Decimal
import math
AB = input().split()

a = int(AB[0])
b = Decimal(AB[1])

print(math.floor(a * b))

Solution (Python):

import sys
from decimal import Decimal

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



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

if __name__ == '__main__':
    main()

Solution (Python):
import random
A,B = input().split()
A = int(A)
B = list(B)
B.remove(".")
B = int("".join(B))
ans = A*B//100
print(ans)

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

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

Solution (Python):
from fractions import Fraction
I = input().split()
a = Fraction(int(I[0]), 1)
b_i, b_s = I[1].split('.')
b = Fraction(int(b_i) * 100 + int(b_s), 100)
print(int(a * b))

Solution (Python):
import decimal

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

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

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

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

Solution (Python):
import sys


def main():
    A,B=input().split()
    A=int(A)
    B=int(B.replace(".",""))
    m=str(A*B)

    if len(m)<=2:
        print("0")
    else:
        res=int(m[:len(m)-2])
        print(res)

if __name__ == "__main__":
    main()

Solution (Python):
from decimal import *
def main():
    A,B = input().split()
    A = int(A)
    A,B = Decimal(A),Decimal(B)
    print((A*B).quantize(Decimal('0'), rounding=ROUND_DOWN))


if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
from collections import Counter, deque, defaultdict
from math import floor, ceil
from bisect import bisect_left
from itertools import combinations
setrecursionlimit(100000)

INF = int(1e10)
MOD = int(1e9 + 7)

def main():
    from builtins import int, map
    A, B = input().split()
    A = int(A)

    if A == 0:
        print(0)
        exit()

    B = int(B.replace(".", ""))
    if A == 0 or B == 0:
        print(0)
        exit()
    AB = int(A * B) // 100
    print(AB)

if __name__ == '__main__':
    main()

Solution (Python):
import sys
from math import log2,floor,ceil,sqrt






















Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
 
def input(): return sys.stdin.readline().strip()
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 ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7

a,b = ri().split()
a = int(a)
b = b.split('.')
b[0] = int(b[0])
b[1] = b[1].rstrip('0')
l = len(b[1])




if l == 0:
    print(a*b[0])
else:
    b[1] = int(b[1])
    ans = a*b[0] + a*b[1]//10**l
    print(ans)

Solution (Python):
from decimal import Decimal
num = []
for n in input().split():
    d = Decimal(n)
    num.append(d)

ans = num[0] * num[1]
print(int(ans))

Solution (Python):
mod = 1000000007
eps = 10**-9


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

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


if __name__ == '__main__':
    main()

Solution (Python):
ab = list(input().split())
a = int(ab[0])
b = ab[1]
ans = 0









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

Solution (Python):




a, b = input().split()


bint = int(b[0:len(b)-3])
bfloat = int(b[len(b)-2:len(b)])
ans = int(a) * (bint * 100 + bfloat) // 100


print(ans)

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

A = int(A)

B = int(B[0])*100 + int(B[2])*10 + int(B[3])

print(A*B//100)

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

Solution (Python):
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    A, B = input().split()

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


main()

Solution (Python):
from decimal import *


A, B = input().split()

ans = Decimal(A) * Decimal(B)



print(int(ans))

Solution (Python):
import sys
import heapq

def main():
    a, b = sys.stdin.readline().split()
    a = int(a)
    b = int(b[:-3] + b[-2:])
    ans = a * b // 100
    print(ans)
    return

if __name__ == "__main__":
    main()

Solution (Python):
import math
import decimal

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


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

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

Solution (Python):
from decimal import Decimal
s_list = input().split()
c = str(int(s_list[0])*Decimal(s_list[1]))
print(c.split(".")[0])

Solution (Python):

import sys


sysread = sys.stdin.readline
read = sys.stdin.read



sys.setrecursionlimit(10 ** 7)







import math

def run():
    A, b = input().split()
    A = int(A)
    B = 0
    B += int(b[0]) * 100
    B += int(b[-2:])
    ret = 0
    for _ in range(B):
        ret += A
    print(ret//100)


if __name__ == "__main__":
    run()

Solution (Python):
import decimal

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

print(int(a*b))

Solution (Python):
from decimal import *

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

res = a * b

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

Solution (Python):
from decimal import Decimal, ROUND_FLOOR
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():
    
    A,B=map(str,input().split())

    val=Decimal(B)*Decimal(A)
    print(int(val))
    
resolve()

Solution (Python):
import math
from decimal import Decimal

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

print(math.floor(a*b))

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

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

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

print(int(a * b))

Solution (Python):
from decimal import *
a,b=open(0).read().split()
print(int(Decimal(a)*Decimal(b)))

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

Solution (Python):


import sys
import math
import collections
import itertools
import bisect
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return x if y == 0 else gcd(y, x%y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")
def YesNo(B) : print("Yes" if B else "No")
def YESNO(B) : print("YES" if B else "NO")

A, B = LS()
A = int(A)

B = B.split('.')
Ba = int(B[0])
Bb = int(B[1])

c = 0
Bb *= A
Bb = str(Bb)
if len(Bb) >= 3:
    c = int(Bb[0:len(Bb)-2])

print(A*Ba + c)

Solution (Python):

import math

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

if __name__ == "__main__":
    main()

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

import decimal

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

Solution (Python):
import sys
a, b = sys.stdin.readline().split()
b = b.replace('.', '')
print(int(a) * int(b) // 100)

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

Solution (Python):
import sys
sys.setrecursionlimit(300000)
from decimal import Decimal, getcontext
getcontext().prec = 32

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')
from math import floor

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

Solution (Python):

ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]

a,b = input().split()
a = int(a)
b = list(b.split("."))
b = ''.join(b)
b = int(b)
print(a*b//100)

Solution (Python):
def C():
    A, B = input().split()
    A = int(A)
    B_int = int(B[:B.index('.')])
    B_decimal = int(B[B.index('.')+1:])
    ans_int = A*B_int
    ans_int += B_decimal*A//100
    print(ans_int)
    
C()

Solution (Python):
import sys

def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
from decimal import Decimal

def main():
    a, b = IS().split()
    a = Decimal(a)
    b = Decimal(b)
    print(int(Decimal(a*b)))

if __name__ == '__main__':
    main()

Solution (Python):
A, B = map(str, input().split())
A = int(A)
B1, B2, B3 = int(B[0]), int(B[2]), int(B[3])
ans = A*B1*100 + A*B2*10 + A*B3
ans = str(ans)
if len(ans)>2:
    print(int(ans[:-2]))
else:
    print(0)

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

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

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

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

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

Solution (Python):
import math
from decimal import Decimal

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

a = Decimal(A)
b = Decimal(B)

ans = math.floor(a * b)
print(ans)

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

a = int(a)
bb = int(b.replace('.',''))
ans = a * bb

print(int(ans//100))

Solution (Python):
from decimal import *
s,t=input().split()
k=(Decimal(s)*Decimal(t))//Decimal(1)
print(k)

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
from decimal import *
getcontext().prec = 20 
a,b = readline().rstrip().decode('utf-8').split()
a = Decimal(a)
b = Decimal(b)
c = Decimal(a*b)
print(int(c))

Solution (Python):


def main():
    a, b = map(str, input().split(' '))
    a = int(a)
    b = b[:-3] + b[-2:]
    b = int(b)
    c = a * b // 100
    print(c)

if __name__ == '__main__':
    main()

Solution (Python):
from decimal import Decimal,ROUND_DOWN
a,b=input().split()
ad = Decimal(a)
bd = Decimal(b)
print((ad * bd).quantize(Decimal('0'), rounding=ROUND_DOWN))

Solution (Python):
A, B = [i for i in input().split()]
A = int(A)
B1, B2 = B.split('.')
B = 100 * int(B1) + int(B2)
print(A*B//100)

Solution (Python):
from decimal import Decimal, ROUND_FLOOR

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


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

Solution (Python):
A,B=input().split()
A=int(A)
B=int(B[0]+B[2]+B[3])
X=str(A*B)
if len(X)>2:
  print(X[:-2])
else:
  print(0)

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

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

print(a*b//100)

Solution (Python):
A, B = input().split()
print(int(A + '00')*int(''.join(B.split('.')))//10000)

Solution (Python):












def solve(a , b):
    b = b.replace(".", "")
    b = int(b)
    ans = a*b // 100
    print(ans)
    return


inp = input().split()
a = int(inp[0])
b = inp[1]
solve(a, b)

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

Solution (Python):


import sys
sys.setrecursionlimit(300000)


def solve(A: int, B: float):
    s = int(B[0]) * 100
    x = int(B[2:])
    
    ret = ((s + x) * A) // 100
    print(int(ret))
    return

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

if __name__ == '__main__':
    main()

Solution (Python):
A, B = map(str, input().split())
A = int(A)
B = int(B.replace(".", ""))

print(A* B // 100)

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

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

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

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

Solution (Python):
def solve(a, b):
    a_int = int(a)
    b_int = 0
    c = 0
    for i in range(len(b)):
        if b[- i - 1] == ".":
            continue
        b_int += int(b[- i - 1]) * (10 ** c)
        c += 1
    
    return a_int * b_int // 100


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


def test():
    assert solve("198", "1.10") == 217
    assert solve("1", "0.01") == 0
    assert solve("1000000000000000", "09.99") == 9990000000000000


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

Solution (Python):
import math
from decimal import Decimal
A,B=list(map(Decimal,input().split()))
B=100*B
C=A*B
C=math.floor(C/100)
print(C)

Solution (Python):
import math
from decimal import Decimal, getcontext

getcontext().prec = 99


def resolve():
    A, B = input().split()

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



resolve()

Solution (Python):
import sys




def main():
    

    A_, B_ = [ch for ch in input().split()]
    A = int(A_)
    Bint = int(float(B_[0]))
    Bfloat = int(B_[2:])

    
    
    

    ans = A * Bint + (A * Bfloat // 100)

    
    print(ans)

    
    
    
    

    return 0

if __name__ == '__main__':
    sys.exit(main())

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

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

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

Solution (Python):
a,b=input().split()
c=[]
for i in range(len(b)):
  if b[i]=='.':
    x=i
  else:
    c.append(b[i])
if len(c)<3:
  c.append('0')
d=''.join(c)
if x==2:
  print(int(a)*10)
  exit()
else:
  e=int(a)*int(d)
  e=list(str(e))
  if len(e)<=2:
    print(0)
    exit()
  else:
    e.pop(-1)
    e.pop(-1)
  print(''.join(e))

Solution (Python):




import sys
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

    a,b=map(str, readline().rstrip().split())
    a=int(a)
    b1,b2=b.split(".")
    b=int(b1)*100+int(b2)
    print((a*b)//100)
    
    
    
    

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

Solution (Python):
import math
from decimal import Decimal

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

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

Solution (Python):
a, b = input().split()
a = int(a)
bl, br = b.split('.')
b = int(bl) * 100 + int(br)

print((a * b) // 100)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd, floor
from itertools import permutations, combinations, product, accumulate, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from decimal import *

def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True

t = input().split()
a, b = int(t[0]), Decimal(t[1])
bb = floor(b)
bbb = (b - bb)
ans = a * bb + int(a * bbb)
print(ans)

Solution (Python):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

A, B = read().split()

A = int(A)
B = int(float(B) * 100 + .5)

A *= B
print(A // 100)