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


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

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

Solution (Python):
def calc_gcd(a, b):
    if a < b:
        s, l = [a, b]
    else:
        s, l = [b, a]
    
    while True:
        r = l % s
        if r == 0:
            return s
        l = s
        s = r

def calc_lcm(a, b):
    gcd = calc_gcd(a, b)
    return (a // gcd) * (b // gcd) * gcd

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

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

ans = lcm(A, B)

print(ans)

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

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

Solution (Python):

A,B = map(int,input().split())
def gcd(x,y):
    M = max(x,y)
    m = min(x,y)
    m2 = M%m
    if m2 == 0:
        return m
    else:
        return gcd(m2,m)
        
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

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

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

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

if __name__ == '__main__':
    solve()

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

Solution (Python):
a,b=map(int, input().split())
c=a
d=b
while c!=d:
  if c>d:
    d+=b
  else:
    c+=a
print(c)

Solution (Python):
from fractions import gcd


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


if __name__ == '__main__':
    solve()

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:
        a, b = b, a % b
    return a

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

print(lcm(a,b))

Solution (Python):

import sys
from fractions import gcd
from string import ascii_uppercase as ABC

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

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

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


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


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

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

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

Solution (Python):

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

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


def main():

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

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

    return 0

if __name__ == "__main__":
    solve()

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

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

Solution (Python):
import fractions

def main():
    buf = input()
    buflist = buf.split()
    a = int(buflist[0])
    b = int(buflist[1])

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

    print(ans)

if __name__ == '__main__':
    main()

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

Solution (Python):
def gcd(m, n):
    while n:
        m, n = n, m % n
    return m


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

print(A*B//g)

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

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

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

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


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

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


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


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


print(lcm(A, B))

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

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

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

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

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

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

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

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

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

Solution (Python):
def main():
    A, B = (int(i) for i in input().split())

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

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


if __name__ == '__main__':
    main()

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

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

print(ans)

Solution (Python):
import copy
import heapq
import math
import fractions

def j(n):
    if n:print("Yes")
    else:print("No")
    exit(0)
rem = 10 ** 9 + 7

"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def iprow():
    return [int(i) for i in input().split()]
def ips():
    return (int(i) for i in input().split())
def ipmultiplerow(n):
    a = []
    for i in range(n):
        a.append(ip())
    return a
def printrow(a):
    for i in a:
        print(i)


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

x,y = ips()
print(lcm(x,y))

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

Solution (Python):


import fractions


def main():
    a, b = (int(z) for z in input().split())
    x = a // fractions.gcd(a, b) * b
    print(x)


if __name__ == "__main__":
    main()

Solution (Python):
def gcd(a,b):
    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):
from fractions import gcd

S, T = map(int, input().split())

print(S * T // gcd(S, T))

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):
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):
A, B = map(int, input().split())
mi = min(A,B)
ma = max(A,B)
i = 1

while True:
    num = ma * i
    if num % mi == 0:
        break
    else:
        i += 1

print(num)

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

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

Solution (Python):
from fractions import gcd

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

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

Solution (Python):
from functools import reduce
from fractions import gcd
def lcm(x,y):return x*y//gcd(x,y)
def lcmm(l):return reduce(lcm,l)
A, B = map(int,input().split())
List=[A, B]
print(lcmm(List))

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

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

from fractions import gcd
ans = (x * y) // gcd(x, y)
print(ans)

Solution (Python):
import sys
a, b = [int(i) for i in sys.stdin.readline().split()]

def gcd(a, b):
    while a and b:
        if a > b:
            a %= b
        else:
            b %= a
    return max(a, b)

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

from fractions import gcd

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

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

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


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


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

Solution (Python):
import fractions

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

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

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

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

import fractions
from functools import reduce
def gcd(*numbers):
    return reduce(fractions.gcd, numbers)

def gcd_list(numbers):
    return reduce(fractions.gcd, numbers)
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)

a,b = m()

print(lcm(a,b))

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 fractions

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


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


print(lcm(a, b))

Solution (Python):
def inpl():
    return list(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)


A, B = inpl()

print(lcm(max(A, B), min(A, B)))

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

Solution (Python):
def gcd(p, q):
    if p < q:
        p, q = q, p
    while q > 0:
        p, q = q, p%q
    return p

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

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

Solution (Python):
import fractions
n,m=[int(s) for s in input().split()]
print(n*m//fractions.gcd(n,m))

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

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

def main():
    a,b=MI()
    print(a*b//gcd(a,b))

main()

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

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

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

Solution (Python):
import sys
import fractions
sys.setrecursionlimit(10**9)
INF=10**18
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())
import fractions
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
print(lcm(a, b))

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict
from fractions import gcd

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


def main():
	A, B = getlist()
	GCD = gcd(A, B)
	ans = int(A * B // GCD)
	print(ans)


if __name__ == '__main__':
	main()

Solution (Python):
import sys
input=sys.stdin.readline
a,b=map(int,input().split())
def gcd(a,b):
  while b:
    a,b=b,a%b
  return a
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):
a, b = map(int, input().split())

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

def lcm(a, b):
    g = gcd(a, b)
    g_a = a // g
    g_b = b // g
    return g_a * g_b * g

print(lcm(a, b))

Solution (Python):

import sys
input = sys.stdin.readline

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
from fractions import gcd

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(A, B):
    c = gcd(A, B)
    ans = (A * B) // c
    return ans


def main():
    A, B = read_int_n()
    print(slv(A, B))


if __name__ == '__main__':
    main()

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

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

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

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

print(lcm(A, B))

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

import fractions

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

Solution (Python):
from fractions import gcd

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

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

Solution (Python):
import sys
from fractions import gcd
input = sys.stdin.readline
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):
	while b:
		a, b = b, a % b
	return a
print(a*b//gcd(a,b))

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

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

Solution (Python):
from fractions import gcd

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

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

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

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

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

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

G = gcd(A,B)

print(A*B//G)

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

Solution (Python):
def gcd(a, b):
    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 math

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]





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



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

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce


sys.setrecursionlimit(2147483647)
INF = 1 << 100
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007


def gcd(i, j):
    while j:
        i, j = j, i % j
    return i


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

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

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

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):
def main():

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

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

    g = gcd(a, b)
    return a * b // g



if __name__ == '__main__':
    print(main())

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

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

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 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):
a,b = map(int, input().split())
def gcd(n, m):
    
    a = max(n,m)
    b = min(n,m)
    while b:
        a, b = b, a % b
    return a

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

Solution (Python):

try:
    from fractions import gcd
except:
    from math import gcd
A, B = map(int, input().split())
print(int(A * B / gcd(A, B)))

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


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


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

print(lcm(a,b))

Solution (Python):

import sys
input = sys.stdin.readline
import fractions

a, b = [int(item) for item in input().split()]
lcm = a * b // fractions.gcd(a, b)
print(lcm)

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

Solution (Python):
import sys

input = sys.stdin.readline

ri = lambda: int(input())
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]


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


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


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

Solution (Python):
from fractions import gcd

a,b = map(int, input().split())
g = gcd(a,b)
ans = a*b//g
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 sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
from fractions import gcd
def resolve():
    a,b=map(int,input().split())
    print(a*b//gcd(a,b))
resolve()

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


main()

Solution (Python):

S,T=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(S,T))

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
INF = float("inf")


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


def LCM(a, b):
    return a*b//GCD(a, b)


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

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

def gcd(x, y):
  b = max(x, y)
  s = min(x, y)
  r = b % s
  while r != 0:
    b = s
    s = r
    r = b % s
  return s

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


print(lcm(A, B))

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

def lcm_core(a,b):
    g = gcd_core(a,b)
    return (a*b)//g


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

Solution (Python):

import sys
import fractions
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
write = sys.stdout.write
def ii(): return int(readline())
def mi(): return map(int, readline().rstrip().split())
def li(): return list(readline().rstrip())
def lmi(): return list(map(int, readline().rstrip().split()))
def end(*arg): print(*arg); sys.exit()



def main():
    A, B = mi()
    print(A * B // fractions.gcd(A, B))
    return


if __name__ == '__main__':
    main()

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()


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



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


def main():
  a,b=LI()

  return int(lcm(a,b))


print(main())

Solution (Python):
import fractions

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

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

Solution (Python):
a,b=[int(j) for j in input().split()]
def gcd(x,y):
    if y==0:
        return x
    else:
        return gcd(y,x%y)


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

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,hypot,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    A,B=MI()
    print(A*B//gcd(A,B))
if __name__ == '__main__':
    main()

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

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