Buggy python submission (verdict: Runtime Error):
from functools import reduce
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))
T.sort()

def gcd(m,n):
    if n == 0:
        return m
    return gcd(n,m%n)
    
def lcm(m,n):
    return int(m * n/gcd(m,n))

print(reduce(lcm,T))

Fixed submission:
from functools import reduce
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))

def gcd(m,n):
    if n == 0:
        return m
    return gcd(n,m%n)
    
def lcm(m,n):
    return m * n//gcd(m,n)

print(reduce(lcm,T))

Buggy python submission (verdict: Runtime Error):
from functools import reduce
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))
T.sort()
ans = 1
def gcd(m,n):
    x = max(m,n)
    y = min(m,n)
    if y == 0:
        return x
    else:
        return gcd(y,x%y)
    
def lcm(m,n):
    return int(m * n/gcd(m,n))

print(reduce(lcm,T))

Fixed submission:
from functools import reduce
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))

def gcd(m,n):
    if n == 0:
        return m
    return gcd(n,m%n)
    
def lcm(m,n):
    return m * n//gcd(m,n)

print(reduce(lcm,T))

Buggy python submission (verdict: Runtime Error):
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))
T.sort()
ans = 1
def gcd(m,n):
    x = max(m,n)
    y = min(m,n)
    if y == 0:
        return x
    else:
        return gcd(y,x%y)
    
def lcm(m,n):
    return int(m * n/gcd(m,n))

for j in range(N):
    ans = lcm(ans,T[j])
        
print(ans)

Fixed submission:
from functools import reduce
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))

def gcd(m,n):
    if n == 0:
        return m
    return gcd(n,m%n)
    
def lcm(m,n):
    return m * n//gcd(m,n)

print(reduce(lcm,T))

Buggy python submission (verdict: Runtime Error):
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))
T.sort()
ans = 1
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))

for j in range(N):
    ans = lcm(ans,T[j])
        
print(ans)

Fixed submission:
from functools import reduce
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))

def gcd(m,n):
    if n == 0:
        return m
    return gcd(n,m%n)
    
def lcm(m,n):
    return m * n//gcd(m,n)

print(reduce(lcm,T))

Buggy python submission (verdict: Runtime Error):
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))
T.sort()
ans = 1
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))

for j in range(N):
    ans = lcm(ans,T[j])
        
print(ans)

Fixed submission:
from functools import reduce
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))

def gcd(m,n):
    if n == 0:
        return m
    return gcd(n,m%n)
    
def lcm(m,n):
    return m * n//gcd(m,n)

print(reduce(lcm,T))

Buggy python submission (verdict: Runtime Error):
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))
T.sort()
ans = 1

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

ans = 1
for j in range(N):
    ans = lcm(ans,T[j])
        
print(ans)

Fixed submission:
from functools import reduce
N = int(input())
T = []
for i in range(N):
    T.append(int(input()))

def gcd(m,n):
    if n == 0:
        return m
    return gcd(n,m%n)
    
def lcm(m,n):
    return m * n//gcd(m,n)

print(reduce(lcm,T))