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



Sample input:
2 3


Sample output:
6

Submission status: Runtime Error

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

print(lcm(a, b))

Submission status: Runtime Error

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

print(lcm(a, b))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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


print(lcm(p, q))

Submission status: Runtime Error

Solution code:
p, q = map(int, input().split())

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

print(lcm(p, q))

Submission status: Runtime Error

Solution code:
ソースコード 

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

Submission status: Runtime Error

Solution code:
p, q = map(int, input().split())
import fraction

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

print(lcm(p, q))

Submission status: Runtime Error

Solution code:
p, q = map(int, input().split())
import math

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

print(lcm(p, q))

Submission status: Runtime Error

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

print(lcm(p, q))

Submission status: Runtime Error

Solution code:
p, q = map(int, input().split())
import math
gcd = math.gcd(p, q)

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

print(lcm(p, q))

Submission status: Runtime Error

Solution code:
import math
A,B=map(int,input().split())

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

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
import math
A,B=map(int,input().split())

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

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
from functools import reduce
def lcm_base(x, y):
    return (x * y) // math.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]))

Submission status: Runtime Error

Solution code:

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

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)
A,B=list(map(int,input().split()))
print(lcm(A,B))

Submission status: Runtime Error

Solution code:
# abc148_c.py
import sys
import time
import unittest
from io import StringIO
import 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()

Submission status: Runtime Error

Solution code:
import math

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

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

print(lcm(A, B))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
def lcm(a, b):
  return a * b / gcd(a, b)

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

import math
l = A * B / math.gcd(A, B)
print(int(l))

Submission status: Runtime Error

Solution code:
import math

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

print(lcm(A, B))

Submission status: Runtime Error

Solution code:
import math

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

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

print(lcm(a,b))

Submission status: Runtime Error

Solution code:
import sys
def input(): return sys.stdin.readline().strip()
import math
def resolve():
    a,b=map(int, input().split())
    print((a*b)//math.gcd(a,b))
resolve()

Submission status: Runtime Error

Solution code:
import sys
def input(): return sys.stdin.readline().strip()
import math
def resolve():
    a,b=map(int, input().split())
    print(a*b//math.gcd(a,b))
resolve()

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
from math import gcd

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

snack = (A * B) // gcd(A, B)

print(snack)

Submission status: Runtime Error

Solution code:
# input
A, B = int(input())

snack = max([A, B])
while snack % A != 0 and snack % B != 0:
    snack += 1

print(snack)

Submission status: Runtime Error

Solution code:
import numpy
a,b = map(int,input().split())
ab = numpy.gcd(a,b)
print(int(a*b//ab))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import numpy as np
a,b = map(int,input().split())

ans = int(a * b / np.gcd(a,b))

print(ans)

Submission status: Runtime Error

Solution code:

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

import numpy as np
ans = int(a * b / np.gcd(a, b))

print(ans)

Submission status: Runtime Error

Solution code:

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

import math
ans = int(a * b / math.gcd(a, b))

print(ans)

Submission status: Runtime Error

Solution code:
import math

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


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


print(lcm(A, B))

Submission status: Runtime Error

Solution code:
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):
    [A, B] = string_to_int(input)
    return A*B


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


if __name__ == "__main__":
    ret = solve(inputs(1))
    print(ret)

Submission status: Runtime Error

Solution code:
import math
A, B = map(int, input().split())

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

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
import math
A, B = map(int, input().split())

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

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
import math
a, b = map(int, input().split())
#a,bの最小公倍数
def lcm(a, b):
  return a * b // math.gcd (a, b)
print(lcm(a, b))

Submission status: Runtime Error

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sat May  9 16:09:21 2020

@author: shinba
"""

import math

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

import math 

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

Submission status: Runtime Error

Solution code:
import numpy as np
a, b = map(int, input().split())
p =np.gcd(a, b)
print(b * (a // p))

Submission status: Runtime Error

Solution code:
import math
a, b = map(int, input().split())
p = math.gcd(a, b)
print(b * (a // p))

Submission status: Runtime Error

Solution code:
a, b = map(int, input().split())
import math
p = math.gcd(a, b)
print(b * (a // p))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
A, B = map(int, input().split())


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


print(lcm(A, B))

Submission status: Runtime Error

Solution code:

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

from fractions import gcd

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

Submission status: Runtime Error

Solution code:

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

import math

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

Submission status: Runtime Error

Solution code:

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

import math

print(len(a*b/math.gcd(a,b)))

Submission status: Runtime Error

Solution code:

#ユークリッドの互除法( A < B　とし, O(logA))
def gcd(a,b):
    if b == 0:
        return a
    else:
        return gcd(b, a%b)

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

#3個以上の最大公約数を求める必要がある
# res=0 と初期化して、res=gcd(res,x[i])と更新する
# gcd(a,b,c,....) → gcd(gcd(gcd(a,b),c),...) 
res = 0
x = list(map(int,input().split()))

for i in range(N):
    res = gcd(res,abs(x[i] - X))

print(res)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
A, B = map(int, input().split())
ans = A * B // math.gcd(A, B)
print(ans)

Submission status: Runtime Error

Solution code:
123 456

Submission status: Runtime Error

Solution code:
# C - Snack
import math
a,b = map(int,input().split())
print(a*b//math.gcd(a,b))

Submission status: Runtime Error

Solution code:
# C - Snack

from math import gcd

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

Submission status: Runtime Error

Solution code:
# C - Snack

from math import gcd

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

Submission status: Runtime Error

Solution code:
import math
def lcm(x, y):
    return int((x * y) / math.gcd(x, y))

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

Submission status: Runtime Error

Solution code:
import math
def lcm(x, y):
    return int((x * y) /math.gcd(x, y))

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

Submission status: Runtime Error

Solution code:
import math
def lcm(x, y):
    return (x * y) // math.gcd(x, y)

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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


if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import math

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

print(lcm(a,b))

Submission status: Runtime Error

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

from math import gcd


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

print(lcm)

Submission status: Runtime Error

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

from math import gcd

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

print(lcm)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
A, B = map(int, input().split())
ans = A * B / math.gcd(A, B)

print(int(ans))

Submission status: Runtime Error

Solution code:
import math
import sys
sys.setrecursionlimit(10**7)
a,b = map(int,input().split())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)
if b != 0:
    print(lcm(a, b))
else:
    print(a)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

print(solve())

Submission status: Runtime Error

Solution code:
import math

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

print(solve())

Submission status: Runtime Error

Solution code:
import math

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

print(solve())

Submission status: Runtime Error

Solution code:
import fractions
a,b=map(int, input().split())
print(’{:.0f}’.format(a*b/fractions.gcd(a, b)))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

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

print(lcm(A, B))

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
A,B=map(int,input().split())

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

Submission status: Runtime Error

Solution code:
import math
A,B=map(int,input().split())

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

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
A,B=map(int,input().split())
import math

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

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
import fractions

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

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

Submission status: Runtime Error

Solution code:
import fractions

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

print(a * b / fracions.gcd(a * b))

Submission status: Runtime Error

Solution code:
import fractions

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

print(a * b / fracions.gcd(a * b))

Submission status: Runtime Error

Solution code:
import math
import sys
sys.setrecursionlimit(10**11)
a,b = map(int,input().split())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)
if b != 0:
    print(lcm(a, b))
else:
    print(a)

Submission status: Runtime Error

Solution code:
import math
import sys
sys.setrecursionlimit(10**10)
a,b = map(int,input().split())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)
if b != 0:
    print(lcm(a, b))
else:
    print(a)

Submission status: Runtime Error

Solution code:
import math
import sys
sys.setrecursionlimit(10**9)
a,b = map(int,input().split())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)
if b != 0:
    print(lcm(a, b))
else:
    print(a)

Submission status: Runtime Error

Solution code:
import math
import sys
sys.setrecursionlimit(10**1000000)
a,b = map(int,input().split())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)
if b != 0:
    print(lcm(a, b))
else:
    print(a)

Submission status: Runtime Error

Solution code:
import math
a,b = map(int,input().split())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)
if b != 0:
    print(lcm(a, b))
else:
    print(a)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import math
from functools import reduce

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

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

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

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

Submission status: Runtime Error

Solution code:
import math
from functools import reduce

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

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

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

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

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


print(lcm(A, B))

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

Solution code:

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

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

Submission status: Runtime Error

Solution code:
import math


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


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

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import math

def lcm(x, y):
    if math.gcd(x, y) == 0:
        return 0
    return x * y // math.gcd(x, y)

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

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

Solution code:
import math

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

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

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
import sys
import fractions
a, b = map(int, sys.stdin.raedline())
gcd = fractions.gcd(a, b)
print(a * b // gcd)

Submission status: Runtime Error

Solution code:
from math import gcd

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

print(lcm(a,b))

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

Solution code:
A = int(input())
B = int(input())
sum = 1
while 1:
    A_d = sum % A 
    B_d = sum %B 
    if A_d == 0 and B_d==0:
        break
    else:
        sum = sum+1
print(sum)

Submission status: Runtime Error

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

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
import math
def lcm(x, y):
    return (x * y) // math.gcd(x, y)

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

Submission status: Runtime Error

Solution code:
#!/usr/bin/env python3
import math
a, b = map(int, input().split())
print(int(a*b/math.gcd(a,b)))

Submission status: Runtime Error

Solution code:
import math
X, Y = map(int, input().split())

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

print(lcm(X,Y))

Submission status: Runtime Error

Solution code:
import math
x, y = (int(x) for x in input().split())

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

Submission status: Runtime Error

Solution code:
import math
x, y = (int(x) for x in input().split())

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

Submission status: Runtime Error

Solution code:
import math
A, B = (int(x) for x in input().split())


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


print(lcm(A, B))

Submission status: Runtime Error

Solution code:
import math

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

res = math.gcd(A, B)

print(int(A*B / res))

Submission status: Runtime Error

Solution code:
import math

# 最小公倍数lcm（ least common multiple）を返す関数は用意されていない
# が、lcm(a, b) = a * b / gcd(a, b)で求められる

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

Submission status: Runtime Error

Solution code:
import math

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

print(lcm(a,b))

Submission status: Runtime Error

Solution code:
import math


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


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

print(lcm(a, b))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math as mt 
A,B=map(int,input().split())
print(int(A*B/mt.gcd(A,B)))

Submission status: Runtime Error

Solution code:
import sys
import math
import itertools

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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


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

print(lcm(A,B))

Submission status: Runtime Error

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


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

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
import sys
import math
from collections import Counter
#from functools import reduce

# 入力を整数に変換して受け取る
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()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
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) // math.gcd(x, y)

A,B=MI()

print(lcm(A,B))

Submission status: Runtime Error

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

print(lcm(a, b))

Submission status: Runtime Error

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

print(lcm(a, b))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

Solution code:
num = map(int, input().split())
A = max(num)
B = min(num)

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

Submission status: Runtime Error

Solution code:

import math

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

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

Submission status: Runtime Error

Solution code:

import fractions

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

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

Submission status: Runtime Error

Solution code:
import numpy as np

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

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

Submission status: Runtime Error

Solution code:

from math import gcd
A,B=[int(x) for x in input().rstrip().split()]

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

import math

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

print(lcm(n,m))

Submission status: Runtime Error

Solution code:
import math
ab=list(map(int,input().split()))
def lcm(x, y):
    return (x * y) // math.gcd(x, y)
print(lcm(ab[0], ab[1]))

Submission status: Runtime Error

Solution code:
from fractions import math

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

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

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
from fractions import math

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

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

print(lcm(a, b))

Submission status: Runtime Error

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

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


if __name__ == '__main__':
    q3()

Submission status: Runtime Error

Solution code:
from math import gcd

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

Submission status: Runtime Error

Solution code:
n = int(input())
s, t = input().split()
a = ''
for i in range(n):
    a += s[i] + t[i]
print(a)

Submission status: Runtime Error

Solution code:
from fraction import gcd


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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import math
A,B = list(map(int,input().split()))
print(int(A*B/math.gcd(A,B)))

Submission status: Runtime Error

Solution code:
import math
A,B = list(map(int,input().split()))
print(A*B/math.gcd(A,B))

Submission status: Runtime Error

Solution code:
import math
a,b = map(int,input().split())
#print(math.gcd(a, b))
x = math.gcd(a, b)
print(a*b//x)

Submission status: Runtime Error

Solution code:
import math
a,b = map(int,input().split())
#print(math.gcd(a, b))
x = math.gcd(a, b)
print(math.floor(a*b/x))

Submission status: Runtime Error

Solution code:
import math
a,b = map(int, input().split());d=math.gcd(a,b)
print((a*b)//d)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
print(int(input())*int(input()))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
x, y = map(int, input().split())
a = math.gcd(x, y)
print(int(x*y/a))

Submission status: Runtime Error

Solution code:
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) // math.gcd(a, b)
print(lcm(a, b))