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

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

print(lcm(a, b))

Solution (Python):
from fractions import gcd


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


if __name__ == "__main__":
    main()

Solution (Python):
import sys; readline = sys.stdin.readline
from collections import deque


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

def f(a, b):
    if a < b:
        a, b = b, a

    while True:
        if a % b == 0:
            break
        r = a % b
        a, b = b, r
    
    return b

c = f(A, B)

print(A * B // c)

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 sys
input = sys.stdin.readline

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 fractions


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


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

print(lcm(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 saidaikouyaku(a, b):
    while b != 0:
        a, b = b, a % b
    return a

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

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

a, b = (int(_) for _ in input().split())

z = lcm(a,b)
print(z)

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())
x = max(a,b)
y = min(a,b)
while y!=0:
    x,y = y,x%y
print((a*b)//x)

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):
    if a == 0:
        return b
    else:
        return gcd(b % a, a)


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

print(A * B // g)

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

import fractions

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

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

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):
def computeGCD(x, y):
    if x > y:
        small = y
    else:
        small = x
    for i in range(1, small + 1):
        if ((x % i == 0) and (y % i == 0)):
            gcd = i

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

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):
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 fractions
A, B = map(int, input().split())
x = (A*B) // fractions.gcd(A, B)

print(x)

Solution (Python):
import fractions

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

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

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

Solution (Python):

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

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

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())
lcm(a, b)

print(lcm(a, b))

Solution (Python):
from fractions import gcd

from heapq import*
import math
from collections import defaultdict, Counter, deque
from bisect import *
import itertools
import fractions
import sys
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7



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

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

    
    

        


if __name__ == '__main__':
    main()

Solution (Python):
A,B=map(int,input().split())
Adiv=[]
Bdiv=[]
Co=[]
for i in range(1,A+1):
  if A%i==0:
    Adiv+=[i]
for i in range(1,B+1):
  if B%i==0:
    Bdiv+=[i]
for i in Adiv:
  if i in Bdiv:
    Co+=[i]
M=max(Co)
print(int(A*B/M))

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())
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 = [int(n) for n in input().split()]

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

Solution (Python):






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

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

Solution (Python):

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

minArg = min(a, b)
maxArg = max(a, b)
i = 2

while True:
    tmp = minArg * i
    if tmp%maxArg == 0:
        print(tmp)
        exit()
    else:
        i += 1

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

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(' ')]
gcd_ = gcd(A, B)
print(int(A*B/gcd_))

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

def gcd(x,y):
  if y == 0:
    return x
  else:
    return gcd(y,x % y)
ans = A * B / gcd(A,B)
print(int(ans))

Solution (Python):

import sys
input = sys.stdin.readline

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)

res = lcm(A,B)

print(res)

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

Solution (Python):

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

if a > b :
    c = a
    d = b
else:
    c = b
    d = a

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(c,d))

Solution (Python):
import sys
import fractions
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

a, b = map(int, read().split())
f= fractions.gcd(a,b)
f_ = a *b // f
 
print(f_)

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

Solution (Python):

import sys
import fractions


def solve(A: int, B: int):
    print(A * B //fractions.gcd(A, B))
    return



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

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

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

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

print(lcm(a, b))

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 = list(map(lambda x: int(x), input().split(" ")))
A = a_b[0]
B = a_b[1]

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

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 fractions
def main():
    A,B = map(int, input().split())
    print((A*B) // fractions.gcd(A,B))


if __name__ == "__main__":
    main()

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):
    while b!=0:
        a,b=b,a%b
    return a
A,B=map(int,input().split())
print(A*B//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):
a,b = map(int,input().split())

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

print(int(c))

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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


A, B = MAP()
def lcm(a, b):
    y = a*b / gcd(a, b)
    return int(y)
print(lcm(A, B))

Solution (Python):
x, y = input().split(' ')
x = int(x)
y = int(y)

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



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

print(int(lcm(x, y)))

Solution (Python):
from fractions import gcd

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

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

Solution (Python):
from sys import stdin

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 = [int(x) for x in stdin.readline().rstrip().split()]
    print(lcm(A, B))

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

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

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

Solution (Python):
def gcd(x,y):
    if x<y:
        x,y=y,x
    if y==0:
        return x
    else:
        return gcd(y,x%y)
a,b=map(int,input().split())
print(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):
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):
from fractions import gcd
a,b = map(int,input().split())

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

Solution (Python):
a, b=(int(i) for i in input().split())

import fractions

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(A * B // gcd(A, B))

Solution (Python):
import sys
import math
import bisect
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop


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


def I(): return int(sys.stdin.readline())


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 A():
    a = I()
    b = I()
    print(6 - a - b)
    return



def B():
    n = I()
    s, t = input().split(' ')
    ans = []
    for i in range(n):
        ans.append(s[i])
        ans.append(t[i])
    print(''.join(ans))
    return



def C():
    def GCD(a, b):
        if (b == 0):
            return a
        else:
            return GCD(b, a % b)

    a, b = LI()
    print(a * b // GCD(a, b))
    return



def D():
    return



def E():
    return



def F():
    return



def resolve():
    C()
    return



if __name__ == "__main__":
    C()

Solution (Python):
from sys import stdin
import platform
ver = platform.python_version_tuple()
if int(ver[1]) < 5:
    from fractions import gcd
else:
    from math import gcd


def main():
    input = lambda: stdin.readline()[:-1]
    A, B = map(int, input().split())

    lcm = lambda x, y: x * y // gcd(x, y)
    print(lcm(A, B))


main()

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

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

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

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


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

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

Solution (Python):
a, b = list(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 = input().split(" ")
A, B = int(A), int(B)


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

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

Solution (Python):
def lcm(a):
    from fractions import gcd
    x = a[0]
    for i in range(1, len(a)):
        x = (x * a[i]) // gcd(x, a[i])
    return x

x = list(map(int, input().split()))
print(lcm(x))

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

inp = input().split()
A = int(inp[0])
B = int(inp[1])

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):
def gcd(m, n):
  x=max(m, n)
  y=min(m, n)
  while x%y!=0:
    z=x%y
    x=y
    y=z
  else:
    return(y)

A,B=map(int, input().split())
print(int(A*B / 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())
ans = lcm(a,b)
print(ans)

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

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

Solution (Python):
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import time
import random
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 GI(V,E,Directed=False,index=0):
    org_inp=[]
    g=[[] for i in range(n)]
    for i in range(E):
        inp=LI()
        org_inp.append(inp)
        if index==0:
            inp[0]-=1
            inp[1]-=1
        if len(inp)==2:
            a,b=inp
            g[a].append(b)
            if not Directed:
                g[b].append(a)
        elif len(inp)==3:
            a,b,c=inp
            aa=(inp[0],inp[2])
            bb=(inp[1],inp[2])
            g[a].append(bb)
            if not Directed:
                g[b].append(aa)
    return g,org_inp
def show(*inp,end='\n'):
    if show_flg:
        print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()

input=lambda: sys.stdin.readline().rstrip()

def ran_input():
    import random
    n=random.randint(4,16)
    rmin,rmax=1,10
    a=[random.randint(rmin,rmax) for _ in range(n)]
    return n,a

show_flg=False
show_flg=True


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

a,b=LI()

ans=[]


print(a*b//gcd(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):

import sys
import math
import collections


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

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

print(ans)

Solution (Python):
import fractions

str_list = input().split(' ')
int_list = [int(x) for x in str_list]
A, B = int_list[0], int_list[1]

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

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

	




if __name__ == '__main__':
	main()

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

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

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

print(R)

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

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

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

print(lcm(a,b))

Solution (Python):
from sys import stdout
import fractions
printn = lambda x: stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
BIG = 999999999
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

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

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

Solution (Python):
import fractions
input_l = list(map(int,input().split()))
a = input_l[0]
b = input_l[1]
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
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
a,b=map(int,input().split())
print(lcm(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
a, b = map(int, input().split())
print( (a*b)//fractions.gcd(a, b) )

Solution (Python):
import fractions

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

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 gcd(a,b):
    while b!=0:
        a,b = b,a%b
    return a

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

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

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

Solution (Python):
import sys
import fractions
def input(): return sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

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

Solution (Python):
a=list(map(int,input().split()))
A=a[0]
B=a[1]

import fractions

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

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

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

print(lcm(A, B))

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

Solution (Python):
from fractions import gcd


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


if __name__ == "__main__":
    main()

Solution (Python):
import fractions

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

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

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

ans = lcm(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):
import sys
sys.setrecursionlimit(1000000)
A,B=map(int,input().split())
def gcd(a,b):
  while b!=0:
    a,b=b,a%b
  return a

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

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

Solution (Python):
a,b=map(int,input().split())
def gcd(x,y):
    while y!=0:
        x,y=y,x%y
    return x
print(int((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 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):
import fractions
a, b = map(int, input().split())
ans = a * b // fractions.gcd(a, b)
print(ans)

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

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

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

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

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


import fractions

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

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

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

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

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 as f
a,b =[int(x) for x in input().split()]
def lcm(x, y):
    return (x * y) // f.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):
def gcd(a, b):
    x = min(a, b)
    y = max(a, b)
    if x % y == 0:
        return y
    else:
        while x % y != 0:
            z = x % y
            x = y
            y = z
        else:
            return z


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


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

Solution (Python):
a,b = map(int,input().split())
count=a
while count % b != 0:
    count +=a
print(count)

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):
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())
ans=lcm(a,b)
print(ans)

Solution (Python):

import fractions


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

Solution (Python):
import fractions as f

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

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


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

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


from functools import reduce


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


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


print(lcm(a, b))

Solution (Python):
from fractions import gcd

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

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

print(lcm)

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

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)

def run():
  A, B = map(int, input().split())
  ans = lcm(A, B)
  print(ans)
  
if __name__ == '__main__':
  run()

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().strip().split())

print(lcm(a,b))

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

min = (a * b) // gcd(a,b)

print(min)

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

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

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


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


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

Solution (Python):
import math
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())

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

print(lcm(A, B))

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


def main():
    sc = Scan()
    a, b = sc.intarr()
    print(lcm(a, b))


class Scan():

    def intarr(self):
        line = input()
        array = line.split(' ')
        num_array = [int(n) for n in array]
        return num_array

    def intarr_ver(self, n):
        return [int(input()) for _ in range(n)]

    def strarr(self):
        line = input()
        array = line.split(' ')
        array[-1] = array[-1].strip('\n')
        return array


def display(array):
    for a in range(len(array)):
        if len(array) - a != 1:
            print(array[a], end=' ')
        else:
            print(array[a])


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


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


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


main()

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

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)
  
print(int(lcm(a,b)))