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):
import fractions
A, B = (int(x) for x in input().split(' '))
func = lambda a, b: a * b // fractions.gcd(a,b)
print(func(A,B))

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

n=max(a,b)
m=min(a,b)
ans=0
for i in range(1,m+1):
    ans=n*i
    if ans%m==0:
        print(ans)
        exit(0)

'''
ans=a*b//gcd(a,b)
print(ans)
'''

Solution (Python):
import sys
ab=input().rstrip().split(" ")
a=int(ab[0])
b=int(ab[1])
if a>=b:
    l=a
    s=b
elif a<b:
    l=b
    s=a
for i in range(1,s+1):
    u=i*l
    if u%s==0:
        ans=u
        print(ans)
        sys.exit()

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

Solution (Python):
import sys
from fractions import gcd

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

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

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

if a < b:
    small = a
    big = b
else:
    small = b
    big = a

i = 2    
while True:
    if (small * i) % big == 0:
        print(small * i)
        break
    i += 1

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())
costomer_gcd = fractions.gcd(a, b)
print(int(a*b/costomer_gcd))

Solution (Python):
a, b = map(int, input().split())
if a < b:
    a, b = b, a
A = a
B = b
while a % b != 0:
    a, b = b, a % b
print((A*B)//b)

Solution (Python):
a,b = map(int, input().split())
 
com = 1
for i in reversed(range(2,a+1)):
	if a % i ==0 and b % i == 0:
		a = a//i
		b = b//i
		com = com*i

print(a*b*com)

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

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



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

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

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

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

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

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

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

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

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

print(a*b//gcd(max(a,b),min(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())
ans = a*b/fractions.gcd(a,b)
print(int(ans))

Solution (Python):
a,b = map(int, input().split())
for i in range(b):
    result = (a * (i + 1))
    if result % b == 0:
        break
print(result)

Solution (Python):
import fractions


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


a, b = [int(i) for i in 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):
a,b = map(int, input().split())

import fractions
lcm = (a * b) / fractions.gcd(a, b)

lcm = int(lcm)

print(lcm)

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

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

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

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

def gcd(a,b):
    X = max(a,b)
    g=0
    for i in range(1,X+1):
        if a%i == 0 and b%i == 0:
            g = i
    return g




answer = gcd(a,b)
print(int(a*b/answer))

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

def gcd(m, n):
    x = max(m, n)
    y = min(m, n)
    if x%y==0:
        return y
    else:
        while x%y!=0:
            z = x%y
            x = y
            y = z
        else:
            return z

def lcm(m, n):
    return int(m*n/gcd(m, n))

print(lcm(A, B))

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

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

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

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))
a,b = iim()
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):
import fractions
A, B = map(int, input().split())
print(A * B // fractions.gcd(A, B))

Solution (Python):
def my_gcd(a, b):
    p = max(a, b)
    q = min(a, b)
    r = p % q
    while r > 0:
        p = q
        q = r
        r = p % q
    return q

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

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())
ans = A*B//fractions.gcd(A,B)
print(ans)

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 gcd(m,n):
  while m > 0 and n > 0:
    if m >= n:
      m = m - n
    else:
      n = n - m
  if m == 0:
    return n
  else:
    return m

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

Solution (Python):
a, b = [int(a) for a in input().split(' ')]
m, n = a, b
temp = 1
while m % n != 0:
    temp = n
    n = m % n
    m = temp

result = a * b / n
print(int(result))

Solution (Python):
import math  
import fractions


A, B = list(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(int(a * b / fractions.gcd(a, b)))

Solution (Python):
import sys
import fractions
sys.setrecursionlimit(10 ** 6)  
to_index = lambda x: int(x) - 1  
print_list_in_2D = lambda x: print(*x, sep="\n")  


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

def map_int_input(): return map(int, input())

MII = map_int_input

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

def MII_to_index(): return map(to_index, input())

def MII_split_to_index(): return map(to_index, input().split())


def list_int_inputs(): return list(map(int, input()))

LII = list_int_inputs

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


def LII_2D(rows_number): return [LII() for _ in range(rows_number)]

def LII_split_2D(rows_number): return [LII_split() for _ in range(rows_number)]

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

A, B = MII_split()

print(lcm(A, B))

Solution (Python):
import fractions


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


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

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


def main():
    A, B = map(int, input().split())
    print(A // GCD(A, B) * B)


main()

Solution (Python):
a,b=map(int, input().split())
for i in range(a,0,-1):
    if a % i == 0 and b % i == 0:
        c = i
        break
print(a*b//c)

Solution (Python):
from fractions import gcd

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

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

print(ans)

Solution (Python):
def gcd(a, b):
    while b:
        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 a < b :
        a, b = b, a
    while True:
        a, b = b, a % b
        if b == 0:
            return a
 
a, b = map(int, input().split())
print(int(a * b / gcd(a, b)))

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

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

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(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):
a,b=map(int,input().split())

def lcm(x, y):
 
   
   if x > y:
       lower = y
   else:
       lower = x
 
   while(True):
       if((x % lower == 0) and (y % lower == 0)):
           lcm = x*y//lower
           break 
       lower -= 1
 
   return lcm
print(lcm(a,b))

Solution (Python):
import fractions

def main():
  a, b = map(int, input().split())
  ans = a*b / fractions.gcd(a,b)
  print (int(ans))
  
if __name__ == "__main__":
  main()

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

def gcd(a,b):
    '''
    3 個以上の値の最大公約数を求めるためには、
    res = 0 と初期化
    各 i に対して res = GCD(res, x[i]) と更新する
    '''
    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 fractions
a,b = map(int,input().split())

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

print(lcm(a,b))

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


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


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


print(lcm(a, b))

Solution (Python):
import math
import numpy as np
A,B = list(map(int,input().split()))
if A == 1:
  print(B)
  exit()
if B == 1:
  print(A)
  exit()
C = A*B
D = []
for i in range(int(math.sqrt(C)),1,-1):
  if A % i == 0 and B % i == 0:
    D.append(i)
    A = A // i
    B = B // i
    C = A*B
if len(D) != 0:
  p = np.prod(D)
  C = C*p
print(C)

Solution (Python):
import fractions
 
data = input().split()
val = [int(n) for n in data]
 
res = val[0] * val[1] / fractions.gcd(val[0], val[1])
 
print(int(res))

Solution (Python):
a,b=map(int,input().split())
c=0
if(a<b):
  c=a
  a=b
  b=c

x=a
y=b
z=x%y
while(z!=0):
    x=y
    y=z
    z=x%y
d=y
    
print(int(a*b/d))

Solution (Python):
def GCD(a,b):
    c=b//a
    d=b%a
    if d==0:
        return a
    else:
        return GCD(d,a)

A,B=map(int,input().split())
if A>B:
  a=A
  b=B
else:
  a=B
  b=A
print(int(a*b/GCD(a,b)))

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):
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):
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):
def gcd(x,y):
    while y!=0:
        x,y=y,x%y
    return x

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

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

Solution (Python):
a,b = map(int,input().split())
c = max(a,b)
d = min(a,b)
for i in range(1,a*b):
  e = c%d
  if e != 0:
    c = d
    d = e
  else:
    break
print(a*b//d)

Solution (Python):

import fractions 

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

def lcm(A,B):
    return A * B // fractions.gcd(A,B)

print(lcm(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 = list(map(int,input().split()))

def lcm(x, y):
  return (x * y) // fractions.gcd(x, y)
 
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())
print(int(a * b / gcd(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(x, y):
    return (x * y) // gcd(x, y)

print(lcm(a,b))

Solution (Python):

from fractions import gcd

def lcm(a, b):
    """ aとbの最小公倍数を返す """
    return a*b // gcd(a, b)

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

    print(lcm(A, B))

if __name__ == "__main__":
    solve()

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())
n = 1
while True:
  if n*A % B == 0:
    print(n*A)
    break
  else:
    n += 1

Solution (Python):
import fractions

x,y = map(int,input().split())

print((x * y) // fractions.gcd(x, y))

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



gcd = fractions.gcd(A, B)


lcm = A*B / gcd

print(int(lcm))

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):
a,b = map(int,input().split())
x = 2
y = a
while y % b != 0:
    y = a*x
    x += 1
print(y)

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

def coprime_checker(x,y):
    if min(x,y) == 1:
        return 1
    else:
        for i in range(2,min(x,y) + 1):
            if x % i == 0 and y % i == 0:
                return i
                break
        return 1

gcd = 1
x = a
y = b
while coprime_checker(int(x),int(y)) != 1:
    c = coprime_checker(int(x),int(y))
    gcd *= c
    x /= c
    y /= c
least_common_multiple  = (a*b) / gcd
print(int(least_common_multiple))

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

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

Solution (Python):

import sys


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


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


def gcd(x: int, y: int):
    """xとyの最大公約数を求める"""
    return gcd(y, x % y) if y else x



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(A, B)

if __name__ == '__main__':
    main()

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

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

print(int(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

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

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

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

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(a * b // fractions.gcd(a, b))

Solution (Python):
from fractions import gcd 

A,B = list(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())

flag = True
num = 1
if A>B:

    while flag:
        temp = A * num
        if temp % B == 0:
            break
        num += 1

else:
    while flag:
        temp = B * num
        if temp % A == 0:
            break
        num += 1

print(temp)

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(x,y):
  while y!=0:
    x,y=y,x%y
  return x

c=a*b
d=gcd(a,b)
bai=int(c/d)

print(bai)

Solution (Python):
from fractions import gcd

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

Solution (Python):
from collections import defaultdict, deque
import sys, heapq, bisect, math, itertools, string, queue, copy, time
from fractions import gcd
import numpy as np
sys.setrecursionlimit(10**8)
INF = float('inf')
MOD = 10**9+7
EPS = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())


A, B = map(int, input().split())
def gcd(a,b):
    if b > a:
        return gcd(b,a)
    if b == 0:
        return a
    return gcd(a%b, b)

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

Solution (Python):
a,b = map(int,input().split())
c = a*b
t = 0
while True:
    b %= a
    if b == 0:
        break
    else:
        t = a
        a = b
        b = t
print(c//a)

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

def gcd(a, b):
    def _gcd(a, b):
        if b == 0:
            return a
        else:
            return gcd(b, a % b)
    if a > b:
        return _gcd(a, b)
    else:
        return _gcd(b, a)


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

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

AB_max = max(A,B)
A_k = A
B_k = B
number = 2
A_soinsu = dict()
B_soinsu = dict()
soinsu = dict()
while (A_k != 1 and B_k != 1) or number <= AB_max:
    check = 0
    A_count = 0
    if A_k % number == 0:
        check = 1
        if number not in A_soinsu:
            A_soinsu[number] = 1
        else:
            A_soinsu[number] += 1
        A_count = A_soinsu[number]
        A_k = A_k / number
    
    B_count = 0
    if B_k % number == 0:
        check = 1
        if number not in B_soinsu:
            B_soinsu[number] = 1
        else:
            B_soinsu[number] += 1
        B_count = B_soinsu[number]
        B_k = B_k / number
    
    count_max = max([A_count, B_count])
    if number not in soinsu:
        soinsu[number] = count_max
    else:
        if count_max > soinsu[number]:
            soinsu[number] = count_max
    if check == 0:
        number += 1

ans = 1
for k, v in soinsu.items():
    ans = ans * (k ** v)
print(ans)

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

def ccc(a, b):
    if a % b == 0:
        return b
    return ccc(b, a % b)

print(a * b // ccc(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 // GCD(a, b) * b

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

    return 0


if __name__ == '__main__':
    main()

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):
import sys
input=sys.stdin.readline
import fractions
a,b = map(int,input().split())
c = fractions.gcd(a,b)
print(int(a*b/c))

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())
ab = a*b
if a < b:
  a, b = b, a
while b > 0:
  a, b = b, a % b
print(ab // a)

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

Solution (Python):
def main():
	A,B = map(int, input().split())
	A,B = max(A,B), min(A,B)
	G = gcd(A,B)
	
	
	L=A*B/G
	print(int(L))

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


if __name__ == '__main__':
	main()

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

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

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

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

Solution (Python):






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache






MOD = 10**9 +7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    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 lcm(a, b):
    return a * b // gcd (a, b)





A,B = inputIL()

print(lcm(A,B))

Solution (Python):
from sys import stdin
import math
import fractions

a, b = [int(x) for x in stdin.readline().rstrip().split()]

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

Solution (Python):

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

a,b=map(int,input().split())
a,b=max(a,b),min(a,b)
print(a*b//fx(a,b))

Solution (Python):
import sys
input = sys.stdin.readline
import fractions 
def solve():
  a,b = (int(i) for i in input().split())
  print(a//fractions.gcd(a,b) * b)
solve()

Solution (Python):
n = input()

a, b = n.split()

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

for i in range(10 ** 5):
    i = i + 1
    if (i * a) % b == 0:
        print(a*i)
        break

Solution (Python):
a,b = map(int,input().split())
A,B = a,b
if A < B: A,B = B,A

while   A % B != 0:
  A,B = B,A % B

print(a * b//B)

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

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

abs = 1
for i in list(range(1,min(A,B)+1))[::-1]:
    if A%i==0 and B%i==0:
        abs = i
        break

print(int(A*B/abs))

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

if a < b:
    a, b = b, a
while a % b != 0:
    a, b = b, a % b
gcd = b
print(int(a_input * b_input / gcd))

Solution (Python):
A, B = map(int, input().split())
X = A * B
if A < B: A, B = B, A

while B:
  A, B = B, A % B
print (X // A)

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):
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
def lcm(x,y):
	return (x*y)//fractions.gcd(x,y)

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

if __name__ == '__main__':
	main()

Solution (Python):
A, B = map(int, input().split())
num = 0
for i in range(B + 1):
    num += A
    if  num % B == 0:
        break
print(num)

Solution (Python):
import fractions

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

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

if __name__ == '__main__':
    main()

Solution (Python):

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

Solution (Python):
import sys

input = sys.stdin.readline

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

for i in range(100000, 0, -1):
    if A % i == 0 and B % i == 0:
        print(A * B // i)
        exit()

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

lcm = a * b // fractions.gcd(a, b)

print(lcm)

Solution (Python):


import fractions





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


resolve()

Solution (Python):
A,B=list(map(int,input().split()))
if(A>=B):
  num=A
else:
  num=B
i=1
while True:
  ans=num*i
  if(ans%A==0 and ans%B==0):
    print(ans)
    break
  i+=1

Solution (Python):
a, b = map(int,input().split())
big = max(a, b)
small = min(a, b)
for i in range(1, 100000):
  if big*i % small == 0:
    print(big*i)
    exit()

Solution (Python):
A, B = map(int,input().split())
mul = A * B
while B:  
    if A < B:
        A, B = B, A
    A, B = B, A % B
print(mul // A)

Solution (Python):
import fractions

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

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

print(ans)

Solution (Python):
a,b = map(int,input().split())
ansl = []
if min(a,b) == 1:
  print(max(a,b))
else:
  for i in range(1,min(a,b)+1):
    if a%i == 0 and b%i == 0:
      ansl.append(i)
  if not ansl:
    print(a*b)
  else:
    print(int(a*b/max(ansl)))

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

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

Solution (Python):
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007
"""

    n,k,m=LI() 
    
    
    
    
    N=I()
    p=LIR(N)
    print(n,k,m,p)
"""

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

def resolve():
    a,b=LI()
    ans=lcm(a,b)
    print(ans)

    return

import sys
from io import StringIO
import unittest

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """2 3"""
        output = """6"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """123 456"""
        output = """18696"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """100000 99999"""
        output = """9999900000"""
        self.assertIO(input, output)

if __name__ == "__main__":
    
    resolve()

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):
import sys
import math
from collections import defaultdict
from collections import deque
def load(vtype=int):
    return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
    return [vtype(v) for v in input().strip().split(seplator)]
def exit():
    import sys
    sys.exit(0)
def perm_sub(li, used):
    if len(li) == len(used):
        return [deque()]
    k = []
    for i in range(len(li)):
        if i in used:
            continue
        used.add(i)
        sub_list = perm_sub(li, used)
        for sub in sub_list:
            sub.appendleft(li[i])
        k.extend(sub_list)
        used.discard(i)
    return k
def perm_li(li):
    return perm_sub(li, set())
def perm_n(n):
    return perm_sub(list(range(n)), set())
def join_i(li, sep=""):
    return sep.join([str(e) for e in li])
def li2n(li):
    n, base = 0, 1
    for i in range(len(li)-1, -1, -1):
        n += li[i] * base
        base *= 10
    return n
def sli2ili(li):
    return [int(s) for s in li] 
def prime_list(n):
    li = [i for i in range(2, n+1)]
    for i in range(len(li)):
        if li[i] >= int(math.sqrt(n)):
            break
        if li[i] == -1:
            continue
        for j in range(i+1, len(li)):
            if li[j] % li[i] == 0:
                li[j] = -1
    return [n for n in li if n != -1]
def gcd(a, b):
    a, b = max(a, b), min(a, b)
    while True:
        r = a % b
        if r == 0: return b
        a, b = b, r
def lcm(a, b):
    return int(a * b / gcd(a,b))

a, b = load_list()

print(lcm(a, b))

Solution (Python):
def gcd(n,m):
    n,m=sorted([n,m])
    while(m%n!=0):
        n,m=m%n,n
    return n
def lcm(n,m):
    return n*m//gcd(n,m)
n,m=map(int,input().split())
print(lcm(n,m))

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(int(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):
from fractions import gcd
a, b = map(int, input().split())
print(a * b // gcd(a, b))

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


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


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):
a,b = map(int,input().split())
import fractions
g = fractions.gcd(a,b)

print(round(a*b/g))

Solution (Python):
import fractions

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

Solution (Python):
import numpy as np
from collections import Counter
import fractions
import math

def hoge(p, q):
  return (p * q) // fractions.gcd(p, q)

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

main()