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:
m = int(input())
n = int(input())

x = max(m, n)
y = min(m, n)
if x % y == 0:
  print(x)
else:
  while x%y!=0:
    z = x % y
    x = y
    y = z
  else:
    print(int(m * n / z))

Submission status: Runtime Error

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

a, b = [int(i) for i in 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 = list(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 = tuple(list(map(int, input().split(' '))))
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)

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

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

Submission status: Runtime Error

Solution code:
from fractions import gcd
A,B = 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):
    if x == 0 or y == 0:
        return 0
    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(int(a * b / math.gcd(a, b)))

Submission status: Runtime Error

Solution code:
import math

a, b = [int(x.strip()) for x in 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:
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:
A, B = map(int,input().split())
import math
g = math.gcd(A,B)
l = A * B // g
print(l)

Submission status: Runtime Error

Solution code:
import numpy as np
def q3(a,b):
    return np.lcm(a,b)

ans = input().split()
a = int(ans[0])
b = int(ans[1])
print(q3(a,b))

Submission status: Runtime Error

Solution code:
import math

a,b = map(lambda x:int(x), input().split())


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

Submission status: Runtime Error

Solution code:
import math

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

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

print(lcm(a, b))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

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

p = input().split()
a = int(p[0])
b = int(p[1])

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
A, B = [int(i) for i in input().split()]
print(int(A*B/math.gcd(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:
A,B = map(int,input().split())
GCD(p,q):
    if p<q:
        p,q = q,p
    p = q
    q = p%q
    if q!=0:
        GCD(p,q)
    else:
        return p
gcd = GCD(A,B)
ans = (A*B)//gcd
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
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:
import math
a,b = map(int,input().split())
c = math.gcd(a,b)
print(int((a*b)/c))

Submission status: Runtime Error

Solution code:
import math
A, B = [int(x) for x in input().split()]
lcm = (A * B) // math.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 = [int(x) for x in input().split()]


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

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

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


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

Submission status: Runtime Error

Solution code:
from math import gcd

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

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

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

Submission status: Runtime Error

Solution code:
str = [int(input()) for i in range(1)]
#input_sum = sum(str)
ans = str[0] * str[1]
print(ans)

Submission status: Runtime Error

Solution code:
import sys
import math
import re
import io

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

if __name__ == "__main__":
    main()

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
# coding: utf-8
import math
A, B = [int(x) for x in input().split(" ")]
 
print(int((A*B) / math.gcd(A, B)))

Submission status: Runtime Error

Solution code:
import sys
import math

str = sys.stdin.readline()

a = int(str.split()[0])
b = int(str.split()[1])

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

Submission status: Runtime Error

Solution code:
import sys
input = sys.stdin.readline

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

min_ = min([a,b])
max_ = max([a,b])

ret = a * b

for i in reversed(range(0,min_)):
  if max_ % i == 0 and min_ % i == 0:
    ret = min_ * max_ / i
    break

print(int(ret))

Submission status: Runtime Error

Solution code:
def gcd(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(m, n):
  return int(m * n/gcd(m, n))

m = int(input())
n = int(input())

print(lcm(m,n))

Submission status: Runtime Error

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


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

Submission status: Runtime Error

Solution code:
import math

N = input().split()

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

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

print(lcm)

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

Submission status: Runtime Error

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


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

Submission status: Runtime Error

Solution code:
import math
s = input().split()
a = int(s[0])
b = int(s[1])
re = int(a*b/math.gcd(a, b))
print(re)

Submission status: Runtime Error

Solution code:
# coding: utf-8
import math
A, B = [int(x) for x in input().split(" ")]

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

Submission status: Runtime Error

Solution code:
# https://atcoder.jp/contests/abc148/tasks/abc148_c
import math


def main():
    (a, b) = [int(i) for i in input().split(" ")]
    print(a * b // math.gcd(a, b))
    


if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
import math

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

k = math.gcd(a, b)

ans = a * b // k

print(ans)

Submission status: Runtime Error

Solution code:
import math

a,b=[int(x) for x in input().rstrip().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
import sys
input = sys.stdin.readline

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


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

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

print(min)

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
s = input().split()
a = int(s[0])
b = int(s[1])
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 = [int(i) for i in input().split()]123 456
print(lcm(a, b))

Submission status: Runtime Error

Solution code:
def gcd(a,b):
    a,b = max(a,b),min(a,b)
    if a % b == 0:
        return b
    else:
        gcd(b,a%b)

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

Submission status: Runtime Error

Solution code:
import math
import sys
input = sys.stdin.readline


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


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

    print(lcm(A, B))


if __name__ == "__main__":
    main()

Submission status: Runtime Error

Solution code:
import math

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

max1 = max(A, B)

for i in range(100000000):
  s = min1 * i
  if max1 < s:
    break
    
print(s)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

test = ""
#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 // math.gcd(a, b))

Submission status: Runtime Error

Solution code:
import math

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

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

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:
#!python3.4.3
import math

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

if __name__ == "__main__":
    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:
import sys
import math

str = sys.stdin.readlines()

a = int(str[0].split()[0])
b = int(str[0].split()[1])

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

print(func(x, y))

Submission status: Runtime Error

Solution code:
from collections import defaultdict
import sys
import math
from datetime import datetime
import re
import math
def lcm(x, y):
    return (x * y) // math.gcd(x, y)


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


do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    #print(parsed_lines)
    n = int(parsed_lines[0][0])
    k = int(parsed_lines[0][1])
    #S = parsed_lines[0][0]
    return n, k


if not do_submit:
    n, k = input_parse("""
    5
10 4 8 7 3
    """)
    print(sol(n, k))

    n, k = input_parse("""
    100000 5
    """)
    print(sol(n, k))


else:
    #n = int(input())
    a, b = list(map(int, input().split()))
    print(sol(a, b))

    # S = input().strip()
    # print(sol(S))

Submission status: Runtime Error

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

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(lambda x:int(x), input().split())

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

Submission status: Runtime Error

Solution code:
import math

a,b = list(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())

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

result = a * b / math.gcd(a, b)

print(int(result))

Submission status: Runtime Error

Solution code:
import math

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

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


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

Submission status: Runtime Error

Solution code:
import math

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

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

print(a)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import numpy as np
import math


s = input().split()
a=int(s[0])
b = int(s[1])

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

Submission status: Runtime Error

Solution code:
import sys
import math

def solve(a, b):
    print(math.gcd(a, b))

if __name__ == '__main__':
    a, b = map(int, sys.stdin.readline().strip().split(" "))
    solve(a, b)

Submission status: Runtime Error

Solution code:
import math

def main():

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

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

if __name__ == '__main__':
    main()

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

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

Submission status: Runtime Error

Solution code:
import math

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

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

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 main():
    A, B = map(int, input().split())

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


if __name__ == "__main__":
    main()

Submission status: Runtime Error

Solution code:
import math
a,b = [int(i) for i in input().split()]
print(a*b//math.gcd(a,b))

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

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

print(lcm(x, y))

Submission status: Runtime Error

Solution code:
#include<iostream>
#include<vector>
#include<cmath>
#include<algorithm>
using namespace std;
typedef long long ll;

#if 1
//whileで小さくしてく
ll gcd(ll x,ll y){
  if(x<y) swap(x,y);
  //xの方が常に大きい
  while(y>0){
    ll r=x%y;
    x=y;
    y=r;
  }
  return x;
}

#endif

#if 1

ll lcm(ll x,ll y){
  return ll(x*y/gcd(x,y));
}

#endif

int main(){
  ll x,y;cin >> x >> y;
  cout << lcm(x,y) << endl;
}

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
from sys import stdin


def fetch_one_line():
    return stdin.readline().rstrip()


def fetch_int_input():
    return [int(s) for s in fetch_one_line().split()]


def fetch_inputs(times):
    return [fetch_one_line() for _ in range(times)]


def fetch_int_inputs(times):
    return [[int(s) for s in fetch_one_line()] for _ in range(times)]

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

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

Submission status: Runtime Error

Solution code:
a, b = list(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 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):
    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())
def okasi(x, y):
    return (x * y) // math.gcd(x, y)

print(okasi(A,B))

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
from sys import stdin 
import math
a,b = [int(x) for x in stdin.readline().rstrip().split()]
answer = a * b // math.gcd(a, b)
print(answer)

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

N = input().split()

lcm = int(N[0]) * int(N[1]) / math.gcd(int(N[0]), int(N[1]))

print(int(lcm))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
#-*- coding: utf-8 -*-
"""
oj dl https://atcoder.jp/contests/abc116/tasks/abc116_d -d test-d
oj test -d test-d -c "python abc116d.py"
oj test -d test-d -c "python abc116d.py" test-d/sample-3.in
"""
from collections import defaultdict
import sys
import math
from datetime import datetime
import re
import math
def lcm(x, y):
    return (x * y) // math.gcd(x, y)


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


do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    #print(parsed_lines)
    n = int(parsed_lines[0][0])
    k = int(parsed_lines[0][1])
    #S = parsed_lines[0][0]
    return n, k


if not do_submit:
    n, k = input_parse("""
    5
10 4 8 7 3
    """)
    print(sol(n, k))

    n, k = input_parse("""
    100000 5
    """)
    print(sol(n, k))


else:
    #n = int(input())
    a, b = list(map(int, input().split()))
    print(sol(a, b))

    # S = input().strip()
    # print(sol(S))

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

Submission status: Runtime Error

Solution code:
import numpy as np
import math

input_line = input().split()

x = int(input_line[0])
y = int(input_line[1])

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

Submission status: Runtime Error

Solution code:
[n,m] = list(map(int,input().split()))
from math import *
print((n*m)/gcd(n,m))

Submission status: Runtime Error

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

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

print(lcm(x, y))

Submission status: Runtime Error

Solution code:
from math import gcd
(A, B), = [list(map(int, s.split())) for s in open(0)]
print(int(A * B / 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

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

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

if __name__=="__main__":
    main()

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)

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

Submission status: Runtime Error

Solution code:
import math

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

myans = (A * B) // math.gcd(A, B)

print(myans)

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:
# coding: utf-8
import math
A, B = [int(x) for x in input().split(" ")]

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
# coding: utf-8
# Your code here!

import math

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

def main():
    l = input().rstrip().split(' ')
    
    x = int(l[0])
    y = int(l[1])
    
    print(lcm(x, y))
    
if __name__ == "__main__":
    main()

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:
A, B  = (int(i) for i in input().split())

import math

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

Submission status: Runtime Error

Solution code:
import math
a,b = map(lambda x: int(x), 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(lcm(a, b))

Submission status: Runtime Error

Solution code:
import math 

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

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

Submission status: Runtime Error

Solution code:
a, b = map(int, input().split())
if a<b: a,b=b,a
c = a*b
while b:
    a, b = b, a//b
print(c//b)

Submission status: Runtime Error

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

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

print(lcm(a, b))

Submission status: Runtime Error

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

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

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:
import math

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

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

Submission status: Runtime Error

Solution code:
import collections
import math
import operator as op
from functools import reduce
import numpy as np
import math
import bisect


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

    lcm = (A * B) // math.gcd(A, B)

    print(lcm)


if __name__ == '__main__':
    main()

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 = [int(n) for n in 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//math.gcd(a, b)*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 math
input  = sys.stdin.readline


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


if __name__ == '__main__':
    solve()

Submission status: Runtime Error

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

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
def main():
    a,b = map(int ,input().split())
    ans=a*b//math.gcd(a,b)
    print(ans)
if __name__=='__main__':
    main()

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:
# coding: utf-8
# submission # - User: herp_sy
# https://atcoder.jp/contests/
#
# lang: Python3 (3.4.3)

import math
import statistics
import numpy as np
import queue

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

Submission status: Runtime Error

Solution code:
# -*- coding: utf-8 -*-
import math

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

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

print(lcm(A, B))

Submission status: Runtime Error

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

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

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

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

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

Submission status: Runtime Error

Solution code:
import math
inp = input().split()
A = int(inp[0])
B = int(inp[1])

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

Submission status: Runtime Error

Solution code:
import numpy as np
input_l = list(map(int,input().split()))
a = input_l[0]
b = input_l[1]
print(np.lcm(a,b))

Submission status: Runtime Error

Solution code:
a, b = map(int, input().split())
if a<b: a,b=b,a
c = a*b
while a%b:
    a, b = b, a//b
print(c//b)