Problem:
 Score : 300 points    Problem Statement  Takahashi is organizing a party.  At the party, each guest will receive one or more snack pieces.  Takahashi predicts that the number of guests at this party will be A or B .  Find the minimum number of pieces that can be evenly distributed to the guests in both of the cases predicted.  We assume that a piece cannot be divided and distributed to multiple guests.      Constraints   1 \leq A, B \leq 10^5  A \neq B  All values in input are integers.         Input  Input is given from Standard Input in the following format:  A  B       Output  Print the minimum number of pieces that can be evenly distributed to the guests in both of the cases with A guests and B guests.        Sample Input 1 2 3      Sample Output 1 6  When we have six snack pieces, each guest can take three pieces if we have two guests, and each guest can take two if we have three guests.       Sample Input 2 123 456      Sample Output 2 18696       Sample Input 3 100000 99999      Sample Output 3 9999900000

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

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

print(lcm(A,B))

Solution (Python):
import fractions

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

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

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

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

A,B=list(map(int,input().split()))
print(lcm_list([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())
gcd_ = fractions.gcd(A, B)
res = (A * B) / gcd_
print(int(res))

Solution (Python):

import sys
import time
import unittest
from io import StringIO
import fractions as math


def resolve():
    A, B = [int(i) for i in input().split()]
    print(int(A * B / math.gcd(A, B)))


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def setUp(self):
        self.startTime = time.time()

    def tearDown(self):
        t = time.time() - self.startTime
        print('%s: %.3f' % (self.id(), t), flush=True)

    def test_入力例_1(self):
        input = """2 3"""
        output = """6"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """123 456"""
        output = """18696"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """100000 99999"""
        output = """9999900000"""
        self.assertIO(input, output)


if __name__ == "__main__":
    if "IS_LOCAL" in locals():
        suite = unittest.TestLoader().loadTestsFromTestCase(TestClass)
        unittest.TextTestRunner(verbosity=0).run(suite)
    else:
        resolve()

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

if a>b:
    if a%b==0:
        gcd=b
    else:
        p=a
        q=b
        r=p%q
        while r!=0:
            p=q
            q=r
            r=p%q
            if r==0:
            	gcd=q
            	break
elif a<b:
    if b%a==0:
    	gcd=a
    else:
        p=b
        q=a
        r=p%q
        while r!=0:
            p=q
            q=r
            r=p%q
            if r==0:
            	gcd=q
            	break
A=a//gcd
B=b//gcd
print(A*B*gcd)

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

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

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

print(child//b)

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

import fractions

gcd = fractions.gcd(a, b)

print(int(a*b/gcd))

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

Solution (Python):
from sys import stdin, setrecursionlimit


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


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


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

Solution (Python):
import itertools
import math
import fractions
import functools

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

Solution (Python):
a,b=map(int,input().split())
i=min(a,b)
j=max(a,b)
while not(i==0) and not(j==0):
  x=i
  i=j%i
  j=x
print(int(a*b/j))

Solution (Python):
import fractions

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

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

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

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

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    from fractions import gcd

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

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


if __name__ == "__main__":
    main()

Solution (Python):
import fractions

A, B = map(int, input().split())
def lcm(a, b):
    g = fractions.gcd(a, b)
    L = a * b // g
    return L

print(lcm(A, B))

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


from fractions import gcd

f = gcd(a,b)
f2 = a*b//f

print(f2)

Solution (Python):
import fractions
n,m = map(int,input().split())
def lcb(n,m):
    return (n*m)//fractions.gcd(n,m)
    
print(lcb(n,m))

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

Solution (Python):
import sys


def input(): return sys.stdin.readline().strip()


import fractions


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

Solution (Python):

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


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

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

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

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

Solution (Python):

def gcd(a,b):
    ma = max(a,b)
    mi = min(a,b)
    while(True):
        los = ma % mi
        ma = mi
        mi = los
        if los == 0:
            result = ma
            break
    return result

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

Solution (Python):
def gcd(m, n):
    x = max(m, n)
    y = min(m, n)
    if x % y == 0:
        return y
    else:
        while x % y != 0:
            z = x % y
            x = y
            y = z
        return z


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



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


snack = lcm(A, B) 

print(snack)

Solution (Python):
def euclid(m, n):
    while n != 0:
        m, n = n, m % n
    return m



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

Solution (Python):

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

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

def gcd(s,t):
  if(s>=t):
    m = s
    n = t
  else:
    m = t
    n = s
  while True:
    if(m%n == 0):
      return n
    else:
      temp = n
      n = m % n
      m = temp

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

Solution (Python):
import sys
from functools import reduce
import copy
import math
from pprint import pprint
import collections
import bisect
import itertools
import heapq


sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def int_inputs(num_of_input):
    ins = [int(input()) for i in range(num_of_input)]
    return ins


def solve(input):
    nums = string_to_int(input)

    def euclid(large, small):
        if small == 0:
            return large
        l = large % small
        return euclid(small, l)

    nums.sort(reverse=True)
    eee = euclid(nums[0], nums[1])
    return int((nums[0] * nums[1]) / eee)


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    ret = solve(input())
    print(ret)

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

a,b =(int(i) for i in input().split())
print((a*b)//gcd(a,b))

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

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

Solution (Python):
import fractions
k = list(map(int, input().split()))

def lcm(k):
    ans = k[0]
    for i in range(1, len(k)):
        ans = ans * k[i] // fractions.gcd(ans, k[i])
    return ans
  
print(lcm(k))

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

"""
Created on Sat May  9 16:09:21 2020

@author: shinba
"""

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

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

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

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

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

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

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

from fractions import gcd

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

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

Solution (Python):


import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))

from fractions import gcd
def resolve():
    A,B=pin()
    print(A*B//(gcd(A,B)))

resolve()

Solution (Python):
def calcgcd(a, b):
  if a > b:
    a, b = b, a
  while a > 0:
    a, b = b%a, a
  return b
def calclcm(a, b):
  return a*b//calcgcd(a, b)

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

Solution (Python):
import math
import sys
input = sys.stdin.readline
a,b=map(int,input().split())
i=1
while True:
  if a*i % b == 0:
    print(a*i)
    break
  i+=1

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations, accumulate
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce
from fractions import gcd

import sys
def I(): return int(input())  
def Is(): return map(int, input().split())  
def LI(): return list(map(int, input().split()))  
def TI(): return tuple(map(int, input().split()))  
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()  
def LS(): return list(input())  
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(1000000)
MOD = 1000000007
INF = float('inf')

a, b = Is()
l = a * b / gcd(a, b)
print(int(l))

Solution (Python):
A, B = map(int,input().split())
for i in range(max(A,B),0,-1):
    if A%i==0 and B%i==0:
        print(A*B//i)
        break

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

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

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

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

Solution (Python):
def main():
    x, y = map(int, input().split())
    mul_xy = x * y
    while True:
        x, y = y, x % y
        if not y:
            break
    print(int(mul_xy / x))

if __name__ == '__main__':
    main()

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

Solution (Python):
from fractions import gcd

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

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

print(lcm(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


def lcm(A):
    value = A[0]
    for i in range(1, len(A)):
        value = value * A[i] // fractions.gcd(value, A[i])
    return value


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

print(lcm(A))

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

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

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

Solution (Python):
import fractions

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

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

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

Solution (Python):

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

Solution (Python):
import fractions


def main():
    n, m = list(map(int, input().split()))
    print((n * m) // fractions.gcd(n, m))


if __name__ == '__main__':
    main()

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


from fractions import gcd



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

print(lcm(a,b))

Solution (Python):
from fractions import gcd  


def main():
    A, B = list(map(int, input().split(' ')))
    gcd_ab = gcd(A, B)
    lcm = A * B // gcd_ab
    print(lcm)


if __name__ == '__main__':
    main()

Solution (Python):
import fractions as f

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

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

Solution (Python):
from fractions import gcd

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

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

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

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

print(lcm(a,b))

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


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


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

print(lcm(a, b))

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

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

from fractions import gcd

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

print(lcm)

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

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

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

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

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

print(solve())

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

Solution (Python):
import sys
import math
from collections import Counter
import itertools
import fractions



def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, 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 SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")



def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
 
A,B=MI()
 
print(lcm(A,B))

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

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

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

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

Solution (Python):

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


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

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

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

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

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

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

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

Solution (Python):
a, b = map(int, input().split())
num = 1
for i in reversed(range(1, min(a, b)+1)):
    if a % i == 0 and b % i == 0:
        a = a / i
        b = b / i
        num = i
        break

print(int(a*b*num))

Solution (Python):
import fractions
def lcm(a:int, b:int) -> int:
    return (a * b) // fractions.gcd(a, b)

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

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

Solution (Python):

import sys


def solve(A: int, B: int):
    from fractions import gcd
    return A * B // gcd(A, B)



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

def test():
    import doctest
    doctest.testmod()

if __name__ == '__main__':
    
    main()

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

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

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

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

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

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


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

Solution (Python):
A, B = map(int,input().split())
AA,BB= A,B
if A < B:
    A,B = B,A
while A%B !=0:
    t = A % B
    A = B
    B = t

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

Solution (Python):
import fractions

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

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


print(lcm(A, B))

Solution (Python):
import fractions

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

Solution (Python):

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

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

Solution (Python):
import fractions


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


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

print(lcm(a, b))

Solution (Python):
import fractions as math

if __name__ == '__main__':
	A, B = map(int, input().split())
	gcd = math.gcd(A,B)
	ans = (A//gcd) * B
	print(ans)

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

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

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

M = max(a,b) 
m = min(a,b)
temp = M

while True:
    if temp%m == 0:
        print(temp)
        exit()
    temp += M

Solution (Python):
from fractions import gcd

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

print(lcm(a,b))

Solution (Python):
import fractions

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

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

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

A_lis = prime_factorize(A)
A_lis.append(1)
B_lis = prime_factorize(B)

ans = 1

for i in set(A_lis + B_lis):
    if A_lis.count(i) >= B_lis.count(i):
        ans = ans * (i ** A_lis.count(i))
    else:
        ans = ans * (i ** B_lis.count(i))

print(ans)

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

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

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

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

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

Solution (Python):
import itertools
import math
import string
import collections
from collections import Counter
from collections import deque
import sys
sys.setrecursionlimit(2*10**5)
INF = 2**60


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
A, B = map(int, input().split())
for i in range(1, B+1):
    if A*i % B == 0:
        print(A*i)
        break

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

s,t = map(int,input().split())
print(lcm(s,t))

Solution (Python):
a,b=map(int,input().split())
if a<b:
  a,b=b,a
a2=a
b2=b
while True:
  if a%b==0:
    break
  a,b=b,a%b
print(a2*b2//b)

Solution (Python):
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

A, B = rl()

from fractions import gcd
from functools import reduce

def get_gcd(A):
    return reduce(gcd, A)

def get_lcm(A):
	def lcm_base(a, b):
		return a*b//gcd(a,b)
	return reduce(lcm_base, A, 1)

print(get_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 sys
input = sys.stdin.readline
from fractions import gcd
def main():
    A, B = map(int, input().split())
    g = gcd(A, B)
    ans = A // g * B
    print(ans)
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
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())
a = min(A,B)
b = max(A,B)
for i in range(1,b+1):
	if (a*i)%b==0:
		print(a*i)
		break

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

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

Solution (Python):
import fractions
x, y = (int(x) for x in input().split())

print(int((x * y) / fractions.gcd(x, y)))

Solution (Python):
import fractions

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

Solution (Python):
import fractions

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


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

Solution (Python):
import fractions

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

res = fractions.gcd(A, B)

print(int(A*B / res))

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


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


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

Solution (Python):
import fractions




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

Solution (Python):
ab=list(map(int,input().split()))
i=max(ab)
while True:
  if i%ab[0]==0 and i%ab[1]==0:
    print(i)
    break
  i+=max(ab)

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

common = 1

for i in range(2, min(A, B) + 1):
    if A % i == 0 and B % i == 0:
        common = i
result = A * B / common

print(int(result))

Solution (Python):
import fractions

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

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

Solution (Python):
import fractions

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

print(lcm(a,b))

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

Solution (Python):
import sys
from math import ceil, floor, sqrt, sin, cos, pi
from itertools import accumulate, permutations, combinations
from fractions import gcd
from collections import deque, Counter
from operator import itemgetter
from heapq import heappop,heappush
sys.setrecursionlimit(10**7)

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

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


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


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


if __name__ == "__main__":
    main()

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