Problem:
 Score : 300 points    Problem Statement  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 1 2 3      Sample Output 1 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.       Sample Input 2 123 456      Sample Output 2 18696       Sample Input 3 100000 99999      Sample Output 3 9999900000

Solution (Python):
from copy import deepcopy
from sys import exit,setrecursionlimit
import math
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac
import fractions
from functools import reduce
from operator import mul
import bisect
import sys
import logging
import heapq
import itertools

logging.basicConfig(level=logging.ERROR)

input = sys.stdin.readline

setrecursionlimit(1000000)


def main():
	a,b = map(int,input().split())
	print(a*b//gcd([a,b]))

def factorization(n):
	if n<2:
		return []
	arr = []
	temp = n
	for i in range(2, int(-(-n**0.5//1))+1):
		if temp%i==0:
			cnt=0
			while temp%i==0:
				cnt+=1
				temp //= i
			arr.append([i, cnt])

	if temp!=1:
		arr.append([temp, 1])

	if arr==[]:
		arr.append([n, 1])

	return arr

def cmb(n,r):
    r = min(n-r,r)
    if r == 0: return 1
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1,r + 1))
    return over // under

def zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

def gcd(numbers):
	return reduce(fractions.gcd, numbers)

def lcm(numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

class PriorityQueue():
	def __init__(self):
		self.queue = []
	def push(self,i):
		heapq.heappush(self.queue,-i)
	def pop(self):
		return -1 * heapq.heappop(self.queue)
	def sum(self):
		return -sum(self.queue)

main()

Solution (Python):
import math

def lcm(x, y):
    return (x * y) // gcd(x, y)

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

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

print(lcm(a, b))

Solution (Python):
import fractions
a, b = map(int, input().split())
print(a * b // fractions.gcd(a, b))

Solution (Python):
import fractions

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

print(int(a * b / fractions.gcd(a, b)))

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

Solution (Python):
import fractions

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

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

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

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

print(c//gcd(a,b))

Solution (Python):
import fractions
a,b = map(int,input().split())
print(a*b//fractions.gcd(a,b))

Solution (Python):
INF = float("inf") 
MOD = 10**9+7 
MAX = 510000 

import fractions as frt

def main():
    a,b = map(int,input().split())
    print(a*b//frt.gcd(a,b))


if __name__ == "__main__":
    main()

Solution (Python):
import fractions
A, B = map(int, input().split())
print((A*B)//fractions.gcd(A, B))

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

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)


print(lcm(a, b))

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline






















def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

def main():
	A,B = inputMap()

	ans = lcm(A,B)
	print(ans)



def gcd(a, b):
	if a > b:
		a, b = b, a

	while a > 0:
		a, b = b % a, a
	return b

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

if __name__ == "__main__":
	main()

Solution (Python):
import fractions

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

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

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

if __name__ == "__main__":
	A, B = map(int, input().split())
	if A < B:
		A, B = B, A
	print(lcm(A, B))

Solution (Python):
from fractions import gcd
def lcm(a, b):
  return a * b // gcd (a, b)

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

Solution (Python):
import fractions
def main():
    A, B = [int(a) for a in input().split()]
    gcd = fractions.gcd(A, B)
    print(A * B // gcd)
main()

Solution (Python):
a,b=map(int,input().split())
import fractions
 
gcd=fractions.gcd(a,b)
lcm=a*b//gcd
print(lcm)

Solution (Python):
import fractions
def lcm(a, b):
    return (a*b) // fractions.gcd(a, b)
x = [int(i) for i in input().split()]
print(lcm(x[0], x[1]))

Solution (Python):
s,t=map(int,input().split())

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

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

Solution (Python):
import sys
def I(): return int(sys.stdin.readline())
def LI(): return [int(x) for x in sys.stdin.readline().split()]

def solv(a,b):
    a_ = a
    b_ = b
    while(a_%b_ != 0):
        a_,b_ = b_,a_%b_
    return a*b//b_
    
def main():
    A,B = LI()
    print(solv(A,B))

if __name__ == "__main__":
    main()

Solution (Python):
import fractions
A, B = map(int, input().split())
print(A*B//fractions.gcd(A, B))

Solution (Python):



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

aa = A
bb = B
while aa != bb:
    if aa < bb:
        aa += A
    else:
        bb += B

print(aa)

Solution (Python):
import fractions as f

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

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush
from fractions import gcd
from copy import deepcopy
import math
import queue


Mod = 1000000007
import sys

sys.setrecursionlimit(100000) 
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

def factorial(i):
    if i == 1:
        return 1
    else:
        return i*factorial(i-1)
 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)




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



if __name__ == "__main__":
    main()

Solution (Python):



import math
import fractions
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

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

Solution (Python):
import fractions
a,b = map(int,input().split())
print(a*b//fractions.gcd(a,b))

Solution (Python):
def gcm(a,b):
    if a < b:
        a,b = b,a
    while True:
        if a % b == 0:
            return b
        else:
            a,b = b,a % b

def lcm(a,b):
    g = gcm(a,b)
    return a*b//g;

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

Solution (Python):
a,b=map(int,input().split())
def gcd(a,b):
    while b!=0:
        a,b=b,a%b
    return a

def lcm(x, y):
    return (x * y) // gcd(x, y)

print(lcm(a, b))

Solution (Python):
from fractions import gcd

def read():
    A, B = list(map(int, input().strip().split()))
    return A, B


def solve(A, B):
    return A * B // gcd(A, B)


if __name__ == '__main__':
    inputs = read()
    print("%d" % solve(*inputs))

Solution (Python):
import fractions
 
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
 
if __name__ == '__main__':
    a,b  = map(int, input().split())
    ans = lcm(a,b)
    print(ans)

Solution (Python):
A,B=map(int,input().split())
def gcd(a,b):
    if a<b:
        a,b=b,a
    c=a%b
    if c==0:
        return b
    return gcd(b,c)
print(int(A*B/gcd(A,B)))

Solution (Python):
import fractions

A, B = map(int, input().strip().split())
print(A * B // fractions.gcd(A,B))

Solution (Python):
import fractions
A, B = map(int, input().split())


gcd = fractions.gcd(A, B)
ans = A * B / gcd

print(int(ans))

Solution (Python):

import fractions



def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

if __name__ == "__main__":
    a, b = map(int, input().split())
    print(lcm(a, b))

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

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


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

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

print(lcm(a,b))

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

from fractions import gcd

def lcm(a, b):
    """
    aとbの最小公倍数を計算します。
    """
    return a * b // gcd(a, b)

print(lcm(A, B))

Solution (Python):
from fractions import gcd

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

print((a*b)//gcd(a,b))

Solution (Python):
import sys
import fractions
A, B = map(int, sys.stdin.readline().split())

print((A*B)//fractions.gcd(A,B))

Solution (Python):
def gcd(A,B):
    a=min(A,B)
    b=max(A,B)
    if a==0:
        return b
    else:
        return gcd(a,b%a)


A,B=[int(i) for i in input().split(" ")]

print(int(A*B/gcd(A,B)))

Solution (Python):
def gcd(x, y):
    z = x % y
    if z == 0:
        return y
    return gcd(y, z)


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

Solution (Python):
from fractions import gcd

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

    print((a*b) // gcd(a, b)) 

if __name__ == "__main__":
    main()

Solution (Python):
import fractions

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

x = A * B // fractions.gcd(A, B)

print(x)

Solution (Python):



import fractions


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


def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)


ans = lcm(A, B)
print(ans)

Solution (Python):
from fractions import gcd

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

print(a * b // gcd(a, b))

Solution (Python):
def gcd(x,y):
    while y != 0:
    	x,y=y,x%y
    return x

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

Solution (Python):
import fractions
a,b=list(map(int,input().split()))

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

Solution (Python):
import fractions

i = input().split(" ")
a = int(i[0])
b = int(i[1])

print(int(a * b // fractions.gcd(a,b)))

Solution (Python):
import fractions

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

ans = a * b // fractions.gcd(a, b)
print(ans)

Solution (Python):
from fractions import gcd


def lcm(x, y):
    return (x * y) // gcd(x, y)


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

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

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

print(lcm(a, b))

Solution (Python):
import fractions
A,B=map(int,input().split())
print((A*B)//fractions.gcd(A,B))

Solution (Python):
from functools import reduce
from fractions import gcd

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

Solution (Python):
import fractions


A, B = map(int, input().split())
lcm = A * B / fractions.gcd(A, B)
print(int(lcm))

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


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

print(a * b // gcd(a, b))

Solution (Python):
import fractions
def main():
    a,b = map(int,input().split())
    print(int(a*b//fractions.gcd(a,b)))
    
if __name__ == '__main__':
    main()

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

import fractions

print(a*b//fractions.gcd(a,b))

Solution (Python):
def gcd(a, b):
    '''ユークリッド互除法を使った最大公約数の求め方'''
    while b != 0:
        a, b = b, a % b
    return(a)


def lcm(a, b):
    '''最小公倍数の求め方'''
    return a * b // gcd(a, b)

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

print(lcm(A,B))

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

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

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

print(lcm(A, B))

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


def gcd(m, n):
    if m < n:
        m, n = n, m
    if n == 0:
        return m
    return gcd(n, m % n)


print(A * B // gcd(A, B))

Solution (Python):
def gcd(x, y):
    while y != 0:
        x, y = y, x%y
    return x


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

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

print(lcm(A,B))

Solution (Python):
import fractions
x,y = map(int,input().split())
print((x * y) // fractions.gcd(x,y))

Solution (Python):
import fractions
a,b=map(int,input().split())
x=fractions.gcd(a,b)
print(a*b//x)

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

for i in range(1,10000000):
    c = a * i
    if c % b == 0:
        print(c)
        break

Solution (Python):
from fractions import gcd

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


def lcm(x, y):
    return (x * y) // gcd(x, y)


print(lcm(A, B))

Solution (Python):
a, b = map(int, input().split())
if a < b:
  tmp =a
  a = b
  b = tmp
r = a%b
x  =a * b
while(r!=0):
  a = b;
  b = r;
  r = a %b
print(int(x/b))

Solution (Python):
import sys











from fractions import gcd

def main():
	a,b=map(int,input().split())
	c=gcd(a,b)
	print(a*b//c)
	
	




	
if __name__ == "__main__":
	main()

Solution (Python):

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

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

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

print(lcm(a,b))

Solution (Python):
def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a%b)


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

ans = A * B // gcd(A, B)

print(ans)

Solution (Python):
def gdc(a, b):
    while b:
        a, b = b, a % b
    return a

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

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

Solution (Python):
def euc(a,b):
  if b>a:
    return euc(b,a)
  res = a%b
  if res==0:
    return b
  else:
    return euc(b,res)

B,C = map(lambda x: int(x),input().split())
print(int(B*C/euc(B,C)))

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


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

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


print(lcm(a,b))

Solution (Python):
import fractions
temp=list(map(int, input().split()))
a=temp[0]
b=temp[1]

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
print(lcm(a,b))

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

Solution (Python):
def gcd(x,y):
    while y>0:
        x,y = y,x%y
    return x
A,B = map(int,input().split())
a = gcd(A,B)
b = (A//a)*(B//a)*a
print(b)

Solution (Python):

MOD = 10 ** 9 + 7

import math
import fractions
import itertools



def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default


def main():


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

if __name__ == "__main__":
    main()

Solution (Python):
import fractions
A, B = map(int, input().split())

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

print(lcm(A, B))

Solution (Python):
from fractions import gcd

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

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

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

print(a*b//gcd(a,b))

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

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

Solution (Python):
import fractions as math

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

print(int(a * b / math.gcd(a, b)))

Solution (Python):
import fractions

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

ans = A * B // fractions.gcd(A, B)

print(ans)

Solution (Python):
import fractions
A, B = map(int, input().split())
def lcm(x,y):
    return (x*y) // fractions.gcd(x,y)
print(lcm(A,B))

Solution (Python):
A, B = map(int,input().split())
 
def gcd(a,b):
  while b!=0:
    a,b=b,a%b
  return a

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

print(lcm(A,B))

Solution (Python):
import sys
from fractions import gcd

stdin = sys.stdin

ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))  
rs = lambda: stdin.readline().rstrip()  

A, B = rl()
answer = A * B // gcd(A, B)
print(answer)

Solution (Python):
from fractions import gcd

ab = list(map(int, input().split()))
a = ab[0]
b = ab[1]

print((a * b) // gcd(a, b))

Solution (Python):
from fractions import gcd
A, B = map(int, input().split())
print(A * B // gcd(A, B))

Solution (Python):
A,B=map(int,input().split())
ans=1
for g in range(1,100000):
  if A%g==0 and B%g==0:
    ans=g
print((A*B)//ans)

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

def lcm(x, y):
    return (x * y) // gcd(x, y)

print(lcm(a, b))

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


import fractions

print(A*B//fractions.gcd(A, B))

Solution (Python):
import fractions

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

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

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

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

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

print(int((a*b/fractions.gcd(a, b))))

Solution (Python):
import fractions

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

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

print(lcm(a, b))

Solution (Python):
import fractions
A, B = map(int, input().split())

print(A * B // fractions.gcd(A,B))

Solution (Python):
import fractions as fc
a,b=map(int,input().split())
print((a*b)//fc.gcd(a,b))

Solution (Python):
import fractions

a, b = map(int, input().split())
c = fractions.gcd(a, b)


print(a * b // c)

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


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




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


print(lcm(A, B))

Solution (Python):
import sys, fractions
def input():
    return sys.stdin.readline()[:-1]
A,B = map(int,input().split(' '))
k = fractions.gcd(A,B)
a = A//k
b = B//k
print(k*a*b)

Solution (Python):
import sys,collections,math,random;sys.setrecursionlimit(10**7)
from fractions import gcd
def Is(): return [int(x) for x in sys.stdin.readline().split()]
def Ss(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

x,y = Is()
print((x * y) // gcd(x, y))

Solution (Python):
import fractions

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

GCD = fractions.gcd(A,B)
print(int(A*B/GCD))

Solution (Python):
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a
a,b=[int(i)for i in input().split()]
print(a*b//gcd(a,b))

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

def gcd(x, y):
	while y != 0:
		t = x % y
		x = y
		y = t
	return x

print(a * b // gcd(a, b))

Solution (Python):
import fractions
a, b = map(int, input().split())
g = fractions.gcd(a, b)
ans = a*b//g
print(ans)

Solution (Python):
from fractions import gcd

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

print((a * b) // gcd(a, b))

Solution (Python):
from fractions import gcd

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

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


def lcm(A,B):
    if B>A:
        A,B=B,A
    while A%B!=0:
        A,B=B,A%B
    return B
    
print(A*B//lcm(A,B))

Solution (Python):
import sys, fractions
from collections import defaultdict
from copy import deepcopy
import itertools
input = sys.stdin.readline




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

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

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

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

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

print(lcm(A, B))

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


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


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

print(lcm(A,B))

Solution (Python):
def scm(s):
    x, y = s
    def gcd(x, y):
        while y:
            x, y = y, x % y
        return x
    gcd = gcd(x, y)
    print(x * y // gcd)

if __name__ == "__main__":
    import sys
    in_str = []
    for line in sys.stdin:
        in_str.append(line)
    scm([int(_) for _ in in_str[0].split()])

Solution (Python):
from fractions import gcd

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

print(A * B // gcd(A, B))

Solution (Python):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def gcd(a,b): 
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

def divisors(a): 
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): 
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): 
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

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

if __name__=='__main__':
    main()

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


def f(m, n):
    while (m % n != 0):
        temp = n
        n = m % n
        m = temp
    return n


print(a * b // f(a, b))

Solution (Python):
import sys, math, fractions
from itertools import permutations, combinations
from collections import defaultdict

sys.setrecursionlimit(10**7)
A, B = map(int, input().split())

ans = fractions.gcd(A, B)
print(A*B//ans)

Solution (Python):
import fractions

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


def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

print(lcm(A,B))

Solution (Python):


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

Solution (Python):
import fractions
a, b= map(int, input().split())
n = fractions.gcd(a,b)
print(a*b//n)

Solution (Python):
import fractions
def main():
    A,B = map(int,input().split())
    g = fractions.gcd(A,B)
    print(A*B//g)
if __name__ == "__main__":
    main()

Solution (Python):
from fractions import gcd

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

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

Solution (Python):
import fractions
a,b=map(int, input().split())
f=fractions.gcd(a,b)
f2=a*b//f
print(f2)

Solution (Python):
k = [int(x) for x in input().split()]
summ = k[0]*k[1]
while(k[0]%k[1]!=0 and k[1]%k[0]!=0):
    if(k[0]>k[1]): k[0]=k[0]%k[1]
    else: k[1]=k[1]%k[0]
if(k[0]>k[1]): print(int(summ/k[1]))
else: print(int(summ/k[0]))

Solution (Python):
A, B = map(int, input().split())
from fractions import gcd
print(A*B//gcd(A, B))

Solution (Python):

from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time
from fractions import gcd



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


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


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YN = ['No', 'Yes']
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']



show_flg = True

p = None
XY = None
N = None


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


def main():
    A, B = MI()
    print(lcm(A, B))


if __name__ == '__main__':
    main()

Solution (Python):
from functools import reduce
from fractions import gcd
def lcm(x,y):return x*y//gcd(x,y)
def lcmm(l):return reduce(lcm,l)


a,b=input().split()
List=[int(a),int(b)]
print(lcmm(List))

Solution (Python):
import fractions as fc

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

print(a*b//fc.gcd(a,b))

Solution (Python):
def gcd(a,b):
    if not b:
        return a
    while a%b:
        a, b = b, a%b
    return b

def lcm(a,b):
    if not a or not b:
        return 0  
    g = gcd(a,b)
    return a*b//g

a, b = [int(s) for s in input().split()]
print(lcm(a,b))

Solution (Python):
import math
import fractions

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

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

print(lcm(A, B))

Solution (Python):
from functools import reduce
from fractions import gcd
a = list(map(int, input().split()))
def lcm(x,y):
    return x*y//gcd(x,y)
def lcmm(l):
    return reduce(lcm,l)
print(lcmm(a))

Solution (Python):
import fractions
a,b=map(int,input().split())
print(a*b//fractions.gcd(a,b))

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

Solution (Python):
import fractions

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

print((A * B) // fractions.gcd(A, B))

Solution (Python):
def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)

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

Solution (Python):
import math
A,B = map(int,input().split())
a = A
b = B
while a!=b:
  if a>b:
    a -= b
  else:
    b -= a
print(math.floor(A*B/a))

Solution (Python):
def lcm(x,y):
    return (x * y)// gcd(x,y)
def gcd(x,y):
    if x < y:
        x, y = y, x
    while y!=0:
        x,y=y,x%y
    return x
def main():
    A, B = map(int, input().split())
    print(lcm(A,B))
main()

Solution (Python):
import fractions
A,B = (int(i) for i in input().split())

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

print(lcm(A,B))

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

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


a,b = [int(_) for _ in input().split()]
print(lcm(a,b))

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

[A,B]=[int(i) for i in input().split()]

print(A*B//gcd(A,B))

Solution (Python):

from fractions import gcd

def solve():
    a,b = map(int, input().split())
    return str(a*b//gcd(a,b))

if __name__ == '__main__':
    print(solve())

Solution (Python):
import fractions
A, B = map(int, input().split())
print(A*B // fractions.gcd(A, B))

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

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

Solution (Python):
def gcd(x,y):
    while y != 0:
        x, y = y, x%y

    return(x)

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

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

init = max(a, b)
minit = min(a, b)
step = init

while(True):
    if(init % minit == 0):
        break
    init += step
print(init)

Solution (Python):
A,B = list(map(int,input().split()))
def gcd(a,b):
    while b!=0:
        a,b=b,a%b
    return a
C = max(A,B)
D = min(A,B)
E = gcd(C,D)
output = int(A*B/E)
print(output)

Solution (Python):
import fractions
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
a,b = map(int,input().split())
print(lcm(a,b))

Solution (Python):
import fractions
a, b = [int(x) for x in input().split(' ')]

print((a * b) // fractions.gcd(a, b))

Solution (Python):
def gcd(a,b):
  if a%b==0:
    return(b)
  else:
    return(gcd(b,a%b))

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

Solution (Python):
import fractions

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

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

print(lcm(a, b))

Solution (Python):
def gcd(p,q):
  
  big=max(p,q)
  small=min(p,q)
  if small==0:
    return big
  else:
    return gcd(big%small,small)

ab=input().split(" ")
a=int(ab[0])
b=int(ab[1])
print(a*b//gcd(a,b))

Solution (Python):
import fractions


def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)


def main():
    A, B = map(int, input().split())
    print(lcm(A, B))


main()