CodeEff/ECCO huggingface dataset:
# Original solution
import sys
readline = sys.stdin.readline
from collections import deque
from math import isinf
INF = float("inf")
sys.setrecursionlimit(200000)
n = int(readline())
G = [[] for _ in range(n)]
D = [INF] * n
for _ in [0] * (n - 1):
    s, t, w = list(map(int, readline().split()))
    G[s].append([t, w])
    G[t].append([s, w])
def bfs(s, D):
    dq = deque([s])
    D = [INF] * n
    D[s] = 0
    while dq:
        u = dq.popleft()
        for i in range(len(G[u])):
            e = G[u][i]
            if isinf(D[e[0]]):
                D[e[0]] = D[u] + e[1]
                dq.append(e[0])
    return D
D = bfs(0, D)
maxv = 0
tgt = 0
for i in range(n):
    if isinf(D[i]): continue
    if maxv < D[i]:
        maxv = D[i]
        tgt = i
D = bfs(tgt, D)
print((max(D[i] for i in range(n) if not isinf(D[i]))))

# Optimized solution
import sys
readline = sys.stdin.readline
def dfs(root):
    visited = [False] * n
    queue = [(0, root)]
    longest = (-1, -1)
    while queue:
        total_weight, node = queue.pop()
        if visited[node]:
            continue
        visited[node] = True
        longest = max(longest, (total_weight, node))
        for w, t in edges[node]:
            if not visited[t]:
                queue.append((total_weight + w, t))
    return longest
n = int(readline())
edges = [set() for _ in range(n)]
for _ in range(n - 1):
    s, t, w = list(map(int, readline().split()))
    edges[s].add((w, t))
    edges[t].add((w, s))
_, ln = dfs(0)
ld, _ = dfs(ln)
print(ld)
# Original solution
# -*- coding: utf-8 -*-

from collections import deque


if __name__ == '__main__':

    n = int(eval(input()))
    A = [[float("inf") for j in range(n)] for i in range(n)]

    for i in range(n - 1):
        A[i][i] = 0
        s, t, d = list(map(int, input().split()))
        A[s][t] = d
        A[t][s] = d

    Q = deque()

    def bfs(s):
        d = [float("inf")] * n
        Q.append(s)
        d[s] = 0
        while Q:
            u = Q.popleft()
            for v in range(n):
                if d[v] == float("inf"):
                    d[v] = d[u] + A[u][v]
                    Q.append(v)

        return d

    d = bfs(0)
    tgt = d.index(max(d))
    d = bfs(tgt)
    print((max(d)))



# Optimized solution
# -*- coding: utf-8 -*-

from collections import deque


if __name__ == '__main__':

    n = int(eval(input()))
    E = [set() for _ in range(n)]
    for _ in range(n - 1):
        s, t, d = list(map(int, input().split()))
        E[s].add((t, d))
        E[t].add((s, d))

    Q = deque()

    def bfs(s):
        d = [float("inf")] * n
        Q.append(s)
        d[s] = 0
        while Q:
            u = Q.popleft()
            for v, w in E[u]:
                if d[v] == float("inf"):
                    d[v] = d[u] + w
                    Q.append(v)

        return d

    d = bfs(0)
    tgt = d.index(max(d))
    d = bfs(tgt)
    print((max(d)))
# Original solution
while True:
    a=[int(num)for num in input().split(' ')]
    n=a[0]
    if n==0:break
    hanafuda=[i+1 for i in range(n)]
    for i in range(a[1]):
        b=[int(num)for num in input().split(' ')]
        for j in range(b[1]):hanafuda.append(hanafuda.pop(n-(b[0]+b[1])+1))
    print((hanafuda.pop()))

# Optimized solution
while True:
    n,r=[int(s)for s in input().split(" ")]
    if n==r==0:break
    ops=[[int(s)for s in input().split(" ")]for i in range(r)]
    cd=[n-i for i in range(n)]
    for op in ops:
        p,c=op
        l=cd[p-1:p+c-1]
        del cd[p-1:p+c-1]
        cd=l+cd
    print((cd[0]))
# Original solution
cond = [int(n) for n in input().split(" ")]

while True:
    case = []
    cards = [n for n in range(1,cond[0] + 1)]
    cards.sort(reverse = True)
    for c in range(cond[1]):
        case = [int(n) for n in input().split(" ")]
        case[0] -= 1
        #print(cards[case[0]:case[0]+case[1]],cards[case[1]:case[0]+case[1]],cards[:case[1]],cards[:case[1]])
        disp = cards[case[0]:case[0]+case[1]]
        cards[case[1]:case[0]+case[1]] = cards[0:case[0]]
        cards[0:case[1]] = disp
    else:
        print((cards[0]))
        cond = [int(n) for n in input().split(" ")]
        if cond[0] == 0 and cond[1] == 0:
            break
        else:
            continue

# Optimized solution
cards,trial = (int(n) for n in input().split(" "))
while True:
    cards = list(reversed([int(n) for n in range(1,(cards)+1)]))
    for n in range(trial):
        num,change = (int(n) for n in input().split(" "))
        num -= 1
        disp = cards[num:num+change]
        cards[change:change+num] = cards[:num]
        cards[:change] = disp
    print((cards[0]))
    cards,trial = (int(n) for n in input().split(" "))
    if cards == 0 and trial == 0:
        break
# Original solution
import sys
from collections import Counter
from collections import deque
import heapq
import math
import fractions
import bisect
import itertools
def input(): return sys.stdin.readline().strip()
def mp(): return list(map(int,input().split()))
def lmp(): return list(map(int,input().split()))

a,b=mp()
print((a*b))

# Optimized solution
a,b=list(map(int,input().split()))
print((a*b))
# Original solution
num = [int(i) for i in input().split() ]
print((num[0] * num[1]))

# Optimized solution
A,B = [int(i) for i in input().split()]
print((A*B))
# Original solution
a,b = list(map(int, input().split()))
ans = a * b
print(ans)

# Optimized solution
import math
a,b = input().split()
a = int(a)
b = float(b)
print((int(math.floor(a * b))))
# Original solution
s = list(map(int, input().split()))
print((s[0]*s[1]))

# Optimized solution
s = list(map(int, input().split()))
S = list(s)
print((S[0]*S[1]))
# Original solution
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    a,b=list(map(int, input().split()))
    print((a*b))
resolve()

# Optimized solution
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    a,b=list(map(float, input().split()))
    b100=b*100
    print((int(a*b100/100)))
resolve()
# Original solution
def iput(): return int(eval(input()))
def mput(): return list(map(int, input().split()))
def lput(): return list(map(int, input().split()))

def solve():
    a, b = mput()
    print((a*b))
    return 0

if __name__ == "__main__":
    solve()

# Optimized solution
import math
def solve():
    a, b = input().split()
    a = int(a)
    b = float(b)
    print((int(a*b)))
    return 0
 
if __name__ == "__main__":
    solve()
# Original solution
# 169A
# 値 A × B を整数として出力せよ。

# １．標準入力をプログラムで扱えるように受け取る
a, b = list(map(int, input().split()))
# print(a, b)

# ２．受け取った入力値を使って、適切に処理（計算）する
answer = a * b

# ３．計算結果を出力する
print(answer)


# Optimized solution
# A × B を求めてください。

# 制約
# 1 ≤ A ≤ 100
# 1 ≤ B ≤ 100
# 入力は全て整数である。

# 標準入力からA、Bを取得する
a, b = list(map(int, input().split()))

# A x B を計算し、出力する
result = a * b

print(result)
# Original solution
A, B = list(map(int, input().split()))
C  = A * B
print(C)


# Optimized solution
A, B = input().split()
A = int(A)
B = float(B)
B = int(B * 1000)
C = A * B
C //= 1000
print(C)
# Original solution
a,b=list(map(int,input().split()))
print((a*b))

# Optimized solution
def resolve():
	a,b=list(map(int,input().split()))
	print((a*b))
resolve()
# Original solution
# 169a
# A×Bを整数として出力せよ。

# 1. 入力をプログラムで扱えるように受け取ること
a, b = list(map(int, input().split()))
# print(a, b)


# 2. 受け取った入力値を使って、適切に処理（計算）すること
answer = a * b


# 3. 計算した結果を出力すること
print(answer)

# Optimized solution
A, B = list(map(int, input().split()))

answer = A * B

print(answer)
# Original solution
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
# pi=math.pi
# print(pi)
# yes()
# no()
# n=int(input())

# s=input()

a,b=LI()
print(a*b)


# Optimized solution
print((eval(input().replace(" ","*"))))
# Original solution
lis = list(map(int,input().split(" ")))
print((lis[0] * lis[1]))


# Optimized solution
N,M = list(map(int,input().split()))
print((N*M))
# Original solution
a, b = list(map(int, input().split()))
print((a*b))

# Optimized solution
#!/usr/bin/env python3
import sys


def solve(A: int, B: int):
    print((A*B))
    return


# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    solve(A, B)

if __name__ == '__main__':
    main()
# Original solution
# -*- coding: utf-8 -*-
"""
Created on Sun May 31 20:59:05 2020

@author: NEC-PCuser
"""

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

print((A * B))

# Optimized solution
A, B = list(map(int, input().split()))

print((str(A * B)))
# Original solution
#169A
#A*Bを整数として出力せよ。
#1．入力を受け取ること
a,b=list(map(int,input().split()))
# print(a, b)

#2．受け取った入力値を使って、適切に処理すること
answer=a*b

#3．計算した結果を出力すること
print(answer)






# Optimized solution
a, b = list(map(int, input().split()))

print((a*b))
# Original solution
A, B = list(map(int, input().split()))

print((A*B))

# Optimized solution
A, B = list(map(float, (input().split())))
print((round(A*B)))
# Original solution
A,B = list(map(int,input().split(" ")))
print((A*B))

# Optimized solution
if __name__ == "__main__":
    A,B = list(map(float,input().split(" ")))
    print((int((int(A)*(int((B)*100)))/100)))
# Original solution
A,B = list(map(int,input().split()))
print((A * B))

# Optimized solution
A,B = list(map(float,input().split()))
A = int(A)
print((int(A * B)))
# Original solution
# 169A
# A × B を整数として出力せよ

# 1.入力をプログラムで扱えるように受け取ること
a, b = list(map(int, input().split()))
# print(a, b)

# 2.受け取った入力値を使って、適切に処理(計算)すること
answer = a * b;

# 3.計算した結果を出力すること
print(answer)

# Optimized solution
a, b = list(map(int, input().split()))

print((a * b))
# Original solution
#169A
#A*Bを整数として出力せよ
#1.入力をプログラムで扱えるように受け取ること
a,b = list(map(int, input().split()))
#2.受け取った入力値を使って適切に処理（計算）すること
print((a * b))

# Optimized solution
#aとbをスペースを空けて入力
a,b = list(map(int,input().split()))
print((a*b))
# Original solution
#!/usr/bin/env python3
# from typing import *
import sys
import math
input = sys.stdin.readline
sys.setrecursionlimit(10**6)


def solve(A, B):
    print((A*B))


def main():
    A, B = list(map(int, input().split()))
    solve(A, B)

if __name__ == '__main__':
    main()
'''
cd ~/Desktop/Programming/AtCoder/contest/abc169/abc169_a && sh test_py.sh
cd ~/Desktop/Programming/AtCoder/contest/abc169/abc169_a && sh etest_py.sh
cd ~/Desktop/Programming/AtCoder/contest/abc169/abc169_a && sh submit_py.sh
'''


# Optimized solution
#!/usr/bin/env python3
# from typing import *
import sys
import math
input = sys.stdin.readline
sys.setrecursionlimit(10**6)


def solve(A, B):
    print((A*B))
    




def main():
    A, B = list(map(int, input().split()))
    solve(A, B)

if __name__ == '__main__':
    main()


'''
cd ~/Desktop/Programming/AtCoder/contest/abc169/abc169_a && sh shellscripts/test_py.sh
cd ~/Desktop/Programming/AtCoder/contest/abc169/abc169_a && sh shellscripts/etest_py.sh
cd ~/Desktop/Programming/AtCoder/contest/abc169/abc169_a && sh shellscripts/submit_py.sh
'''
# Original solution
# 169A
# A × B を整数として出力せよ

# 1. 入力をプログラムで扱えるように受け取ること
a, b = list(map(int, input().split()))
# print(a, b)

# 2. 受け取った入力値を使って、適切に処理(計算)すること
answer = a * b

# 3. 計算した結果を出力すること
print(answer)



# Optimized solution
a, b = list(map(int, input().split()))

answer = a * b

print(answer)
# Original solution
A,B = list(map(int, input().split()))
print((A*B))

# Optimized solution
A,B = input().split()
import math
A=int(A)
B=float(B)
print((math.floor(A*B)))
# Original solution
# Problem A - Multiplication 1

# input
a, b = list(map(int, input().split()))

# output
print((a * b))


# Optimized solution
# Problem a - Multiplication 1

# input
A, B = list(map(int, input().split()))

# initialization
ans = A * B

# output
print(ans)
# Original solution
a,b = list(map(int,input().split()))
c = a*b
print(c)

# Optimized solution
a,b = list(map(float,input().split()))
A = int(a)
B = 100*b
c = int(A*B//100)

print(c)
# Original solution
#169A
#A×Bを整数として出力せよ。

#やること①入力を受け取ること
a, b = list(map(int, input().split()))
# print(a, b)

#やること②受け取った値を使って、適切に処理する
answer = a * b

#やること③計算した結果を出力すること
print(answer)

# Optimized solution
A, B = list(map(int, input().split()))
print((A * B))
# Original solution
# 入力をプログラムで扱えるように受け取ること
a, b = list(map(int, input().split()))
# print(a, b)

# 受け取った入力値を使い、適切に処理（計算）する
anser = a * b

# 計算した結果を出力する
print(anser)

# Optimized solution
a, b = list(map(int, input().split()))
anser = a * b
print(anser)
# Original solution
a, b = list(map(int, input().split()))
anser = a * b
print(anser)

# Optimized solution
# 入力をプログラムで扱えるように受け取ること
a, b = list(map(int, input().split()))
# print(a, b)
 
# 受け取った入力値を使い、適切に処理（計算）する
answer = a * b
 
# 計算した結果を出力する
print(answer)
# Original solution
# 169A
# A × B を整数として出力せよ。

# 1. 入力をプログラムで扱えるように受け取ること
a, b = list(map(int, input().split()))
# print(a, b)

# 2. 受け取った入力値を使って、適切に処理(計算)すること
answer = a * b

# 3. 計算した結果を出力すること
print(answer)



# Optimized solution
# 入力
a, b = list(map(int, input().split()))

# 計算
answer = a * b

# 出力
print(answer)
# Original solution
A, B = list(map(int, input().split()))
print((A * B))

# Optimized solution
print((eval(input().replace(" ","*"))))
# Original solution
a, b = list(map(int, input().split()))
answer = a * b
print(answer)

# Optimized solution
A, B = list(map(int,input().split()))

print((A * B))
# Original solution
from sys import stdin

def main():
  read = stdin.readline
  A, B = list(map(int,read().split(" ")))
  print((A*B))
  
  
if __name__ == "__main__":
  main()

# Optimized solution
from sys import stdin

def main():
  read = stdin.readline
  A,B = list(read().split(" "))
  B = int(B)*100
  c = int(A) * B
  print((c//100))
  
  
  
if __name__ == "__main__":
  main()
# Original solution
# 169A
# A × B を整数として出力せよ

# 1. 入力をプログラミングで扱えるように受け取ること
a, b = list(map(int, input().split()))
# print(a, b)

# 2. 受け取った入力値を使って、適切に処理（計算）すること
answer = a * b

# 3.計算した結果を出力すること
print(answer)

# Optimized solution
# 169A
# A × Bを求めてください。

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

answer = A * B
print(answer)
# Original solution
a, b = list(map(int, input().split()))

answer = a * b

print(answer)

# Optimized solution
# A-Multiplication 1
# A×Bを求める
# 1≤A≤100
# 1≤B≤100

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

answer = a * b

print(answer)
# Original solution
N, M = list(map(int, input().split()))
print((N*M))

# Optimized solution
a,b = list(map(float,input().split()))
a = int(a)
b = int(b*1000)
print((int(a*b)//1000))
# Original solution
a, b = list(map(int, input().split()))

answer = a * b

print(answer)

# Optimized solution
a, b = list(map (int, input().split()))

print((a * b))
# Original solution
#169A

a, b = list(map(int, input().split()))
# print(a)
# print(b)

answer=a*b

print(answer)


# Optimized solution
A,B=input().split()
A=int(A)
B=int(B)
print((A*B))
# Original solution
a,b=list(map(int,input().split()))
print((a*b))

# Optimized solution
a,b=input().split()
a=int(a)
b=int(float(b)*100)
print((int(a*b/100)))
# Original solution
a, b = list(map(int, input().split()))

answer = a * b

print(answer)


# Optimized solution
a,b = list(map(int,input().split()))

print((a * b))
# Original solution
import math
from collections import deque
from collections import defaultdict

import time

#自作関数群
def readInt():
	return int(eval(input()))
def readInts():
	return list(map(int, input().split()))
def readChar():
	return eval(input())
def readChars():
	return input().split()
def factorization(n):
	res = []
	if n%2==0:
		res.append(2)
	for i in range(3,math.floor(n//2)+1,2):
		if n%i==0:
			c = 0
			for j in res:
				if i%j==0:
					c=1
			if c==0:
				res.append(i)
	return res
def fact2(n):
	p = factorization(n)
	res = []
	for i in p:
		c=0
		z=n
		while 1:
			if z%i==0:
				c+=1
				z/=i
			else:
				break
		res.append([i,c])
	return res
def fact(n):#階乗
	ans = 1
	m=n
	for _i in range(n-1):
		ans*=m
		m-=1
	return ans
def comb(n,r):#コンビネーション
	if n<r:
		return 0
	l = min(r,n-r)
	m=n
	u=1
	for _i in range(l):
		u*=m
		m-=1
	return u//fact(l)
def combmod(n,r,mod):
	return (fact(n)/fact(n-r)*pow(fact(r),mod-2,mod))%mod
def printQueue(q):
	r=copyQueue(q)
	ans=[0]*r.qsize()
	for i in range(r.qsize()-1,-1,-1):
		ans[i] = r.get()
	print(ans)
class UnionFind():
	def __init__(self, n):
		self.n = n
		self.parents = [-1]*n

	def find(self, x): # root
		if self.parents[x]<0:
			return x
		else:
			self.parents[x] = self.find(self.parents[x])
			return self.parents[x]

	def union(self,x,y):
		x = self.find(x)
		y = self.find(y)

		if x==y:
			return

		if self.parents[x]>self.parents[y]:
			x,y = y,x

		self.parents[x]+=self.parents[y]
		self.parents[y]=x

	def size(self,x):
		return -1*self.parents[self.find(x)]

	def same(self,x,y):
		return self.find(x)==self.find(y)

	def members(self,x): # much time
		root = self.find(x)
		return [i for i in range(self.n) if self.find(i)==root]

	def roots(self):
		return [i for i,x in enumerate(self.parents) if x<0]

	def group_count(self):
		return len(self.roots())

	def all_group_members(self):
		return {r: self.members(r) for r in self.roots()} # 1~n
def bitArr(n):#ビット全探索
	x = 1
	zero = "0"*n
	ans = []
	ans.append([0]*n)
	for i in range(2**n-1):
		ans.append(list([int(x) for x in list((zero+bin(x)[2:])[-1*n:])]))
		x+=1
	return ans;
def arrsSum(a1,a2):
	for i in range(len(a1)):
		a1[i]+=a2[i]
	return a1
def maxValue(a,b,v):
	v2 = v
	for i in range(v2,-1,-1):
		for j in range(v2//a+1): #j:aの個数
			k = i-a*j
			if k%b==0:
				return i
	return -1
def copyQueue(q):
	nq = queue.Queue()
	n = q.qsize()
	for i in range(n):
		x = q.get()
		q.put(x)
		nq.put(x)
	return nq

a,b = readInts()

print((a*b))

# Optimized solution
a,b = list(map(int, input().split()))

print((a*b))
# Original solution
import math
from collections import deque
from collections import defaultdict
import itertools as it

#自作関数群
def readInt():
  return int(eval(input()))
def readInts():
  return list(map(int, input().split()))
def readChar():
  return eval(input())
def readChars():
  return input().split()
def factorization(n):
  res = []
  if n%2==0:
    res.append(2)
  for i in range(3,math.floor(n//2)+1,2):
    if n%i==0:
      c = 0
      for j in res:
        if i%j==0:
          c=1
      if c==0:
        res.append(i)
  if len(res)==0:
    res = [n]
  return res
def fact2(n):
  p = factorization(n)
  res = []
  for i in p:
    c=0
    z=n
    while 1:
      if z%i==0:
        c+=1
        z/=i
      else:
        break
    res.append([i,c])
  return res
def fact(n):#階乗
  ans = 1
  m=n
  for _i in range(n-1):
    ans*=m
    m-=1
  return ans
def comb(n,r):#コンビネーション
  if n<r:
    return 0
  l = min(r,n-r)
  m=n
  u=1
  for _i in range(l):
    u*=m
    m-=1
  return u//fact(l)
def combmod(n,r,mod):
  return (fact(n)/fact(n-r)*pow(fact(r),mod-2,mod))%mod
def printQueue(q):
  r=copyQueue(q)
  ans=[0]*r.qsize()
  for i in range(r.qsize()-1,-1,-1):
    ans[i] = r.get()
  print(ans)
class UnionFind():
  def __init__(self, n):
    self.n = n
    self.parents = [-1]*n

  def find(self, x): # root
    if self.parents[x]<0:
      return x
    else:
      self.parents[x] = self.find(self.parents[x])
      return self.parents[x]

  def union(self,x,y):
    x = self.find(x)
    y = self.find(y)

    if x==y:
      return

    if self.parents[x]>self.parents[y]:
      x,y = y,x

    self.parents[x]+=self.parents[y]
    self.parents[y]=x

  def size(self,x):
    return -1*self.parents[self.find(x)]

  def same(self,x,y):
    return self.find(x)==self.find(y)

  def members(self,x): # much time
    root = self.find(x)
    return [i for i in range(self.n) if self.find(i)==root]

  def roots(self):
    return [i for i,x in enumerate(self.parents) if x<0]

  def group_count(self):
    return len(self.roots())

  def all_group_members(self):
    return {r: self.members(r) for r in self.roots()} # 1~n
def bitArr(n):#ビット全探索
  x = 1
  zero = "0"*n
  ans = []
  ans.append([0]*n)
  for i in range(2**n-1):
    ans.append(list([int(x) for x in list((zero+bin(x)[2:])[-1*n:])]))
    x+=1
  return ans;
def arrsSum(a1,a2):
  for i in range(len(a1)):
    a1[i]+=a2[i]
  return a1
def maxValue(a,b,v):
  v2 = v
  for i in range(v2,-1,-1):
    for j in range(v2//a+1): #j:aの個数
      k = i-a*j
      if k%b==0:
        return i
  return -1
def copyQueue(q):
  nq = queue.Queue()
  n = q.qsize()
  for i in range(n):
    x = q.get()
    q.put(x)
    nq.put(x)
  return nq
def get_sieve_of_eratosthenes(n):
  data = [2]
  #data = [0,0,0]
  for i in range(3,n+1,2):
    data.append(i)
    data.append(0)
  for i in range(len(data)):
    interval = data[i]
    if interval!=0:
      for j in range(i+interval,n-1,interval):
        data[j] = 0
  ans = [x for x in data if x!=0]
  #ans = data[:]
  return ans


a,b = readInts()

#print(a+b)
print((a*b))

# Optimized solution

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

#print(a+b)
print((a*b))
# Original solution

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

#print(a+b)
print((a*b))

# Optimized solution
a,b = list(map(int,input().split()))

print((a*b))
# Original solution
"""
~~ Author : Bhaskar
~~ Dated : 31~05~2020
"""

import sys
from bisect import *
from math import floor,sqrt,ceil,factorial as F,gcd,pi
from itertools import chain,combinations,permutations,accumulate
from collections import Counter,defaultdict,OrderedDict,deque
from array import array
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize)-1
mod = 1000000007
lcm = lambda a,b : (a*b)//gcd(a,b)
setbit = lambda x : bin(x)[2:].count("1")

def solve():
    a,b = list(map(int,sys.stdin.readline().split()))
    print((a*b))

if __name__ == "__main__":
    solve()


# Optimized solution
"""
~~ Author : Bhaskar
~~ Dated : 13~06~2020
"""

import sys
from bisect import *
from math import floor, sqrt, ceil, factorial as F, gcd, pi
from itertools import chain, combinations, permutations, accumulate
from collections import Counter, defaultdict, OrderedDict, deque

INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize) - 1
mod = 1000000007
ch = "abcdefghijklmnopqrstuvwxyz"
lcm = lambda a, b: (a * b) // gcd(a, b)
setbit = lambda x: bin(x)[2:].count("1")
INT = lambda type: type(sys.stdin.readline()) if type in [int, float] else type(sys.stdin.readline()).replace("\n", "")
ARRAY = lambda type: list(map(type, sys.stdin.readline().split()))
NUMS = lambda type: list(map(type, sys.stdin.readline().split()))


def solve():

    a,b = NUMS(int)
    print((a*b))
    


if __name__ == "__main__":
    try:
        sys.stdin = open("input.txt", "r")
    except:
        pass
    solve()
# Original solution
A, B = list(map(int, input().split()))
print((A * B))

# Optimized solution
import math
A, B = list(map(float, input().split()))
B *= 100
mul = math.floor(A * B)
print((int(mul/100)))
# Original solution
# 1．入力を受け取ること
# スペース区切りの入力を整数として受け取れる「2 5」　->　「a=2, B=5」となる
a, b = list(map(int, input().split()))

# print(a)
# print(b)

# 2.受け取った結果を使って目的の計算をすること

answer = a * b

# 3.出力すること
print(answer)

# Optimized solution
A, B = list(map(int,input().split()))

print((A * B))
# Original solution
a, b = list(map(int, input().split()))
print((a * b))

# Optimized solution
a, b = list(map(str, input().split()))
A = int(a)
B = round(float(b) * 100)
print((A * B // 100))
# Original solution
def resolve():
    A, B = list(map(int, input().split()))
    print((A*B))
resolve()

# Optimized solution
A, B = list(map(int, input().split()))
print((A*B))
# Original solution
import sys
input = sys.stdin.readline

a, b = [int(x) for x in input().split()]
print((a*b))

# Optimized solution
import sys
input = lambda: sys.stdin.readline().rstrip()


a, b = list(map(int, input().split()))
print((a*b))
# Original solution
A, B = list(map(int, input().split()))

print((A*B))

# Optimized solution
A, B = list(map(float, input().split()))
mod = 10000
a = int(A // mod)
a2 = int(A % mod)
B = int(100 * B)
ans = a * B * mod + a2 * B 
print((ans // 100))
# Original solution
A,B = list(map(int,input().split()))
print((A*B))

# Optimized solution
A,B = list(map(float,input().split()))

tmp = A*B*100
print((int(tmp/100)))