Problem:


Score : 300 points

Problem Statement

Compute A \times B, truncate its fractional part, and print the result as an integer.

Constraints

0 \leq A \leq 10^{15}

0 \leq B < 10

A is an integer.

B is a number with two digits after the decimal point.

Input

Input is given from Standard Input in the following format:

A B

Output

Print the answer as an integer.

Sample Input 1

198 1.10

Sample Output 1

217

We have 198 \times 1.10 = 217.8. After truncating the fractional part, we have the answer: 217.

Sample Input 2

1 0.01

Sample Output 2

0

Sample Input 3

1000000000000000 9.99

Sample Output 3

9990000000000000



Sample input:
198 1.10


Sample output:
217

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal
import math
ab = input().split()
a = int(ab[0])
b = Decimal(ab[1])
print(math.floor(a*b))

Submission status: Accepted

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


print(int(a*b))

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from math import floor
from decimal import Decimal


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a, b = map(str, input().split())
a = int(a)
q, r = map(int, b.split('.'))
#print(q, r)
d = (a*r)//100
ans = a*q + d
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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


print(A * B // 100)

Submission status: Accepted

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

a = int(a)

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

answer = (a * b100) // 100

print(answer)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from decimal import Decimal

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

print(math.floor(A * B))

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
# region header
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
# endregion
from decimal import Decimal
A, B = rs_()
ans = int(Decimal(A) * Decimal(B))
print(ans)

Submission status: Accepted

Solution code:
from decimal import Decimal

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
import heapq
import decimal
# import statistics
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()))


# ===CODE===


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

Submission status: Accepted

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

print(int(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!python3

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

Submission status: Accepted

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

Submission status: Accepted

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


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

print((a * b)//100)

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
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, C, D)
print((A*B*100 + A*C*10 + A*D) // 100)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

ans = int(a * b)

print(ans)

Submission status: Accepted

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


#隣接リスト 1-order
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


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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)))

Submission status: Accepted

Solution code:
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)

print( A*B//100 )

Submission status: Accepted

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


# 入力を整数に変換して受け取る
def input_int():
    return int(input())


# マイナス1した値を返却
def int1(x):
    return int(x) - 1


# 半角スペース区切り入力をIntに変換してMapで受け取る
def input_to_int_map():
    return map(int, input().split())


# 半角スペース区切り入力をIntに変換して受け取る
def input_to_int_tuple():
    return tuple(map(int, input().split()))


# 半角スペース区切り入力をIntに変換してマイナス1した値を受け取る
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())

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# vim: set fileencoding=utf-8

# pylint: disable=unused-import, invalid-name, missing-docstring, bad-continuation


"""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")
    # first line is number of test cases
    a, b = map(decimal.Decimal, stdin.readline().split())
    # values = []
    # for _ in range(N):
    #     values.append(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 #{}: {}".format(testcase + 1, result), file=stdout)
    # 6 digits float precision {:.6f} (6 is the default value)
    # print("Case #{}: {:f}".format(testcase + 1, result), file=stdout)


BUFSIZE = 8192


class FastIO(IOBase):
    # pylint: disable=super-init-not-called, expression-not-assigned
    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):
    # pylint: disable=super-init-not-called
    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
# for interactive call: do not add multiple times the handler
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())

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import Decimal, ROUND_DOWN

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
@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()

Submission status: Accepted

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

Submission status: Accepted

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

a = int(a)
b = int(b.replace(".",""))
print(a*b//100)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from decimal import *

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

Submission status: Accepted

Solution code:
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(".", ""))
    # print(B)
    ans = A * B // 100

    print(ans)

    return


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
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)))

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:

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

print(math.floor(a*b))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)
# else:
#     sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(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()

Submission status: Accepted

Solution code:
import sys
import math
from decimal import *

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

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

Submission status: Accepted

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

print(trunc(a * b))

Submission status: Accepted

Solution code:


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

Submission status: Accepted

Solution code:
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))

Submission status: Accepted

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

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

Submission status: Accepted

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

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

print(a*b//100)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#from collections import deque,defaultdict
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 # and False
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)

Submission status: Accepted

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

Submission status: Accepted

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

A = int(A)
#B = float(B)
B1, B2, B3 = int(B[0]), int(B[2]), int(B[3])
#print(B1, B2, B3)

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

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
import decimal

A, B = input().split()

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

print(int(A * B))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
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()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
import sys
readline = sys.stdin.readline
read = sys.stdin.read

#n,*a = map(int,read().split())
a,b = read().split()
a = int(a)
b = int(b.replace(".",""))

print(a*b//100)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

import decimal

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

Submission status: Accepted

Solution code:
from decimal import Decimal

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

Submission status: Accepted

Solution code:
import math
import decimal

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

print(math.floor(a*b))

Submission status: Accepted

Solution code:
import sys
import re
import random
# import numpy as np
from math import sqrt,log,floor
from fractions import gcd  # python<=3.4
from collections import Counter, defaultdict

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

## INPUT

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

def read_ints():
  # return map(int,raw_input().split())
  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

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




###############
# st = Counter(input())

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

a,b = input().rstrip().split()
#a = int(input().rstrip())
#b = float(input().rstrip())
a=int(a)
b=float(b)


print(solve(a,b))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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


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

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