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
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))



def read_a_int(): return int(read())


def read_ints(): return list(map(int, read().split()))


def read_col(H):
    '''H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_tuple(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_matrix(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  
from decimal import Decimal
A, B = input().split()
A = Decimal(int(A))
B = Decimal(B)
print(int(A * B))

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

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

print(int(ans))

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

Solution (Python):
from decimal import Decimal
import math
'''
a=10**15
b=9.99
'''
a,b=map(Decimal,input().split())

num=a*b


num=math.floor(num)
print(num)

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

a = int(a)
b = int(b.replace('.', ''))

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

Solution (Python):


import sys
import math
from collections import Counter
import itertools
import fractions
from decimal import *




def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())

def LI(): return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")


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

print(math.floor(da*db))

Solution (Python):
import sys, random, math
from bisect import bisect_left, bisect_right
input = sys.stdin.readline

def main():
    inf = 10 ** 20



    t = 1
    
    for _ in range(1, t+1):
    
        
        aa, bb = input().split()
        a, b = -1, -1
        for i in range(len(aa)):
            if(aa[i] == '.'):
                a = int(aa[:i]) * 100
                if(i == len(aa)-2):
                    a += int(aa[-1]) * 10
                else:
                    a += int(aa[-2:])
        if(a == -1):
            a = int(aa) * 100
        for i in range(len(bb)):
            if(bb[i] == '.'):
                b = int(bb[:i]) * 100
                if(i == len(bb)-2):
                    b += int(bb[-1]) * 10
                else:
                    b += int(bb[-2:])
        if(b == -1):
            b = int(bb) * 100
    
            
    
        
        print((a*b//10000))
        
main()

Solution (Python):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))

from collections import defaultdict, deque
from sys import exit
import math
import copy
from bisect import bisect_left, bisect_right
from heapq import *
import sys

INF = 10 ** 17
MOD = 1000000007

from fractions import *
def inverse(f):
    
    return 1/f


def combmod(n, k, mod=MOD):
    ret = 1
    for i in range(n - k + 1, n + 1):
        ret *= i
        ret %= mod

    for i in range(1, k + 1):
        ret *= pow(i, mod - 2, mod)
        ret %= mod

    return ret
def bunsu(n):
    ret = []
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            tmp = 0
            while(True):
                if n % i == 0:
                    tmp += 1
                    n //= i
                else:
                    break
            ret.append((i, tmp))

    ret.append((n, 1))
    return ret

def solve():
    a, b = input().split()
    a = int(a)
    b = int(b[:-3]) * 100 + int(b[-2:])
    ans = (a * b) // 100
    print(ans)
    
def main():
    
    
    solve()
if __name__ == "__main__":
    solve()

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

print(int(A*B))

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

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

Solution (Python):
from decimal import Decimal

a,b = input().split()

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

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

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

Solution (Python):
from decimal import Decimal

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

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

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

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

print(A*B//100)

Solution (Python):
a,b=input().split()
a=int(a)
b=int(float(b)*pow(10,len(str(a))))
print(a*b//pow(10,len(str(a))))

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

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

Solution (Python):
A, B = input().split()
A = int(A)
B = int(B[0]+B[2:])
C = A*B
D = str(C)[:-2]
if D == "":
    D = 0
else:
    D = int(D)
print(D)

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

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

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

Solution (Python):

import decimal

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

print(int(ans))

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)
b=int(b[:-3]+b[-2:])

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

Solution (Python):
import math

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

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

print((a*b)//100)

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

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

A = int(A)

if '.' in B:
    idx_dot = B.index('.')
    level = len(B) - 1 - idx_dot
    B_int = ''
    for Bi in list(B):
        if Bi != '.': B_int += Bi
    B_int = int(B_int)
    
    ans = (A * B_int) // (10 ** level)
else:
    B = int(B)
    ans = A * B

print(ans)

Solution (Python):
from decimal import Decimal

a, b = [Decimal(x) for x in input().split()]

p = a * b

print(int(p))

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

print(a*b//100)

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

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

from decimal import *
getcontext().prec = 100
a=Decimal(a)
b=Decimal(b)
print(int(a*b))

Solution (Python):
import decimal

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

Solution (Python):
from fractions import Fraction
a, b = map(Fraction, input().split())

print(int(a*b))

Solution (Python):
A,B=input().split()
A=int(A)
Bi=int(B[:len(B)-3])
Bf=int(B[len(B)-2:])
res=(100*Bi+Bf)*A//100
print(res)

Solution (Python):
A, B = [s for s in input().split()]
A = int(A)
intB, decimalB = B.split(".")
result = A * int(intB) +  A * int(decimalB) // 100
print(result)

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

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

Solution (Python):
from decimal import Decimal

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

Solution (Python):


import math
import re
import numpy as np

S = input().split(" ")
A = int(S[0])
B = int(S[1][0]) * 100 + int(S[1][2]) * 10 + int(S[1][3])

ans = (A * B) // 100

print(ans)

Solution (Python):


iim = lambda: map(int, input().rstrip().split())
from decimal import Decimal

def resolve():
    a, b = input().split()
    a = int(a); b = Decimal(b)

    print(int(a*b))

if __name__ == "__main__":
    resolve()

Solution (Python):
import math
from decimal import *

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

Solution (Python):
from decimal import Decimal

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

Solution (Python):
from decimal import *
import math
inputs = input().strip().split()
A = Decimal(inputs[0])
B = Decimal(inputs[1])

ans = A * B

print(math.floor(ans))

Solution (Python):
import bisect
import copy
import heapq
import math
import sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
sys.setrecursionlimit(500000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

a,b=input().split()
b=b[0]+b[2:]

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




print(a*b//100)

Solution (Python):
from sys import stdin, stdout

int_in = lambda: int(stdin.readline())
arr_in = lambda: [int(x) for x in stdin.readline().split()]
mat_in = lambda rows: [arr_in() for y in range(rows)]
str_in = lambda: stdin.readline().strip()
out = lambda o: stdout.write("{}\n".format(o))
arr_out = lambda o: out(" ".join(map(str, o)))
bool_out = lambda o: out("YES" if o else "NO")
tests = lambda: range(1, int_in() + 1)
case_out = lambda i, o: out("Case 


if __name__ == "__main__":
    parts = str_in().split()
    a = int(parts[0])
    b = int(parts[1].replace(".", ""))
    out((a*b)//100)

Solution (Python):
from decimal import *

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

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

Solution (Python):
def main():
    a, b = map(str, input().split())
    a = int(a)
    x = int(b[0])
    y = int(b[2])
    z = int(b[3])
    ans = a*x*100 + a*y*10 + a*z
    print(ans//100)

if __name__ == "__main__":
    main()

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):
from decimal import Decimal
a,b=input().split()
a=Decimal(a)
b=Decimal(b)


print(int(a*b))

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

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
import math
setrecursionlimit(10 ** 7)

a,b = input().split()

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

print(a*b//100)

Solution (Python):
import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


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

    print(A * (B * 100 + C) // 100)


if __name__ == "__main__":
    main()

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


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


if __name__ == '__main__':
    main()

Solution (Python):
a, b = map(str, input().split())
a = int(a)
q, r = map(int, b.split('.'))

d = (a*r)//100
ans = a*q + d
print(ans)

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

Solution (Python):
A, B = input().split()
a = int(A)
if '.' in B:
    b, c = B.split('.')
    p = len(c)
    b = int(b) * 10 ** p + int(c)
else:
    b = int(B)
    p = 0

print(a * b // 10 ** p)

Solution (Python):
import decimal

A, B = map(decimal.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):
a,b = map(str,input().split())

import math
from decimal import *
a = Decimal(a)
b = Decimal(b)

print(math.floor(a * b))

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

a = int(a)

k, s = b.split('.')
b100 = int(k) * 100 + int(s)

answer = (a * b100) // 100

print(answer)

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

Solution (Python):
import math
from decimal import Decimal

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

print(math.floor(A * B))

Solution (Python):
from decimal import Decimal

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

Solution (Python):
from collections import deque
import sys

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

li = list(input().split())
A = int(li[0])
a, b, c = int(li[1][0]), int(li[1][2]), int(li[1][3])

ans = 100 * A * a + 10 * A * b + A * c
ans //= 100
print(ans)

Solution (Python):

import sys
import math
from bisect import bisect_left, bisect_right, insort_left, insort_right
from collections import defaultdict, deque, Counter
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import accumulate, groupby, product, permutations, combinations, combinations_with_replacement
from math import ceil, floor, factorial, log, sqrt, sin, cos
from operator import itemgetter
from string import ascii_lowercase, ascii_uppercase, digits
sys.setrecursionlimit(10**6)
INF = float('inf')
MOD = 10 ** 9 + 7
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rf(): return float(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]
def rf_(): return [float(_) for _ in rs().split()]
def divisors(n, sortedresult=True):
    div = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            div.append(i)
            if i != n // i:
                div.append(n//i)
    if sortedresult:
        div.sort()
    return div

from decimal import Decimal
A, B = rs_()
ans = int(Decimal(A) * Decimal(B))
print(ans)

Solution (Python):
from decimal import Decimal

def main():
    A, B = [Decimal(x) for x in input().split()]
    print(int(A * B))

if __name__ == "__main__":
    main()

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

Solution (Python):
import sys


import math
import collections

import bisect
import itertools
import fractions

import copy
import heapq
import decimal

import queue

sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7

ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))





def main():
    a, b = input().split()
    a = int(a)
    b = int((float(b) + 0.005) * 100)

    ans = (a * b) // 100

    print(ans)


if __name__ == '__main__':
    main()

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

print(int(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()
A = int(A)
B = int(("1"+B.replace(".","")+"000")[:4])
if A == 0:
  print(0)
elif B == 1000:
  print(0)
else:
  print((A*B-1000*A)//100)

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from decimal import Decimal 
from math import floor
def main():
    a, b = map(Decimal, input().split())
    ans = a*b
    print(floor(ans))
if __name__ == '__main__':
    main()

Solution (Python):
import sys
from decimal import Decimal

input = sys.stdin.readline


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

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


if __name__ == "__main__":
    main()

Solution (Python):
import sys
sys.setrecursionlimit(700000)

def s_in():
    return input()

def n_in():
    return int(input())

def l_in():
    return list(map(int, input().split()))
a,b=input().split()

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

print(a*b//100)

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

print(A*B + (C*A)//100)

Solution (Python):
import decimal
a,b = input().split()
A = int(a)
B = decimal.Decimal(b)
c = (A*B).quantize(decimal.Decimal('1'), rounding=decimal.ROUND_FLOOR)
print(c)

Solution (Python):
import decimal
a,b = input().split()
c = decimal.Decimal(a)
d = decimal.Decimal(b)


print(int(c*d))

Solution (Python):



A, B = input().split()


def main():
    a = int(A)
    b = int(B.split(".")[0]) * 100 + int(B.split(".")[1])
    ans = a * b // 100
    print(ans)


if __name__ == "__main__":
    main()

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

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


a = int(a)
b = int(b[0]) * 100 + int(b[2:4])

print((a * b)//100)

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

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

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
import re

s = input()
group = re.search(r"(\d+) (\d).(\d)(\d)", s).groups()
A, B, C, D = [int(x) for x in group]

print((A*B*100 + A*C*10 + A*D) // 100)

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

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

Solution (Python):
from decimal import Decimal

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

ans = int(a * b)

print(ans)

Solution (Python):
import sys
import math
from collections import deque
from decimal import Decimal

sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(float, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()


def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]



def make_adjlist_d(n, edges):
    res = [[] for _ in range(n + 1)]
    for edge in edges:
        res[edge[0]].append(edge[1])
        res[edge[1]].append(edge[0])
    return res


def make_adjlist_nond(n, edges):
    res = [[] for _ in range(n + 1)]
    for edge in edges:
        res[edge[0]].append(edge[1])
    return res



def cmb(n, r):
    return math.factorial(n) // math.factorial(r) // math.factorial(n - r)


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


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    a, b = input().split()
    a = int(a)
    b = int(b.replace(".", ""))
    ret = str(a * b)
    if len(ret) < 2:
        print(0)
    else:
        print(ret[:-2])

if __name__=="__main__":
    main()

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

Solution (Python):
from math import floor
a, b = input().split()
a = int(a)
b1, b2 = map(int, b.split("."))
print(a*(b1*100+b2)//100)

Solution (Python):
from math import floor
from decimal import Decimal, getcontext, ROUND_FLOOR
getcontext().prec = 50
A, B = map(Decimal, input().split())
print(int((A*B).quantize(Decimal("0.0000000000000001"), ROUND_FLOOR)))

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



print( A*B//100 )

Solution (Python):




def input_int():
    return int(input())



def int1(x):
    return int(x) - 1



def input_to_int_map():
    return map(int, input().split())



def input_to_int_tuple():
    return tuple(map(int, input().split()))



def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


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

    from decimal import Decimal

    import math
    return math.floor(Decimal(a) * Decimal(b))

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

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

A,B=input().split()
A=int(A)
B,C=map(int,B.split("."))

B=B*100+C
print(A*B//100)

Solution (Python):






"""Module docstring
"""

import decimal
import functools
import heapq
import itertools
import logging
import math
import os
import random
import string
import sys
from argparse import ArgumentParser
from collections import defaultdict, deque
from copy import deepcopy
from io import BytesIO, IOBase
from typing import Dict, List, Optional, Set, Tuple


def solve(values: List[int], nb: int) -> int:
    for _v in values:
        pass
    return nb


def do_job(stdin, stdout):
    "Do the work"
    LOG.debug("Start working")
    
    a, b = map(decimal.Decimal, stdin.readline().split())
    
    
    
    print(int(a * b), file=stdout)


def print_output(testcase: int, result, stdout) -> None:
    "Formats and print result"
    if result is None:
        result = "IMPOSSIBLE"
    print("Case 
    
    


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 configure_log() -> None:
    "Configure the log output"
    log_formatter = logging.Formatter("L%(lineno)d - " "%(message)s")
    handler = logging.StreamHandler(IOWrapper(sys.stderr))
    handler.setFormatter(log_formatter)
    LOG.addHandler(handler)


LOG = None

if not LOG:
    LOG = logging.getLogger("template")
    configure_log()


def main(argv=None):
    "Program wrapper."
    if argv is None:
        argv = sys.argv[1:]
    parser = ArgumentParser()
    parser.add_argument(
        "-v",
        "--verbose",
        dest="verbose",
        action="store_true",
        default=False,
        help="run as verbose mode",
    )
    args = parser.parse_args(argv)
    if args.verbose:
        LOG.setLevel(logging.DEBUG)
    stdin = IOWrapper(sys.stdin)
    stdout = IOWrapper(sys.stdout)
    do_job(stdin, stdout)
    stdout.flush()
    for h in LOG.handlers:
        h.flush()
    return 0


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

Solution (Python):
import sys
from decimal import Decimal, ROUND_DOWN

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')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7

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

ans = (a*b).quantize(Decimal('1'), rounding=ROUND_DOWN)
print(ans)

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

Solution (Python):
from decimal import Decimal, ROUND_DOWN

A, B = map(Decimal, input().split())
ans = A * B
print(ans.quantize(Decimal('0'), rounding=ROUND_DOWN))

Solution (Python):

"""
@author: H_Hoshigi
"""
def main():
    A_str, B_str = input().split()

    A = int(A_str)
    B100 = int(B_str.replace(".", ""))

    answer = (A*B100)//100
    print(answer)

if __name__ == "__main__":
    main()

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

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

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

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

div = 0
for i in range(15):
    if a % 10**i == 0:
        div = i
    else:
        break

print(int(a // 10**div * (b * 10**div)))

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

Solution (Python):
from decimal import *

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

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


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


def main():

    tA, tB = input().split()
    A = int(tA)
    B = int(tB.replace(".", ""))
    
    ans = A * B // 100

    print(ans)

    return


if __name__ == '__main__':
    main()

Solution (Python):
a,b = input().split()
a = int(a)
b = b.split('.')
if(len(b) == 1):
    print(a*b)
    exit()

ans = 0
ans += a*int(b[0])
ans += a*int(b[1])//100
print(ans)

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

getcontext().prec = 1000

A, B = input().split()
A, B = D(A), D(B)
print(int(A * B // D(1)))