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

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

Submission status: Runtime Error

Solution code:
#coding:utf-8

import math

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

Submission status: Runtime Error

Solution code:
import math

a = int(input())
b = int(input())

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

Submission status: Runtime Error

Solution code:
import math

a, b = (int(_) for _ 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())

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

Submission status: Runtime Error

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

import math
import fractions
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(' ')]
gcd = math.gcd(A, B)
print(int(A*B/gcd))

Submission status: Runtime Error

Solution code:
# coding: utf-8
# Your code here!
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:
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)

l = input().rstrip().split(' ')

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

print(lcm(x, y))

Submission status: Runtime Error

Solution code:
# @Author: Amit Dwivedi
# @Date:   2019-12-22 11:55:43
# @Last Modified by:   Amit Dwivedi
# @Last Modified time: 2019-12-22 12:08:06
ll= lambda : list(map(int,input().split()))
testcases=1
# testcases=int(input())
import math
for testcase in range(testcases):
	[n,m] = ll()
	print((n*m)//math.gcd(n,m))

Submission status: Runtime Error

Solution code:
import math


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


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

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:
# coding: utf-8
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

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

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

Submission status: Runtime Error

Solution code:
# -*- coding: utf-8 -*-
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 = list(map(int,input().split()))
print(int((a*b)/math.gcd(a,b)))

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
a=list(map(int,input().split()))
A=a[0]
B=a[1]

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

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


print(myans)

Submission status: Runtime Error

Solution code:
import math

str_list = input().split(' ')
int_list = [int(x) for x in str_list]
A, B = int_list[0], int_list[1]

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
# from fractions import gcd
from math import gcd

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

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

Submission status: Runtime Error

Solution code:
import math

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

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

Submission status: Runtime Error

Solution code:
import math

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

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

print(lcm(A, B))

Submission status: Runtime Error

Solution code:
import numpy as np

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:

a, b=(int(i) for i in 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 sys
import math
def input(): return sys.stdin.readline().rstrip()

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

import math

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

res = lcm(A, B)

print(res)

Submission status: Runtime Error

Solution code:
import math

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

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


a,b=acinput()

print(lcm(a,b))

Submission status: Runtime Error

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

from math import gcd
print(int(A * B / gcd(A, B)))

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)

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

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

print(lcm(A, B))

Submission status: Runtime Error

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

import math

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

Submission status: Runtime Error

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

gcd=fractions.gcd(a,b)#最大公約数
lcm=a*b//gcd#最小公倍数least common multiple
print(lmc)

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):
    ans = (x * y)// math.gcd(x, y)

    return ans

A, B = [int(i) for i in 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)


print(lcm(A, B))

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

Solution code:
#!/usr/bin/env python3
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 = map(int, input().split())
lcm = A * B / math.gcd(A, B)
print(int(lcm))

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

d = [int(i) for i in input().split()]

print(lcm(d[0],d[1]))

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 copy
import math
import bisect
import pprint
import bisect

glist=[]

def makelist(max,num,list):
    if num == max:
        glist.append(list)
    else:
        list1 = copy.deepcopy(list)
        list1[num]=-1
        makelist(max,num+1,list1)
        list2 = copy.deepcopy(list)
        list2[num]=1
        makelist(max,num+1,list2)

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


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

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

Submission status: Runtime Error

Solution code:
from math import gcd
from functools import reduce


def least_common_multiple(iter):
    '''
    最小公倍数を返す
    '''
    lcm = lambda x, y: x*y//gcd(x, y)
    return reduce(lcm, iter)


AB = map(int, input().split())
print(least_common_multiple(AB))

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

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

Submission status: Runtime Error

Solution code:
import sys, math
from collections import defaultdict
from copy import deepcopy
import itertools
input = sys.stdin.readline
# 文字列の場合は普通のinput()を使うか下を使う
# input = sys.stdin.readline().rstrip()


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

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

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

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


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

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

Submission status: Runtime Error

Solution code:
#JMD
#Nagendra Jha-4096

 
import sys
import math

#import fractions
#import numpy
 
###File Operations###
fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile

###Defines...###
mod=1000000007
 
###FUF's...###
def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 
##### Main ####
t=1
for tt in range(t):
    #n=int(input())
    a,b= map(int, sys.stdin.readline().split(' '))
    print((a*b)//(math.gcd(a,b)))
    #a=list(map(int,sys.stdin.readline().split(' ')))
    
    
#####File Operations#####
if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

Submission status: Runtime Error

Solution code:
import sys
import math

def main():
    # input = sys.stdin.readline

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

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


if __name__ == '__main__':
    main()

Submission status: Runtime Error

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

Submission status: Runtime Error

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

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

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

Submission status: Runtime Error

Solution code:
from copy import deepcopy
from sys import exit,setrecursionlimit
import math
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac
import fractions
from functools import reduce
from operator import mul
import bisect
import sys
import logging
import heapq
import itertools

logging.basicConfig(level=logging.ERROR)

input = sys.stdin.readline

setrecursionlimit(1000000)


def main():
	a,b = map(int,input().split())
	print(a*b//gcd([a,b]))

def factorization(n):
	if n<2:
		return []
	arr = []
	temp = n
	for i in range(2, int(-(-n**0.5//1))+1):
		if temp%i==0:
			cnt=0
			while temp%i==0:
				cnt+=1
				temp //= i
			arr.append([i, cnt])

	if temp!=1:
		arr.append([temp, 1])

	if arr==[]:
		arr.append([n, 1])

	return arr

def cmb(n,r):
    r = min(n-r,r)
    if r == 0: return 1
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1,r + 1))
    return over // under

def zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

def gcd(numbers):
	return reduce(math.gcd, numbers)

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

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

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

class PriorityQueue():
	def __init__(self):
		self.queue = []
	def push(self,i):
		heapq.heappush(self.queue,-i)
	def pop(self):
		return -1 * heapq.heappop(self.queue)
	def sum(self):
		return -sum(self.queue)

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

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


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

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:
import sys
import math
import re
import io

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

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:
# coding: utf-8
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
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())
gd = math.gcd(A,B)
hf = A*B//gd
print(hf)

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

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

    
    return lcm(A,B)
print(solve())

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:
#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
import math
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


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

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


# region fastio

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == "__main__":
    main()

Submission status: Runtime Error

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


def read_values():
    return map(int, input().split())


def read_list():
    return list(read_values())


def read_lists(N):
    return [read_list() for n in range(N)]


import math
def main():
    A, B = read_values()
    print(int(A * B / math.gcd(A, B)))



if __name__ == "__main__":
    main()

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

def main():
    a,b = map(int,input().split())
    gcd = math.gcd(max(a,b),min(a,b))
    lcm = a*b//gcd

    print(lcm)

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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