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

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

from  fractions import gcd
C = gcd(A,B)
print(int(A*B/C))

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

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

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

















mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def main():
    a,b = readInts()
    from fractions import gcd
    ans = a // gcd(a,b) * b
    print(ans)
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(lcm(a, b))

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

def gcd(p, q):
    if q < p:
        p, q = q, p
    if q % p == 0:
        return p
    else:
        return (gcd(p, q-(q//p)*p))

print(int(a * b / gcd(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(p,q):
  if p%q == 0:
    return q
  return gcd(q,p%q)

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

Solution (Python):
from fractions import gcd

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

Solution (Python):
num = [int(i) for i in input().split()]
A = max(num)
B = min(num)

X = A*B
num = 0
while X >= num:
  num += B
  if 0 == num % A:
    print(num)
    break
  elif X == num:
    print(num)

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

Solution (Python):
import sys
from bisect import bisect_right as bsr
from collections import Counter as cnt
from collections import defaultdict as dd
from collections import deque
from fractions import gcd
from itertools import permutations as perm
from math import ceil, factorial, floor
from operator import itemgetter as ig

sys.setrecursionlimit(1000000)


args = None
INF = float("inf")
MOD = int(1e9 + 7)


def input(*ps):
    if type(ps[0]) is list:
        return [input(*ps[0][:-1]) for _ in range(ps[0][-1])]
    elif len(ps) == 1:
        return ps[0](next(args))
    else:
        return [p(next(args)) for p in ps]


def yesno(v, yes="Yes", no="No", upper=False):
    if upper:
        print([yes.upper(), no.upper()][not v])
    else:
        print([yes, no][not v])


def lcm(v1, v2):
    """最大公約数 / 最小公倍数"""
    return (v1 // gcd(v1, v2)) * v2


def main():
    """エントリーポイント"""
    A, B = input(int, int)
    print(lcm(A, B))


if __name__ == '__main__':
    args = iter(sys.stdin.read().split())
    main()

Solution (Python):
from fractions import gcd

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

ans = a * b // gcd(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

A,B=[int(x) for x in input().rstrip().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())
okashi = 1
max = 10**9
for i in range(0,max):
  if(a * okashi) % b == 0:
      break
  else:
    okashi +=1
print(a*okashi)

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

Solution (Python):
n,m = map(int,input().split())

for a in range(1,m+1):
    if (n*a)%m==0:
        print(n*a)
        exit()

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

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 math import floor,ceil,sqrt,factorial,log
import fractions
from collections import Counter, deque
from functools import reduce
import numpy as np
def S(): return input()
def I(): return int(input())
def MS(): return map(str,input().split())
def MI(): return map(int,input().split())
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in input()]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]

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

a, b = MI()

print(lcm(a,b))

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

Solution (Python):
def q3():
    def lcm(x, y):
        """ xとyの最小公倍数を求める """
        
        import fractions
        return (x * y) // fractions.gcd(x, y)

    A, B = (int(i) for i in input().split())
    print(lcm(A, B))


if __name__ == '__main__':
    q3()

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

Solution (Python):
import sys

def gcd(a, b): return gcd(b, a % b) if b else abs(a)
def lcm(a, b): return abs(a // gcd(a, b) * b)

a, b = map(int, sys.stdin.readline().split())

def main():
    print(lcm(a, b))

if __name__ ==  '__main__':
    main()

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):
def yu(x, y):
    min_v = min(x, y)
    max_v = max(x, y)

    mod = max_v % min_v
    if mod != 0:
        min_v = yu(min_v, mod)
    return min_v


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

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

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

if a < b:
  a, b = b, a
while a % b != 0:
  a, b = b, a%b
  
print(int(c*d/b))

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

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










mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def main():
    from fractions import gcd
    a,b =readInts()
    g = gcd(a,b)
    print(a // g * b)
if __name__ == '__main__':
  main()

Solution (Python):
from fractions import gcd


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


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

Solution (Python):

import io
import math

import fractions
nim, mike = list(map(int, input().split()))
print(nim * mike // fractions.gcd(nim, mike))

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

Solution (Python):
from fractions import gcd

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

Solution (Python):
import sys
import fractions

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

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

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

Solution (Python):
import fractions
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

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

resolve()

Solution (Python):


import sys
import math






from itertools import count, cycle, repeat     
from itertools import groupby                  
from itertools import starmap                  








def main():
    mod = 1000000007                  
    inf = float('inf')
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():  return int(input())
    def mi():  return map(int, input().split())
    def mi_0(): return map(lambda x: int(x)-1, input().split())
    def lmi(): return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():  return list(input())
    
    
    from fractions import gcd
    a, b = mi()
    
    g = gcd(a, b)
    print(a * b // g)

if __name__ == "__main__":
    main()

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

Solution (Python):
from fractions import gcd
l = list(map(int,input().split()))
x = l[0]
y = l[1]
print((x * y) // gcd(x, y))

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

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

Solution (Python):
A,B=map(int,input().split())
i=1
while (A*i)%B!=0:
    i += 1
print(A*i)

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

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

if B>A:
    C = A
    A = B
    B = C

while B != 0:
    a = A
    b = B
    A = B
    B = a%b
    
print(int(seki/A))

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

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

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

for i in range(1,B+1):
    if A*i % B == 0:
        print(A*i)
        break

Solution (Python):
import math
import fractions

def input1():
	return int(input())


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


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




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


a,b=input2()

print(lcm(a,b))

Solution (Python):
import sys
sys.setrecursionlimit(20000000)
def gcd(m, n):
    r = m % n
    return gcd(n, r) if r else n

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

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

A, B = MAP()
C = gcd(A, B)
print(A*B//C)

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

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

multiply = 1
while True:
    if A * multiply % B  == 0:
        break
    multiply += 1

answer = A * multiply

print(answer)

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

x, y = map(int, input().split())
print(x*y //GCD(x,y))

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

def euclid(num1,num2):
  if num1<num2: num1,num2 = num2,num1
  while num2>0:
    r = num1%num2
    num1 = num2
    num2 = r
  return num1

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

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

Solution (Python):
a,b=map(int,input().split())
A=a
B=b
while b%a>0:
  e=a
  a=b%a
  b=e

A=A//a
B=B//a
print(str(int(A*B*a)))

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())
if A>B:
    x,y=A,B
else:
    x,y=B,A
i=1
while x*i%y!=0:
    i+=1
print(x*i)

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

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

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

Solution (Python):
from fractions import gcd

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

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

Solution (Python):

import sys
import numpy as np
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):
import fractions
a,b =map(int ,input().split())
def lcm(A,B):
    y =A*B /fractions.gcd(A,B)
    return int(y)
print(lcm(a,b))

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

Solution (Python):
import fractions

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

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

print(lcm(A,B))

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

def gcd(a,b):
    num=[a,b]
    GCD=0
    for i in range(1,min(num)+1):
        if a%i==0 and b%i==0:
            GCD=i
    return GCD
            
print(int(A*B/gcd(A,B)))

Solution (Python):
def gcd(a,b):
    if a==0 or b==0:
        return max([a,b])
    else:
        if a>=b:
            n=int(a/b)
            return gcd(a-n*b,b)
        else:
            n=int(b/a)
            return gcd(a,b-n*a)

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

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
import fractions
def lcm(a,b):
    f=a*b//fractions.gcd(a,b)
    return f
def main():
    a,b=map(int,input().split())
    print(lcm(a,b))

if __name__=='__main__':
    main()

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
import fractions
def lcm(a,b):
    f=a*b//fractions.gcd(a,b)
    return f
def main():
    a,b=map(int,input().split())
    print(lcm(a,b))

if __name__=='__main__':
    main()

Solution (Python):
import sys
import fractions
def input(): return sys.stdin.readline().rstrip()
def main():
    a,b=map(int,input().split())
    f=fractions.gcd(a,b)
    f2=a*b//f
    print(f2)

if __name__=='__main__':
    main()

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

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

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

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

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

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

print(ans)

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

for i in range(1,10**5):
  if (A*i)%B==0:
    print(A*i)
    break

Solution (Python):
A, B = map(int, input().split())
num = max(A, B)
while True:
  if A % num == 0 and B % num == 0:
    break
  else:
    num = num - 1
  if num == 1:
    break
print(int(min(A, B) * max(A, B)/num))

Solution (Python):
A, B = map(int, input().split())
if A > B:
  tmp = A
  A = B
  B = tmp
_A = A
num = 2
while True:
  if A % num == 0:
    A = A / num
    if B % num == 0:
      B = B / num
  else:
    num = num + 1
    
  if A == 1:
    break
print(int(_A * B))

Solution (Python):
num1, num2 = map(int, input().split())

import math
def gcd(num1, num2):
  for i in range(min(num1, num2),0,-1):
    if num1%i==0 and num2%i==0:
      return i
    
print(int(num1*num2/gcd(num1,num2)))

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

Solution (Python):
import math

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

c=0

while(1):
  c+=a
  if c%b==0:
    print(c)
    break

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

Solution (Python):

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

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

i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()

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

print(lcm(A,B))

Solution (Python):
A, B = map(int, input().split())
a = A
b = B
while a * b:
    if a > b:
        a = a % b
    else:
        b = b % a
print(A * B // (a + b))

Solution (Python):
def gcd(a, b):
    while True:
        a, b = b, a%b
        if b==0:
            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 sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

from fractions import gcd

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

Solution (Python):
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') 
def gcd(a,b):return fractions.gcd(a,b) 
def lcm(a,b):return (a*b) // fractions.gcd(a,b) 
def iin(): return int(sys.stdin.readline()) 
def ifn(): return float(sys.stdin.readline()) 
def isn(): return sys.stdin.readline().split() 
def imn(): return map(int, sys.stdin.readline().split()) 
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) 
def fmn(): return map(float, sys.stdin.readline().split()) 
def iln(): return list(map(int, sys.stdin.readline().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, sys.stdin.readline().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD
def print_list(l): print(*l, sep='\n')
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def No(): print('No')

def sieves_of_e(n):
    is_prime = [True] * (n+1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i * 2, n+1, i): is_prime[j] = False
    return is_prime


def prime_factorize(n):
    res = []
    for i in range(2, int(n**0.5)+1):
        if n % i != 0: continue
        ex = 0

        while (n % i == 0):
            ex += 1
            n //= i
        res.append((i, ex))
    if n != 1: res.append((n, 1))
    return res

A,B = imn()

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

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

Solution (Python):

A,B = (int(x) for x in input().split(" "))


from functools import reduce
import fractions 
def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y) 
def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)
def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

saisyou_koubaisu = lcm(A,B)

print(saisyou_koubaisu)

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

Solution (Python):
def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a

def main():
    A, B = map(int, input().split())
    XA = prime_factorize(A)
    XB = prime_factorize(B)
    sum = 1
    for i in XA:
        if i in XB:
            XB.remove(i)
        sum *= i

    for j in XB:
        sum *= j

    print(sum)

main()

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

if a < b:
  a, b = b, a

p = a
q = b

while True:
  r = a % b
  a, b = b, r
  if r == 0:
    break
    
print(p*q//a)

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

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

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(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):
  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 sys
from fractions import gcd


def solve(A: int, B: int):
    print(A*B//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):
import fractions

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

print(a*b//c)

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):
import sys
input = sys.stdin.readline
from collections import Counter, deque

INF = float('inf')


def gcd(a, b):
    """
    Greatest Common Divisor
    Euclidean Algortihm
    """
    if a < b:
        gcd(b, a)
    while b != 0:
        a, b = b, a % b
    return a


def lcm(a, b):
    """
    Least Common Multiple
    """
    return a * b // gcd(a, b)


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


if __name__ == '__main__':
    main()

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

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

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

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


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


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

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

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

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())
def fcd(a , b):
    if a>= b:
        while b != 0:
            a,b = b,a%b
        return a
    
    else:
        while a != 0:
            b,a = a,b%a
        return b
    
    
def lcm(a,b):
    return a*b//fcd(a , b)


print(lcm(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):
A,B = map(int, input().split())
i=1
C=max(A,B)
while C*i%min(A,B) != 0:
    i+=1
print(C*i)

Solution (Python):





from fractions import gcd

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

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):
from fractions import gcd
a, b = [int(i) for i in 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 (int((a*b)/gcd(a,b)))

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

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

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

import fractions

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

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

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


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

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):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby
    
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    mod = 10**9 + 7

    a,b = map(int, input().split())
    def gcd(a, b):
        if b == 0:
            return a
        else:
            return gcd(b, a % b)
    
    def gcd_group(arr):
        g = gcd(arr[0], arr[1])
        for i in range(2, len(arr)):
            g = gcd(g, arr[i])
        return g
    
    def lcm(a, b):
        g = gcd(a, b)
        return (a*b)//g
    
    def lcm_group(arr):
        l = lcm(arr[0], arr[1])
        for i in range(2, len(arr)):
            l = lcm(l, arr[i])
        return l
    
    print(lcm(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())

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

Solution (Python):



import fractions

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

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

if __name__ == '__main__':
    main()