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
input = sys.stdin.readline



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

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

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

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



ans = a * b // 100

print (ans)

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

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

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

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

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

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

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):
A, B = map(float, input().split())
B = int(round(B * 100, 0))
A = int(A)
ans = A * B // 100
print(ans)

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

Solution (Python):
def main():
    A, B = input().split()
    A = int(A)
    B = int(B[:-3] + B[-2:])
    return (A * B)//100
print(main())

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque 


from collections import Counter

from itertools import accumulate

from heapq import heapify,heappop,heappush


from functools import lru_cache


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
    
    import decimal
    
    A,B =  input().split()
    A=decimal.Decimal(A)
    B = decimal.Decimal(B)
    
    
    

    print(math.floor(A*B))




if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

Solution (Python):


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

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




print(a*(b_1+b_2)//100)

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

print(int(a*b))

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

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

print(floor(A * B))

Solution (Python):
from decimal import *

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

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

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

print(a*b//100)

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







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

print(a*b//10000)

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

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

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

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

Solution (Python):
from decimal import Decimal

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

Solution (Python):

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))  
    B = int(next(tokens).replace('.', ''))  
    solve(A, B)


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):

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

Solution (Python):

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

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

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

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

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

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

Solution (Python):
A,B = input().split()
A = int(A)
B = int(''.join([s for s in B if s != '.']))
ans = (A*B)//100
print(ans)

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

Solution (Python):
l = input()
l = l.replace('.', " ")

l = [int(i) for i in l.split()]
a, b, c = l

b = b * 100 + c
a *= b
a //= 100
print(a)

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

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

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

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

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

print((A*B)//100)

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

Solution (Python):
import sys, math,os
from io import BytesIO, IOBase


from collections import defaultdict as dd, deque, Counter

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

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

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

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

Solution (Python):
from decimal import Decimal

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

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())
print(math.floor(Decimal(a)*Decimal(b)))

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

Solution (Python):
from decimal import Decimal

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

print(int(A * B))

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

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

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

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

Solution (Python):
from decimal import *

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

print(int(A * B))

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

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)
bx100 = int(b.replace('.', ''))
print(a * bx100 // 100)

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

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

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

Solution (Python):

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():
    
    
    solve()


if __name__ == "__main__":
    main()

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

Solution (Python):

import sys


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



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 = next(tokens)  
    B = int(B.replace('.', ''))
    print(solve(A, B))

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

if __name__ == '__main__':
    
    main()

Solution (Python):
from decimal import *

def main():

    x,y = input().split()

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

    print(int(x*y))

if __name__ == "__main__":
    main()

Solution (Python):
def main():
    a, b = input().split()
    a = int(a)
    c, d = b.split(".")
    b = int(c)*100+int(d)
    print( a*b//100)
if __name__ == '__main__':
    main()

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

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

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

Solution (Python):

import sys

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

print(a*b//100)

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

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

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

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

Solution (Python):

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

Solution (Python):
from decimal import *

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

print(int(A*B))

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


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