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

N = A*B

if A >= B:
    a = int(N/A)
    for i in range(a):
        if A*(a-i) % B == 0:
            N = A*(a-i)

else:
    b = int(N/B)
    for i in range(b):
        if B*(b-i) % A == 0:
            N = B*(b-i)

print(N)

Solution (Python):
import sys
import fractions


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    a, b = list(map(int, readline().split()))
    print(a * b // fractions.gcd(a, b))


if __name__ == '__main__':
    solve()

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

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

Solution (Python):
def lcm(a,b):
    m = a*b
    while a != 0 and b != 0:
        if a > b:
            a %= b
        else:
            b %= a
    return m // (a+b)
a, b = tuple(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)

if __name__ == "__main__":
    arr = input().split(" ")
    print(lcm(int(arr[0]), int(arr[1])))

Solution (Python):
from sys import stdin
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
a,b = map(int, stdin.readline().rstrip().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())

Max = max([A, B])
Min = min([A, B])

for i in range(1, Max + 1):
    pro = Min * i
    if pro % Max == 0:
        break

print(pro)

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


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


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

Solution (Python):

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

c = a*b

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

print(c//a)

Solution (Python):



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


if __name__=='__main__':
  a, b = map(int, input().strip().split())
  print(int(a * b / gcd(a ,b)))

Solution (Python):





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

if A >= B : 
    L = A
    S = B
else : 
    L = B
    S = A

while True : 
    mod = L % S
    if mod != 0 : 
        L = S
        S = mod
    else : 
        GCD = S
        break

LCM = int((A/GCD) * (B/GCD) * GCD)

print(LCM)

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


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

print(lcm(a,b))

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

n = 1
while ((b * n) % a) != 0:
  n = n + 1

print(b * n)

Solution (Python):
from fractions import gcd

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

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

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

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

Solution (Python):
import fractions
A,B = list(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
	print(gcd(a,b))

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

Solution (Python):
A,B = (int(i) for i in input().split())
def gcd(a,b):
    if a % b == 0:
        return b
    else:
        r = a% b
        return gcd(b,r)
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):
import fractions

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

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

if __name__ == '__main__':
    main()

Solution (Python):
import fractions


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


def main():
    A, B = map(int, input().split())
    print(run(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):
ab = list(map(int, input().split()))
a = max(ab)
b = min(ab)
r = a%b
while r!=0:
    a = b
    b = r
    r = a%b
print(int(max(ab) * min(ab)/b))

Solution (Python):

def gcd(a,b):
    if a > b: a,b = b,a
    while a != 0:
        a,b = b%a,a
    return (b)
if __name__ == "__main__":
    import sys
    read = sys.stdin.buffer.read
    readline = sys.stdin.buffer.readline
    readlines = sys.stdin.buffer.readlines
    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 = sorted(map(int,input().split()))
for i in range(1,A+1):
    if B*i%A == 0:
        print(B*i)
        break

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


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

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

print (lcm(A,B))

Solution (Python):
A,B=(int(x) for x in input().split())
a=max(A,B)
b=min(A,B)

while True:
  if a%b==0:
    break
  else:
    a,b=b,a%b
o=int(A*B/b)
print(o)

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

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

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

print(lcd(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
  return y

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

A = list(map(int, input().split()))
print(lcm(A[0], A[1]))

Solution (Python):


import fractions

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

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

print(int(lcm(a, b)))

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):
def gcd(a,b):
    if b>a:
        return gcd(b,a)
    else:
        if b==0:
            return a
        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())
 
print((A * B) // fractions.gcd(A, B))

Solution (Python):
a, b = tuple(map(int, input().split(" ")))
prod = a*b
if a>b:
    a, b = b, a
r = b % a
while r:
    b, a = a, r
    r = b % a
print(int(prod/a))

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):
def gcd(a, b):
    r = a % b
    if r == 0:
        return b
    else:
	    return gcd(b, r)
def lcm(a,b):
    return a * b // gcd(a, b)
a,b = tuple(map(int,input().rstrip().split()))
print(lcm(a, b))

Solution (Python):
ints = [ int(i) for i in input().split(" ") ]

maxInt = max(ints)
minInt = min(ints)

count = 1
while True: 

  if maxInt * count % minInt == 0:
    print(maxInt * count)
    break
  
  count += 1

Solution (Python):
import fractions


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

print((A * B) // gcd)

Solution (Python):
p=input().split()
a=int(p[1])
b=int(p[0])
i=1
while i<=b:
    if(a==0 or b==0):
        print(max(a,b))
        break
    elif((a*i)%b==0):
        print(a*i)
        break
    i+=1

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

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

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

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

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

Solution (Python):
import math
from math import ceil
from math import factorial
from collections import Counter
from operator import itemgetter

def gcd(a,b):
	if(b==0):
		return a
	return gcd(b,a%b)
import bisect
ii = lambda: int(input())
iia = lambda: list(map(int,input().split()))
isa = lambda: list(input().split())

a,b = iia()

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

Solution (Python):
import fractions
a=input().split()
print(int(a[0]) * int(a[1]) // fractions.gcd(int(a[0]), int(a[1])))

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

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

A, B = [int(x) for x in input().split()]
print(saishoukoubaisu(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())
g = gcd(a, b)
l = a * b // g
print(l)

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

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):
def LMC(a,b):
  i = 1
  while(1):
    c = a * i
    if c % b == 0:
      return c
    i += 1

num_line = [int(i) for i in input().split(" ")]
print(LMC(num_line[0],num_line[1]))

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

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

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

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

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

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

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

if a > b:
    big = a
    sh = b
else:
    big = b
    sh = a

while big % sh != 0:
    r = big % sh
    big = sh
    sh = r
r = sh

ans = a*b/r
print(int(ans))

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

cnt = 1

for cnt in range(1,A*B) :
  if cnt*min(A,B)%A == 0 and cnt*min(A,B)%B == 0:
    break
  else:
    cnt = cnt +1
  
print(cnt*min(A,B))

Solution (Python):
def euq(a, b):
  if b==0: return a
  else:
    tmp = b
    b = a%b
    a = tmp
    return euq(a, b)
  
A, B = map(int, input().split())
ma = euq(max(A, B), min(A, B))

ans = A*B//ma
print(ans)

Solution (Python):
A , B = input().split(" ")
num1 = int(A)
num2 = int(B)
def gcd(num1,num2):
    if num1%num2 == 0:
        
        return num2
    else:
        
        return gcd(num2,num1%num2)
lcm = (num1*num2)//gcd(num1,num2)
print(lcm)

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

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

Solution (Python):
import fractions

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

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

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

Solution (Python):
import fractions
nums=[int(i) for i in input().split()]
print(nums[0]*nums[1]//fractions.gcd(nums[0],nums[1]))

Solution (Python):
import sys

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

while True:
    if number[0] > number[1]:
        number[1] += b
    elif number[0] < number[1]:
        number[0] += a
    else:
        print(number[0])
        break

Solution (Python):
from fractions import gcd
A, B = map(int, input().split())
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):
w, x = input().split(" ")
a = int(w)
b = int(x)

x = a
y = b
while(y):
    x, y = y, x % y

print((a*b)//x)

Solution (Python):
N,M = map(int,input().split())
n,m=N,M
if n<m:
    t=n;n=m;m=t
while n%m:
    t=n%m;n=m;m=t
print(int(N*M/m))

Solution (Python):
w, x = input().split(" ")
a = int(w)
b = int(x)

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

def compute_lcm(x, y):
   lcm = (x*y)//compute_gcd(x,y)
   return lcm

print(compute_lcm(a, b))

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

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

print(ans)

Solution (Python):
def gcd(A, B):
    if B > A: 
        A, B = B, A

    if B == 0:
        return A
    else:
        return gcd(B, A%B)


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

gcdAB = gcd(A, B)

print '{}'.format(A*B/gcdAB)

Solution (Python):
def main():

    a, b = map(int, input().split())
    for k in range(1, b + 1):
        if a * k % b == 0:
            print(a * k)
            break
        else:
            continue

if __name__ == "__main__":
    main()

Solution (Python):
import fractions

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

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

Solution (Python):
import fractions

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

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

print(lcm)

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


if (a < b):
    tmp = a
    a = b
    b = tmp

x = a * b 

r = a % b
while (r != 0):
    a = b
    b = r
    r = a%b

print(int(x/b))

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

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

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

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

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

tmp = gcd(max(a,b),min(a,b))

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

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 sys
sys.setrecursionlimit(10**8)

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

def gcd(a, b):
    if a > b:
        a, b = b, a
    if a == 0:
        return b
    return gcd(b%a, 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(int(a*b/fractions.gcd(a,b)))

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

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

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

Solution (Python):
import fractions

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

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

print(ans)

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

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

Solution (Python):


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

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

if a<b:
    tmp=a
    a=b
    b=tmp

ans=int(a*b/saidaikouyakusu(a,b))

print(ans)

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

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

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

list_a = factorization(A)
list_b = factorization(B)

temp_list = []
double_list = []
for i in range(len(list_a)):
    for j in range(len(list_b)):
        if list_a[i][0] == list_b[j][0]:
            temp_list = []
            index = None
            index = min(list_a[i][1], list_b[j][1])
            temp_list = [list_a[i][0], index]
            double_list.append(temp_list)
        else:
            pass

devision_num = 1
if double_list==[]:
    devision_num = 1
else:
    for i in range(len(double_list)):
        devision_num *= double_list[i][0]**double_list[i][1]

num_answer = None
a = 1
b = 1

for i in range(len(list_a)):
    a *= list_a[i][0]**list_a[i][1]

for j in range(len(list_b)):
    b *= list_b[j][0]**list_b[j][1]

num_answer = a*b//devision_num
print(num_answer)

Solution (Python):
alpha, beta = [int(i) for i in input().split(" ")]
a = max(alpha, beta)
b = min(alpha, beta)
x = a * b
r = a % b

while r != 0:
  a = b
  b = r
  r = a % b

print(int(x/b))

Solution (Python):
inp = input()
a = int(inp.split(" ")[0])
b = int(inp.split(" ")[1])

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

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

print(lcm(a,b))

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

print(ans)

Solution (Python):
A = [int(e) for e in input().split()]
tmp = A[0]
while 1: 
  if A[0]%A[1]==0:
    print(A[0])
    break
  else:
    A[0]+=tmp

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

Solution (Python):
import fractions

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

line = input()
arr =  [int(n) for n in line.split(' ')]

print(lcm(*arr))

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

from fractions import gcd

gcd_AB = gcd(A, B)
a = A // gcd_AB
b = B // gcd_AB

print(a*b*gcd_AB)

Solution (Python):
A = list(map(int, input().split()))
a = A[0]
b = A[1]
 
def gcd(a,b):
  while b!=0:
    a,b=b,a%b
  return a
 
ans = a*b/gcd(a,b)
ans = int(ans)
print(ans)

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

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

tmp = input().split(" ")
print(lcm(int(tmp[0]),int(tmp[1])))

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 fractions

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

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

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

Solution (Python):

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

import fractions

gcd=fractions.gcd(a,b)

ans=a*b/gcd

print(int(ans))

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


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

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

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

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

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

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

import sys
input = sys.stdin.readline
A, B = map(int, input().split())
print(lcm(A, B))

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

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

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

Solution (Python):
def lcm(a,b):
  lar = max(a, b) 
  small = min(a, b) 
  i = lar 
  while(1) : 
    if (i % small == 0): 
      return i 
    i += lar 

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

Solution (Python):
a=list(map(int,input().split()))
def cud(a,b):
  if a%b==0:
    return b
  else:
    return cud(b,a%b)
print(int(a[0]*a[1]/cud(a[0],a[1])))

Solution (Python):
def yukurid(a,b):
    if a>b:
        a,b = b,a
    while b%a != 0:
        a,b = b%a,a
    return int(a)

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

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

def gcd(a,b):
    while b!=0:
        a,b=b,a%b
    return a
print(int(A*B/gcd(A,B)))