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

def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')






from fractions import gcd

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

def solve():
    a, b = MI()
    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):





def gcd(a, b):
    """最大公約数"""
    a, b = (a, b) if a >= b else (b, a)
    if b == 0:
        return a
    return gcd(b, a % b)


def lcm(a, b):
    """最小公倍数"""
    
    return (a * b) // gcd(a, b)






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


if __name__ == '__main__':
    A, B = map(int, input().split())
    solve(A, B)

Solution (Python):


from sys import stdin
import fractions

a, b=map(int, stdin.readline().strip().split())
f=fractions.gcd(a,b)
f2=a*b//f

print(f2)

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())
GCD=1
for i in range(2,10**5+1):
    if A%i==0 and B%i==0:
        GCD=i

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

Solution (Python):

"""
C - Snack
https://atcoder.jp/contests/abc148/tasks/abc148_c

"""
import sys


from fractions import gcd

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


def main(args):
    A, B = map(int, input().split())
    ans = solve(A, B)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

Solution (Python):
import fractions

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

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

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

max_num = max(int(A),int(B))
min_num = min(int(A),int(B))
i = 0
flag = False

while flag == False:
    i += 1
    if (max_num*i)% min_num == 0:
        print(max_num*i)
        flag = True

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

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

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

Solution (Python):
import fractions

A,B = (int(a) for a in 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(int((a*b)/c))

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

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

Solution (Python):

def lcm(x, y):
    from fractions import gcd
    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())

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

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

    if a > b:
        tmp = a
        a = b
        b = tmp

    b0 = b
    a0 = a
    while b % a != 0:
        c = b % a
        b = a
        a = c

    print(int(b0 * a0 / a))


if __name__ == '__main__':
    q_c()

Solution (Python):
import fractions as math
input_line = list(map(int,input().split(' ')))

ans = input_line[0] * input_line[1] // math.gcd(input_line[0], input_line[1])
print(ans)

Solution (Python):
a,b=map(int,input().split())
m=min(a,b)
kouyakusuu=1
for i in range(1,m+1):
    if a%i==0 and b%i==0:
        kouyakusuu=i
print(a*b//kouyakusuu)

Solution (Python):
import fractions


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

Solution (Python):
import math
import numpy as np
A,B = np.array(input().split(),dtype = int)

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

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

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

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

Solution (Python):
ma = lambda :map(int,input().split())
ni = lambda:int(input())
import collections
import math
import itertools
import fractions
gcd = fractions.gcd
a,b = ma()
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):
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9
import fractions

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

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


if __name__ == '__main__':
    main()

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

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

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

def lcm2(x,y):
    return x // gcd2(x,y) * y

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

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

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

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

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())
ma,mi=0,0
ma=max(A,B)
mi=min(A,B)

if A%B==0 or B%A==0:
    print(ma)

else :
    for i in range(2,ma+1):
        if (ma*i)%mi==0:
            print(ma*i)
            break
        i+=(mi-1)

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

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

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

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

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

Solution (Python):
import fractions

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

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

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

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

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

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

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

Solution (Python):
def resolve():
    A, B = map(int, input().split())
    ans = []
    for i in range(1, min(A, B)+1):
        if A%i == 0 and B%i == 0:
            ans.append(i)
    print(A*B//ans[-1])
resolve()

Solution (Python):
from sys import stdin

input=stdin.readline


def gcd(a, b):
  dekai = max(a, b)
  tiisai = min(a, b)
  
  div = dekai % tiisai
  next_dived=tiisai
  
  
  while (div != 0):
    tmp=div
    div = next_dived % div
    next_dived=tmp

  return next_dived

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



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

Solution (Python):
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)

from math import factorial
import heapq, bisect
import math
import itertools
import queue
from collections import deque
from fractions import Fraction


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

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

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 sys
A, B = map(int, input().split())
A_, B_ = A, B
counta, countb = 1, 1
while True:
    if A == B:
        print(A)
        sys.exit()
    elif A > B:
        countb += 1
        B = B_ * countb
    elif B > A:
        counta += 1
        A = A_ * counta

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

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

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

print(lcm(a, b))

Solution (Python):
import fractions

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

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

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

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

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

Solution (Python):
from fractions import gcd

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

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

print(lcm(a, b))

Solution (Python):
from fractions import gcd

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

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

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

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

def lcm_(x,y):
    return (x * y) // gcd_(x, y)

print(lcm_(A, B))

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

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

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

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

print(ans)

Solution (Python):
import fractions

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

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

Solution (Python):
import fractions

def is_lcm(X, Y):
    return X*Y // fractions.gcd(X, Y)

N, M = map(int, input().split())

print(is_lcm(N, M))

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

tmp_A, tmp_B = max(A,B), min(A,B)

while 1:
  if tmp_A % tmp_B != 0:
    tmp = tmp_B
    tmp_B = tmp_A%tmp_B
    tmp_A = tmp
  else:
    if tmp_B == 1:
      result = A*B
      break
    else:
      result = int(A*B/tmp_B)
      break
print(result)

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

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

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


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


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


a, b = map(int, readline().split())
print(lcm(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(l,s):
    r = l%s
    if r == 0:
        return s
    else:
        return gcd(s,r)

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

print(lcm(a,b))

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

large = A if A > B else B
small = A if A < B else B

def gcd(large, small):
    r = large % small
    while r != 0:
        large = small
        small = r
        r = large % small
    return small

print(large*small//gcd(large, small))

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

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

l = 0
if A > B: 
    l = A
    s = B
else:
    l = B
    s = A

for i in range(1,10**10):
    if (l*i)%s == 0:
        print(l*i)
        exit()
    else:
        continue

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


def BIG_SMALL(A, B):
    if A % B == 0:
        print(A)
    else:
        print(A*B//gcd(A,B))


if A > B:
    BIG_SMALL(A, B)
elif A < B:
    BIG_SMALL(B, A)
else:
    print(A)

Solution (Python):
from fractions import gcd


def func(A, B):
    ans = (A * B) // gcd(A, B)
    return ans


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

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

Solution (Python):

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

Solution (Python):
import fractions

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

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

print(lcm(A,B))

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

def lcm(x, y):
    return (x*y)//gcd(x,y)
    
tmp = lcm(a, b)
print(tmp)

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

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

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

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

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

Solution (Python):
def find_lcm(a, b):
    """lcm = least common multiple
    """
    large_num = max(a, b)
    small_num = min(a, b)

    count = 1
    while True:
        
        if large_num * count % small_num == 0:
            break
        count += 1
    
    return large_num * count

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

Solution (Python):
def gcd(a, b):
    if a<b:
        a,b = b,a
    r = a%b
    while r != 0:
        a = b
        b = r
        r = a % b
    return b
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(str((A * B) // gcd(A, B)))

Solution (Python):
import fractions

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

print(str(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
import sys
sys.setrecursionlimit(10**7)
a,b = map(int,input().split())
def lcm(x, y):
    return (x * y) // gcd(x, y)
if b != 0:
    print(lcm(a, b))
else:
    print(a)

Solution (Python):
from fractions import gcd

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

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

Solution (Python):
import fractions

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

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

Solution (Python):
import fractions

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

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

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

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

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

Solution (Python):
def gcd(a, b):
    for i in range(min(a, b), 0, -1):
        if a%i == 0 and b%i == 0:
            return i


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

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

Solution (Python):
import fractions

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

result = fractions.gcd(a, b)

print((a * b) // result)

Solution (Python):

import sys
import fractions

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


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


if __name__ == '__main__':
    main()

Solution (Python):


import sys

import fractions as math

def input():
    return sys.stdin.readline().rstrip('\n')


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

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

Solution (Python):
import fractions as math

def main():
    x, y = map(int, input().split())
    print(x*y // math.gcd(x,y))

if __name__ == '__main__':
    main()

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

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

Solution (Python):
def gcd(a,b):
	return gcd(b, a% b) if b else a
a,b = map(int,raw_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):
import fractions
a,b=map(int,input().split())
g=fractions.gcd(a, b)
l=int(a*b/g)
print(l)

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

Solution (Python):
A=list(map(int,input().split()))
x=max(A)
n=min(A)
while(n!=0):
    x,n=n,x%n
print(int(max(A)*min(A)/x))

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

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

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

Solution (Python):
a,b=[int(x) for x 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())
g = gcd(a, b)
print((a*b)//g)

Solution (Python):
import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))



A,B=nm()

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

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

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

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

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

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

while True:
    if a_tmp == b_tmp:
        print(a_tmp)
        exit(0)
    elif a_tmp > b_tmp:
        b_tmp = B*b_cnt
        b_cnt += 1
    else:
        a_tmp = A*a_cnt
        a_cnt += 1

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

Solution (Python):
from fractions import gcd

n, m = map(int, input().split())

print(n * m // gcd(n, m))

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

from fractions import gcd

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

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

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

Solution (Python):
A, B = map(int,input().split())
def gcd(a,b):
    if b == 0:
        return a
    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

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

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

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

def resolve():
    a,b=map(int, input().split())
    import fractions


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

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

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

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

print(lcm_base(a, b))

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

Solution (Python):
def gcd(_a, _b):
	if _a%_b==0:return _b
	else:return gcd(_b, _a%_b)

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

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

Solution (Python):
import fractions

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

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

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

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

Solution (Python):
import sys
import fractions

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

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

c = a
d = b
r = c // d
m = c % d

while True:
    if m == 0:
        break
    else:
        c = d
        d = m
        m = c % d

print(int(a * b / d))

Solution (Python):
A,B = map(int,input().split())
Flag = True
i = max(A,B)
s = max(A,B)
while Flag == True and i <= A*B:
  if i%A ==0 and i%B == 0:
    Flag = False
  i += s
print(i-s)

Solution (Python):
A, B = map(int, input().split())
n = 1
while True:
  A_ = A * n
  if A_ % B == 0:
    print(A_)
    exit()
  n += 1

Solution (Python):
from fractions import gcd


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


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

print(lcm(A, B))

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

Solution (Python):
from fractions import gcd

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

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

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

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

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

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

print(int(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())
print(lcm(A,B))

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

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

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
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()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

Solution (Python):
import sys
import os
import math
import bisect
import collections
import itertools
import heapq
import re
import queue
import fractions

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]


lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

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


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

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


if __name__ == '__main__':
    main()

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

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

print(lcm(p, q))