Takahashi is organizing a party.
At the party, each guest will receive one or more snack pieces.
Takahashi predicts that the number of guests at this party will be A or B.
Find the minimum number of pieces that can be evenly distributed to the guests in both of the cases predicted.
We assume that a piece cannot be divided and distributed to multiple guests.

-----Constraints-----
 - 1 \leq A, B \leq 10^5
 - A \neq B
 - All values in input are integers.

-----Input-----
Input is given from Standard Input in the following format:
A B

-----Output-----
Print the minimum number of pieces that can be evenly distributed to the guests in both of the cases with A guests and B guests.

-----Sample Input-----
2 3

-----Sample Output-----
6

When we have six snack pieces, each guest can take three pieces if we have two guests, and each guest can take two if we have three guests.

Difficulty: EASY

Solutions:
from math import gcd
(a, b) = map(int, input().split())
lcm = a * b / gcd(a, b)
print(int(lcm))


import math
(A, B) = map(int, input().split())
print(A * B // math.gcd(A, B))


import math

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

def lcm(x, y):
	return x * y // math.gcd(x, y)
[a, b] = L()
print(lcm(a, b))


import math
(a, b) = map(int, input().split())
c = math.gcd(a, b)
print(a * b // c)


import math
(a, b) = map(int, input().split())
(x, y) = (a, b)
while b != 0:
	(a, b) = (b, a % b)
print(x * y // a)


import math
(num1, num2) = map(int, input().split())
print(num1 * num2 // math.gcd(num1, num2))


import math
(a, b) = list(map(int, input().split()))
print(a * b // math.gcd(a, b))


import math
(a, b) = map(int, input().split())
x = math.gcd(a, b)
print(a * b // x)


(a, b) = map(int, input().split())
c = a * b
while b:
	(a, b) = (b, a % b)
print(c // a)


import math
(a, b) = map(int, input().split())
g = math.gcd(a, b)
print(a * b // g)


from fractions import *
(a, b) = map(int, input().split())
g = gcd(a, b)
print(a * b // g)


import math
(A, B) = map(int, input().split())
g = math.gcd(A, B)
l = A * B // g
print(l)


import math
(a, b) = (int(x) for x in input().split())
print(int(a * b / math.gcd(a, b)))


def main():
	from math import gcd
	(A, B) = list(map(int, input().split()))
	print(A * B // gcd(A, B))

def __starting_point():
	main()
__starting_point()


import math
import collections
ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(map(int, input().split()))
(a, b) = mi()
print(a * b // math.gcd(a, b))


(a, b) = map(int, input().split())
(x, y) = (a, b)
while y != 0:
	(x, y) = (y, x % y)
print(a * b // x)


import math
(a, b) = map(int, input().split())
ans = a * b // math.gcd(a, b)
print(ans)


import math
(A, B) = map(int, input().split())

def lcm(x, y):
	return x * y // math.gcd(x, y)
print(lcm(A, B))


def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a
(a, b) = map(int, input().split())
tmp = gcd(a, b)
print(int(a * b / tmp))


import math
[a, b] = [int(i) for i in input().split()]
print(a * b // math.gcd(a, b))


import math
[A, B] = [int(i) for i in input().split()]
ans = A * B / math.gcd(A, B)
print(int(ans))


import math
(x, y) = map(int, input().split())
print(x * y // math.gcd(x, y))


import sys
from itertools import chain

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

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

def solve(A: int, B: int):
	answer = lcm(A, B)
	return answer

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

def __starting_point():
	main()
__starting_point()


import math
(a, b) = map(int, input().split())
d = math.gcd(a, b)
print(a * b // d)


import math
(a, b) = list(map(int, input().split()))
x = math.gcd(a, b)
y = a * b
ans = y // x
print(ans)


import math
(A, B) = map(int, input().split())
g = math.gcd(A, B)
print(int(A * B / g))
return


from math import gcd
(a, b) = map(int, input().split())
val = gcd(a, b)
print(a * b // val)


from math import gcd
(A, B) = list(map(int, input().split()))
print(A * B // gcd(A, B))


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

def gcd(x, y):
	if y == 0:
		return x
	return gcd(y, x % y)
print(a * b // gcd(a, b))


import sys
import math
from collections import defaultdict, deque, Counter
from copy import deepcopy
from bisect import bisect, bisect_right, bisect_left
from heapq import heapify, heappop, heappush
input = sys.stdin.readline

def RD():
	return input().rstrip()

def F():
	return float(input().rstrip())

def I():
	return int(input().rstrip())

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

def MF():
	return map(float, input().split())

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

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

def LF():
	return list(map(float, input().split()))

def Init(H, W, num):
	return [[num for i in range(W)] for j in range(H)]

def main():
	(A, B) = MI()
	print(A * B // math.gcd(A, B))

def __starting_point():
	main()
__starting_point()


from math import gcd
(A, B) = map(int, input().split())
if A < B:
	(A, B) = (B, A)
print(A * B // gcd(A, B))


import math
(a, b) = map(int, input().split())
div = math.gcd(a, b)
print(div * a // div * b // div)


(A, B) = map(int, input().split())
r = A * B
while B:
	(A, B) = (B, A % B)
print(r // A)


from math import gcd

def lcm(a, b):
	return a * b // gcd(a, b)
(a, b) = list(map(int, input().split()))
print(lcm(a, b))


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

def gcd(a, b):
	while b != 0:
		(a, b) = (b, a % b)
	return a

def abc(a, b):
	return a * b // gcd(a, b)
print(abc(A, B))


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

def compute_gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def compute_lcm(x, y):
	lcm = x * y // compute_gcd(x, y)
	return lcm
num1 = 54
num2 = 24
print(compute_lcm(a, b))


import math
(A, B) = [int(n) for n in input().split()]
print(int(A * B / math.gcd(A, B)))


from math import *
(n, m) = map(int, input().split())
g = gcd(n, m)
print(n * m // g)


import math
(A, B) = (int(x) for x in input().split())
print(A * B // math.gcd(A, B))


from math import gcd as g
(a, b) = map(int, input().split())
print(a * b // g(a, b))


import math
(A, B) = [int(s) for s in input().split()]
print(A * B // math.gcd(A, B))


import math
(m, n) = map(int, input().split())
print(m * n // math.gcd(m, n))


(A, B) = map(int, input().split())
c = A * B
while B > 0:
	d = A % B
	A = B
	B = d
print(c // A)


(A, B) = map(int, input().split())
x = A
y = B
while y > 0:
	(x, y) = (y, x % y)
print(A // x * B)


import math as mp
(a, b) = map(int, input().split())
print(a * b // mp.gcd(a, b))


(A, B) = map(int, input().split())
import math
a = math.gcd(A, B)
ans = A * B // a
print(ans)


(A, B) = map(int, input().split())
from math import gcd
ans = A * B // gcd(A, B)
print(ans)


from math import gcd

def lcm(a, b):
	return a * b // gcd(a, b)
(A, B) = map(int, input().split())
print(lcm(A, B))