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

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


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

    return gcd(n, m % n)


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

def getEuclideanAlgorithm(i, j):
    r = i % j
    while (r != 0):
        i = j
        j = r
        r = i % j
    return j

if (num[0] < num[1]):
    gcd = getEuclideanAlgorithm(num[1], num[0])
else:
    gcd = getEuclideanAlgorithm(num[0], num[1])

print(int((num[0] * num[1]) / gcd))

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

def euclid(a0, b0):
    a = max(a0, b0)
    b = min(a0, b0)
    while(a%b != 0):
        a = a%b
        if a<b: 
          a = a^b
          b = a^b
          a = a^b
        
        
    return b

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

Solution (Python):
def gcd(m,n):
  while n!=0: n, m = m % n, n
  return m
A,B = map(int, input().split())
print(A*B//gcd(max(A,B),min(A,B)))

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

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


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

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

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

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
        else:
            return z
def lcm(m,n):
    return int(m*n/gcd(m,n))
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):
s=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)
print(int(lcm(s[0],s[1])))

Solution (Python):
L=input().split(' ')

X = int(L[0])
Y = int(L[1])

if X < Y:
    tmp = Y
    Y = X
    X = tmp

M = X*Y

R = X%Y
while(R!=0):
    X=Y
    Y=R
    R=X%Y
    
print(int(M/Y))

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

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

def lcm(a,b):
    return int(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 sys
import fractions
input  = sys.stdin.readline


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


if __name__ == '__main__':
    solve()

Solution (Python):
import math
from fractions import gcd

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

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

Solution (Python):
aa,bb = map(int,input().split())
a = aa
b = bb
if aa>bb:
    a = bb
    b = aa
rx = a
ry = b

while 1:
    if rx == 0:
        break
    rx2 = ry%rx
    ry = rx
    rx = rx2

print(int(a*b/ry))

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) 

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

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(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 math import sqrt as sq

def main():
    l=[int(e) for e in list(sys.stdin.readline().split())]
    if l[0]>l[1]:
        l=l[::-1]
    for e in range(l[0],0,-1):
        if l[0]%e==0:
            tempQ1=l[0]//e
            if l[1]%e==0:
                tempQ2=l[1]//e
                print(tempQ1*tempQ2*e)
                break


main()

Solution (Python):
import collections

def factorize(n):
    b = 2
    fct = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            fct.append(b)
        b = b + 1
    if n > 1:
        fct.append(n)
    return fct

a, b = map(int, input().split())
af = factorize(a)
bf = factorize(b)
ac = collections.Counter(af)
bc = collections.Counter(bf)
pnum = set(ac.keys()) | set(bc.keys())

ans = 1
for i in pnum:
    ans *= i**(max(ac[i], bc[i]))
print(ans)

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

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

print(lcm(A, B))

Solution (Python):


def resolve():
    A, B = map(int, input().rstrip().split(" "))

    a = b = 2
    X = A
    Y = B
    while True:
        if X == Y:
            break
        elif X < Y:
            X += A
        else:
            Y += B

    print(X)

if __name__ == "__main__":
    resolve()

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

def gcb(a,b):
  x = max(a,b)
  y = min(a,b)
  if x%y ==0:
    return y
  else:
    while x%y!=0:
      z = x%y
      x = y
      y = z
    else:
      return z
def lcm(a,b):
  return int(a * b / gcb(a,b))

print(lcm(A,B))

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

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

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

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

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

print(int(x/b))

Solution (Python):

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

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



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


print(lcm(a, b))

Solution (Python):
from fractions import gcd
A, B = [int(x) for x in input().split()]


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

Solution (Python):
from fractions import gcd

def saisyou(x, y):
    ans =  (x * y) // gcd(x, y)
    print(ans)

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

Solution (Python):
def main(a: int, b: int):
    x, y = 1, 1

    while (a * x) != (b * y):
        if (a * x) > (b * y):
            y += 1
        else:
            x += 1

    print(a * x)


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

    main(a, b)

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

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

Solution (Python):
a, b = map(int,input().split())
flg = False
for i in range(1,b+1):
  if a*i%b == 0:
    print(a*i)
    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):
from fractions import gcd
a, b = list(map(int,input().split()))
print(int(a * b//gcd(a, b)))

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

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

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


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

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

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

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) 

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

    print(int(lcm(A,B)))

if __name__ == "__main__":
    main()

Solution (Python):
import fractions

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

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

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

def gcd(a,b):
  return a if b == 0 else gcd(b,a%b)
answer=A*B//gcd(A,B)
print(answer)

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 math



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

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


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 math import factorial
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
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()))
MOD = 10**9 + 7

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

Solution (Python):
import math

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

def computeGCD(x, y): 
    if x > y: 
        small = y 
    else: 
        small = x 
    for i in range(1, small+1): 
        if((x % i == 0) and (y % i == 0)): 
            gcd = i 
              
    return gcd

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

print(lcm(A, B))

Solution (Python):

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

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

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

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

Solution (Python):
import fractions

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

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

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

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=list(map(int,input().split()))
A=min(a,b)
B=max(a,b)

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

Solution (Python):
A, B = map(int, input().split())
x = max(A, B)
y = min(A, B)
if x%y == 0:
  gcd = y
else:
  while x%y != 0:
    z = x%y
    x = y
    y = z
  else:
    gcd = z
lcm = int(A*B/gcd)

print(lcm)

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

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

Solution (Python):
from fractions import gcd

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

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

print(lcm(x, y))

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

Solution (Python):
import fractions

test = ""

"""
123 456
"""
test = list(reversed(test.strip().splitlines()))
if test:
    def input2():
        return test.pop()
else:
    def input2():
        return input()
    

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

Solution (Python):
a,b = map(lambda x: int(x), input().split())
c = a
d = b
if a < b:
    a, b = b, a
while a % b != 0:
    a, b = b, a % b

print(c*d // b)

Solution (Python):

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

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

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

Solution (Python):
import fractions
a, b = [int(x) for x in input().split()]
f = a * b // fractions.gcd(a, b)
print(f)

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

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

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

tmp = input().split()
A = int(tmp[0])
B = int(tmp[1])

mo = 0
if A >= B:
    mo = gcd(A, B)
else:
    mo = gcd(B, A)
ans = (A * B) // mo

print(ans)

Solution (Python):
import fractions

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

gcd=fractions.gcd(a,b)

n=a*b/gcd

print(int(n))

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


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


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

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

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

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

Solution (Python):
import fractions

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

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

print(ans)

Solution (Python):
import fractions

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

Solution (Python):
import unittest


class TestC(unittest.TestCase):
    def test_1(self):
        self.assertEqual(think(2, 3), 6)

    def test_2(self):
        self.assertEqual(think(123, 456), 18696)

    def test_3(self):
        self.assertEqual(think(100000, 99999), 9999900000)


def solve():
    a, b = read()
    result = think(a, b)
    write(result)


def read():
    return read_int(2)


def read_int(n):
    return read_type(int, n)


def read_float(n):
    return read_type(float, n)


def read_type(t, n):
    return list(map(lambda x: t(x), read_line().split(' ')))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(a, b):
    return lcm(a, b)


def write(result):
    print(result)


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


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


if __name__ == '__main__':
    
    solve()

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

def NonRecursiveGcd(x,y):
 
    while(y):
        x , y = y , x % y
    return x 
def computeLcmWithNonRecursiveGcd(x,y):
    
    lcm = (x*y)//NonRecursiveGcd(x,y)
    
    return lcm  
print(computeLcmWithNonRecursiveGcd(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())
n = a*b
if a < b:
  tmp = a
  a = b
  b = tmp
tmp = a % b
while tmp != 0:
  a = b
  b = tmp
  tmp = a % b

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

Solution (Python):

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

a = A
b = B
while True:
    r = a % b
    if r == 0:
        break
    a = b
    b = r

lcm = (A*B)/b




print(int(lcm))

Solution (Python):


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

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

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

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):
def gcd(a, b):
	while b:
		a, b = b, a % b
	return a
s = input().split()
a = int(s[0])
b = int(s[1])
re = int(a*b/gcd(a, b))
print(re)

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

for i in range(2,n+1):
  while 1:
    if (b/x)%i==0 and (a/x)%i==0:
      x=x*i
    else:
      break
  
print(int(a*b/x))

Solution (Python):
A,B = map(int,input().split())
X = A*B
if A < B:
    temp = A
    A = B
    B = temp

r = A % B
while r != 0:
    A = B;
    B = r;
    r = A % B

print (X // B)

Solution (Python):
import fractions

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

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

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

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

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

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

if A < B:
  tmp = A
  A = B
  B = tmp

r = A % B

while r != 0:
  A = B
  B = r
  r = A % B

print(int(Ans / B))

Solution (Python):
from fractions import gcd

N = input().split()

A = int(N[0])
B = int(N[1])

lcm = int(A * B / gcd(A, B))

print(lcm)

Solution (Python):
import fractions

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

print(int(a[0]*a[1]/fractions.gcd(a[0],a[1])))

Solution (Python):
a,b=(int(x) for x in input().split())
gcc=1
i=2
while True:
    if(a<i or b<i):
        break
    elif (a%i==0 and b%i==0):
        gcc*=i
        a/=i
        b/=i
        i=2
    else:
        i+=1

print(int(a*b*gcc))

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

_A, _B = min(A, B), max(A, B)

pres = _A
while True:
    res = _B % _A
    if res == 0:
        break
    else:
        pres = res
        _B = _A
        _A = res

print((A * B) // pres)

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

Solution (Python):


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


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


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

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

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

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

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

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

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

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

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

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

Solution (Python):
A, B = map(int, input().split())
def gcd(a,b):
  while b!=0:
    a,b=b,a%b
  return a

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

ans = lcm(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):

import fractions

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

f=fractions.gcd(a,b)

f2=a*b//f

print(f2)

Solution (Python):
from fractions import gcd

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

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

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

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

ans = lcm(a, b)

print(ans)

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

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

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

if __name__ == "__main__":
    main()

Solution (Python):
import fractions

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

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(a, b):
    while a % b != 0:
        r = a % b
        a, b = b, r
    return b

def LCM(a, b):
    return int((a * b) / gcd(a, b))
print(LCM(A, B))

Solution (Python):
def gcd(a,b):
    if(b==0):
        return a
    return gcd(b,a%b)
a,b=map(int,input().split())
maxi=max(a,b)
mini=min(a,b)
gg=gcd(mini,maxi)
maxii=maxi//gg
minii=mini//gg
print(maxii*mini)

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

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

Solution (Python):
from fractions import gcd

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

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

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

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

print(int(x/b))

Solution (Python):
import fractions

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

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 = [int(x) for x in input().split()]

import fractions

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

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

Solution (Python):
AB = [int(e) for e in input().split()]
A = AB[0]
B = AB[1]
cnt = 1
while 1:
    if ((A * cnt) % B)==0:
        ans = A * cnt
        break
    cnt+=1
print(ans)

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

x = A*B

if A<B:
    tmp = A
    A = B
    B = tmp

r = A%B
while r != 0:
    A = B
    B = r
    r = A%B

print((int)(x/B))

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

n = max(a,b)
m = min(a,b)
ans=0

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

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):
"""
Atcoder_Beginner_Contest_148
C

"""
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000)

A, B = map(int, input().split())
tmp_a, tmp_b = A, B
while tmp_a % tmp_b != 0:
    tmp_a, tmp_b = tmp_b, tmp_a % tmp_b

print(int(A * B / tmp_b))

Solution (Python):
from fractions import gcd
import sys

input = sys.stdin.readline

a, b = list(map(int, input()[:-1].split(" ")))

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

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

Solution (Python):
inpl = lambda: list(map(int,input().split()))
def gcd(a, b):
    if a < 0: a = -a
    if b < 0: b = -b
    while b > 0:
        (a, b) = (b, a % b)
    return a

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

Solution (Python):

from fractions import gcd

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

if __name__ == "__main__":
    a, b = map(int, input().split(' '))
    
    print(lcm(a, b))

Solution (Python):
import fractions

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

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

Solution (Python):
a,b = map(int, input().split())
i = min(a,b)
s = 0
while(i <= a*b):
    if (i%a == 0 and i%b == 0):
        s = i
        break
    i += min(a,b)
print(i)

Solution (Python):
import fractions

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

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

Solution (Python):
import fractions

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

a = (n[0] * n[1]) // fractions.gcd(n[0], n[1])
print(a)

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

def euc(a,b):
    euc1 = max(a,b)
    euc2 = min(a,b)
    rem = euc1 % euc2
    if rem == 0:
        return euc2
    else:
        return euc(euc2,rem)

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

Solution (Python):
from fractions import gcd


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

Solution (Python):
import fractions

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

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

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

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

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

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):
import fractions
import sys
input = sys.stdin.readline

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


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

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

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

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

print(int(min))

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

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

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 = [int(num) for num in input().split()]
max = A * B

bigger = None
smaller = None
if A > B:
    bigger = A
    smaller = B
else:
    bigger = B
    smaller = A

for i in range(1, smaller + 1):
    num = bigger * i

    if not num % smaller:
        print(num)
        break

Solution (Python):
u = input().split()
c = int(u[0])
d = int(u[1])
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(c,d))

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

Solution (Python):
from __future__ import print_function

import sys
input = sys.stdin.readline

def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return

import math

import fractions
from fractions import Fraction
from fractions import gcd

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





















def reduce(p, q):
    common = fractions.gcd(p, q)
    return (p//common , q//common )














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

if __name__ == '__main__':
    main()

Solution (Python):
import math

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

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

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

print(okasi(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())
s = max(a,b)
m = max(a,b)

for i in range(s,10**10+1,m):
    if i%a == 0 and i%b ==0:
        print(i)
        exit()

Solution (Python):
import math
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!=0:
        a,b=b,a%b
    return a
 
def lcm(a,b):
    return a*b//gcd(a,b)
    
result = A * B // gcd(A, B)
print(result)

Solution (Python):
import fractions

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

    return ans

A, B = [int(i) for i in input().split()]

print(lcm(A, B))

Solution (Python):
a, b =  list(map(int, input().split()))
def lcm(a):
    from fractions import gcd
    x = a[0]
    for i in range(1, len(a)):
        x = (x * a[i]) // gcd(x, a[i])
    return x

print(lcm([a,b]))

Solution (Python):
from fractions import gcd

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

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

Solution (Python):
from fractions import gcd

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

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

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

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


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

    print(ans)


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
def hcf(a,b):
	if(a==0):
		return b
	if(b==0):
		return a
	return hcf(b%a,a)
import math
a,b = list(map(int,input().split()))
print(abs(a*b)//hcf(a,b))

Solution (Python):
import fractions

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

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

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

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

print(lcm(a,b))

Solution (Python):
import fractions

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

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

print(int(n))

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