Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
N = int(input())

a_list = []
for _ in range(N):
    a_list.append(int(input())

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

res = 1
for i in range(N):
    d = gcd(res, a_list[i])
    res = res // d
    res = res * a_list[i]

print(res) 
 

Fixed submission:
N = int(input())
 
a_list = []
for _ in range(N):
    a_list.append(int(input()))
 
def gcd(a, b):
    if a < b:
        a, b = b, a
    if b == 0:
        return a
    c = a % b
    return gcd(b, c)
 
res = 1
for i in range(N):
    d = gcd(res, a_list[i])
    res = res // d
    res = res * a_list[i]
 
print(res)
Buggy python submission (verdict: Time Limit Exceeded):
# A(300)
import math
import numpy as np
N, K = map(int, input().split())
A_np = np.array(list(map(int, input().split())))

if K > A_np.max():
    print("IMPOSSIBLE")
    
else:    
    L = 10**9+1
    l = math.ceil(math.sqrt(L)) + 1

    isprime = np.ones(l)
    isprime[0] = 0
    isprime[1] = 0
    for i in range(2, l):
        if isprime[i]:
            isprime[2*i:l:i] = 0


    # find LCM
    LCM = 1
    for p in range(l):
        if isprime[p]:
            while True:
                if (A_np % p).sum() == 0:
                    A_np = A_np // p
                    LCM *= p
                else:
                    A_np[A_np % p == 0] = A_np[A_np % p == 0] // p
                    break


    # rare case 
    # large p in common
    if A_np.max() == A_np.min():
        LCM *= A_np.max()
    else:
        LCM = 1
        
    if K % LCM == 0:
        print("POSSIBLE")
    else:
        print("IMPOSSIBLE")






Fixed submission:
# A(300)
N, K = map(int, input().split())
A_list = list(map(int, input().split()))


def gcd(x, y):
    if x < y:
        x, y = y, x
    while y > 0:
        r = x % y
        x = y
        y = r

    return x

# find LCM
LCM = A_list[0]
for i in range(1, N):
    LCM = gcd(LCM, A_list[i])
    
if K % LCM == 0 and K <= max(A_list):
    print("POSSIBLE")
else:
    print("IMPOSSIBLE")
Buggy python submission (verdict: Runtime Error):
# D
import numpy as np
N = int(input())
X = np.zeros(N, dtype=int)
Y = np.zeros(N, dtype=int)

for i in range(N):
    x, y = map(int, input().split())
    X[i] = x
    Y[i] = y

# edges
X_s = np.argsort(X)
Y_s = np.argsort(Y)

edge_list = []
edge_weight = []
for i in range(N-1):
    edge_list.append([X_s[i], X_s[i+1]])
    edge_weight.append(min(abs(X[X_s[i+1]] - X[X_s[i]]), abs(Y[X_s[i+1]] - Y[X_s[i]])))
    edge_list.append([Y_s[i], Y_s[i+1]])
    edge_weight.append(min(abs(X[Y_s[i+1]] - X[Y_s[i]]), abs(Y[Y_s[i+1]] - Y[Y_s[i]])))
    
# sort edges
sel = np.argsort(np.array(edge_weight))

res = 0
flg = np.zeros(N)

for s in sel:
    m, n = edge_list[s]
    if flg[m]*flg[n] > 0:
        pass
    else:
        res += edge_weight[s]
        flg[m] = 1
        flg[n] = 1
print(res)

Fixed submission:
# C
N, M = map(int, input().split())
L = 1000000007

res = 1

if (M - N) >= 2 or (N - M) >= 2:
    res = 0
else:
    for k in range(M):
        res *= (k+1)
        res = res % L
    for k in range(N):
        res *= (k+1)
        res = res % L
    if M == N:
        res *= 2
        res = res % L
print(res)
Buggy python submission (verdict: Runtime Error):
# D
res = 0

A = int(input())
B = int(input())

def pow2_floor_log2(x):
    res = 1
    while res*2 <= x:
        res *= 2
    return res


while True:
    # find log2A and log2B
    C = pow2_floor_log2(B)
    if A < C:
        # A to C
        res += C - A
        if B > C:
            B_ = C + pow2_floor_log2(B - C)*2 - 1
        if C + A <= B_:
            res += C
            break
        else:
            res += (C - A) + (B_ - C + 1)
            break
    else:
        A -= C
        B -= C

print(res)

Fixed submission:
# D
res = 0

A = int(input())
B = int(input())

def pow2_floor_log2(x):
    res = 1
    while res*2 <= x:
        res *= 2
    return res

if A == B:
    res += 1
    
while A < B:
    # find log2A and log2B
    C = pow2_floor_log2(B)
    if A < C:
        # A to C
        res += C - A
        if B > C:
            B_ = C + pow2_floor_log2(B - C)*2 - 1
        else:
            B_ = C
        if C + A <= B_:
            res += C
            break
        else:
            res += (C - A) + (B_ - C + 1)
            break
    else:
        A -= C
        B -= C

print(res)

Buggy python submission (verdict: Runtime Error):
# D
import math
res = 0

A = int(input())
B = int(input())


while True:
    # find log2A and log2B
    C = 2**math.floor(math.log2(B))
    if A < C:
        # A to C
        res += C - A
        if B > C:
            B_ = C + 2**math.floor(math.log2(B - C) + 1) - 1
        if C + A <= B_:
            res += C
            break
        else:
            res += (C - A) + (B_ - C + 1)
            break
    else:
        A -= C
        B -= C

print(res)

Fixed submission:
# D
res = 0

A = int(input())
B = int(input())

def pow2_floor_log2(x):
    res = 1
    while res*2 <= x:
        res *= 2
    return res

if A == B:
    res += 1
    
while A < B:
    # find log2A and log2B
    C = pow2_floor_log2(B)
    if A < C:
        # A to C
        res += C - A
        if B > C:
            B_ = C + pow2_floor_log2(B - C)*2 - 1
        else:
            B_ = C
        if C + A <= B_:
            res += C
            break
        else:
            res += (C - A) + (B_ - C + 1)
            break
    else:
        A -= C
        B -= C

print(res)
Buggy python submission (verdict: Runtime Error):
from collections import deque

G = dict()
N, M = map(int, input().split())
color = [0]*(N+1)
for n in range(1, N+1):
    G[n] = []
for _ in range(M):
    a, b = map(int, input().split())
    G[a].append(b)
    G[b].append(a)
Q = int(input())




data = [list(map(int, input().split())) for _ in range(Q)]
data.reverse()
color_d = [-1]*(N+1)

for v, d, c in data:
    if color_d[v] >= d:
        pass
    # BFS
    deq = deque([v])
    if color[v] == 0:
        color[v] = c
    color_d[v] = d
    while len(deq) > 0:
        s = deq.popleft()
        for t in G[s]:
            if color_d[t] >= color_d[s] - 1:
                pass
            else:
                color_d[t] = color_d[s] - 1
                if color[t] == 0:
                    color[t] = c
                if color_d[t] > 0:
                    deq.append(t)
                
for n in range(1, N+1):
    print(color[n])
                



Fixed submission:
import numpy as np
N = int(input())
a = np.array(list(map(int, input().split())))
a.sort()
print(a[N:(3*N):2].sum())
Buggy python submission (verdict: Runtime Error):
x = int(raw_input())
if x < 1200:
    print('ABC')
else:
    print('ARC')

Fixed submission:
x = int(input())
if x < 1200:
    print('ABC')
else:
    print('ARC')
Buggy python submission (verdict: Runtime Error):
S = raw_input()

def pick_greedy(S):
    if S[0:5] == 'dream':
        if S[5:7] == 'er':
            if S[7] == 'a':
                ret = 'dream'
            else:
                ret = 'dreamer'
        else:
            ret = 'dream'
    elif S[0:5] == 'erase':
        if S[5] == 'r':
            ret = 'eraser'
        else:
            ret = 'erase'
    else:
        ret = 'no'
    return ret

sol = 'YES'

while len(S) > 0:
    r = pick_greedy(S)
    if r == 'no':
        sol = 'NO'
        break
    else:
        if len(S) < len(r):
            sol = 'NO'
            break
        else:
            S = S[len(r):]
        
print sol

Fixed submission:
S = raw_input()

def pick_greedy(S):
    if S[0:5] == 'dream':
        if S[5:7] == 'er':
            if S[7] == 'a':
                ret = 'dream'
            else:
                ret = 'dreamer'
        else:
            ret = 'dream'
    elif S[0:5] == 'erase':
        if S[5] == 'r':
            ret = 'eraser'
        else:
            ret = 'erase'
    else:
        ret = 'no'
    return ret

sol = 'YES'

while len(S) > 0:
    try:
        r = pick_greedy(S)
        if r == 'no':
            sol = 'NO'
            break
        else:
            if len(S) < len(r):
                sol = 'NO'
                break
            else:
                S = S[len(r):]
    except:
        sol = 'YES'
        break
        
print sol

Buggy python submission (verdict: Runtime Error):
S = raw_input()

def pick_greedy(S):
    if S[0:5] == 'dream':
        if S[5:7] == 'er':
            if S[7] == 'a':
                ret = 'dream'
            else:
                ret = 'dreamer'
        else:
            ret = 'dream'
    elif S[0:5] == 'erase':
        if S[5] == 'r':
            ret = 'eraser'
        else:
            ret = 'erase'
    else:
        ret = 'no'
    return ret

sol = 'YES'

while len(S) > 0:
    r = pick_greedy(S)
    if r == 'no':
        sol = 'NO'
        break
    else:
        S = S[len(r):]
        
print sol

Fixed submission:
S = raw_input()

def pick_greedy(S):
    if S[0:5] == 'dream':
        if S[5:7] == 'er':
            if S[7] == 'a':
                ret = 'dream'
            else:
                ret = 'dreamer'
        else:
            ret = 'dream'
    elif S[0:5] == 'erase':
        if S[5] == 'r':
            ret = 'eraser'
        else:
            ret = 'erase'
    else:
        ret = 'no'
    return ret

sol = 'YES'

while len(S) > 0:
    try:
        r = pick_greedy(S)
        if r == 'no':
            sol = 'NO'
            break
        else:
            if len(S) < len(r):
                sol = 'NO'
                break
            else:
                S = S[len(r):]
    except:
        sol = 'YES'
        break
        
print sol
Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np
from collections import deque

xs, ys, xt, yt = map(int, raw_input().split())
N = int(raw_input())
X = [xs]
Y = [ys]
R = [0]
for _ in range(N):
    x, y, r = map(int, raw_input().split())
    X.append(x)
    Y.append(y)
    R.append(r)
X.append(xt)
Y.append(yt)
R.append(0)

X_np = np.array(X)
Y_np = np.array(Y)
R_np = np.array(R)

dist = np.zeros((N+2, N+2))
for i in range(N+2):
    dist[i, :] = np.maximum(np.sqrt((X_np - X_np[i])**2 + (Y_np - Y_np[i])**2) - (R_np + R_np[i]), 0)

cost = 2000000000.0 * np.ones(N+2)
cost[0] = 0
# with minnimum cost
q = 0
unfixed_list = range(N+2)

while len(unfixed_list) > 0:
    new_cost = cost[q] + dist[q, :]
    cost = np.minimum(cost, new_cost)
    q = unfixed_list[cost[unfixed_list].argmin()]
    

print cost[N+1]

Fixed submission:
import numpy as np
from collections import deque

xs, ys, xt, yt = map(int, raw_input().split())
N = int(raw_input())
X = [xs]
Y = [ys]
R = [0]
for _ in range(N):
    x, y, r = map(int, raw_input().split())
    X.append(x)
    Y.append(y)
    R.append(r)
X.append(xt)
Y.append(yt)
R.append(0)

X_np = np.array(X)
Y_np = np.array(Y)
R_np = np.array(R)

dist = np.zeros((N+2, N+2))
for i in range(N+2):
    dist[i, :] = np.maximum(np.sqrt((X_np - X_np[i])**2 + (Y_np - Y_np[i])**2) - (R_np + R_np[i]), 0)

cost = 4000000000.0 * np.ones(N+2)
cost[0] = 0
# with minnimum cost
q = 0
unfixed_list = range(N+2)
unfixed_list.remove(q)


while len(unfixed_list) > 0:
    new_cost = cost[q] + dist[q, :]
    cost = np.minimum(cost, new_cost)
    q = unfixed_list[cost[unfixed_list].argmin()]
    unfixed_list.remove(q)
    

print cost[N+1]
Buggy python submission (verdict: Runtime Error):
W, H = map(int, raw_input().split())

p_list = list()
q_list = list()

for i in range(W):
    p_list.append(int(raw_input()))
    
for j in range(H):
    q_list.append(int(raw_input()))

p_list.sort()
q_list.sort()

cp = H+1
cq = W+1

res = 0
pid = 0
qid = 0

while True:
    if pid == H:
        if qid == W:
            break
        else:
            choice = 'q'
    elif qid == W:
        choice = 'p'
    elif p_list[pid] < q_list[qid]:
        choice = 'p'
    else:
        choice = 'q'
    if choice == 'p':
        cq -= 1
        res += cp*p_list[pid]
        pid += 1
    else:
        cp -= 1
        res += cq*q_list[qid]
        qid += 1

print res 

Fixed submission:
W, H = map(int, raw_input().split())

p_list = list()
q_list = list()

for i in range(W):
    p_list.append(int(raw_input()))
    
for j in range(H):
    q_list.append(int(raw_input()))

p_list.sort()
q_list.sort()

cp = H+1
cq = W+1

res = 0
pid = 0
qid = 0

while True:
    if pid == W:
        if qid == H:
            break
        else:
            choice = 'q'
    elif qid == H:
        choice = 'p'
    elif p_list[pid] < q_list[qid]:
        choice = 'p'
    else:
        choice = 'q'
    if choice == 'p':
        cq -= 1
        res += cp*p_list[pid]
        pid += 1
    else:
        cp -= 1
        res += cq*q_list[qid]
        qid += 1

print res

Buggy python submission (verdict: Time Limit Exceeded):
W, H = map(int, raw_input().split())

p_list = list()
q_list = list()

for i in range(W):
    p_list.append(int(raw_input()))
    
for j in range(H):
    q_list.append(int(raw_input()))

p_list.sort()
q_list.sort()

cp = H+1
cq = W+1

res = 0

while len(p_list) + len(q_list) > 0:
    if len(p_list) == 0:
        choice = 'q'
    elif len(q_list) == 0:
        choice = 'p'
    elif p_list[0] < q_list[0]:
        choice = 'p'
    else:
        choice = 'q'
    if choice == 'p':
        cq -= 1
        res += cp*p_list.pop(0)
    else:
        cp -= 1
        res += cq*q_list.pop(0)

print res 

Fixed submission:
W, H = map(int, raw_input().split())

p_list = list()
q_list = list()

for i in range(W):
    p_list.append(int(raw_input()))
    
for j in range(H):
    q_list.append(int(raw_input()))

p_list.sort()
q_list.sort()

cp = H+1
cq = W+1

res = 0
pid = 0
qid = 0

while True:
    if pid == W:
        if qid == H:
            break
        else:
            choice = 'q'
    elif qid == H:
        choice = 'p'
    elif p_list[pid] < q_list[qid]:
        choice = 'p'
    else:
        choice = 'q'
    if choice == 'p':
        cq -= 1
        res += cp*p_list[pid]
        pid += 1
    else:
        cp -= 1
        res += cq*q_list[qid]
        qid += 1

print res
Buggy python submission (verdict: Runtime Error):
x_vec = map(int, raw_input().split())
ret = 0
for i in range(len(x_vec)):
    if x_vec[x_vec[i]] == i:
        ret += 1 
print ret / 2

Fixed submission:
N = int(raw_input())
x_vec = map(int, raw_input().split())
ret = 0
for i in range(len(x_vec)):
    if x_vec[x_vec[i] - 1] == i + 1:
        ret += 1 
print ret / 2
Buggy python submission (verdict: Time Limit Exceeded):
H, W, N = map(int, raw_input().split())
D = dict()

for i in range(N):
    a, b = map(int, raw_input().split())
    for a_add in [-1, 0, 1]:
        for b_add in [-1, 0, 1]:
            c = a + a_add
            d = b + b_add
            if c-1 in range(1, H-1) and d-1 in range(1, W-1):
                if str([c, d]) in D.keys():
                    D[str([c, d])] += 1
                else:
                    D[str([c, d])] = 1

res_list = [0]*10
for s in D.keys():
    res_list[D[s]] += 1

res_list[0] = (H-2) * (W-2) - sum(res_list)

for i in range(10):
    print res_list[i]

Fixed submission:
H, W, N = map(int, raw_input().split())
D = dict()

for i in range(N):
    a, b = map(int, raw_input().split())
    for a_add in [-1, 0, 1]:
        for b_add in [-1, 0, 1]:
            c = a + a_add
            d = b + b_add
            if c-1 in range(1, H-1) and d-1 in range(1, W-1):
                if D.has_key(str([c, d])):
                    D[str([c, d])] += 1
                else:
                    D[str([c, d])] = 1

res_list = [0]*10
for s in D.keys():
    res_list[D[s]] += 1

res_list[0] = (H-2) * (W-2) - sum(res_list)

for i in range(10):
    print res_list[i]

Buggy python submission (verdict: Time Limit Exceeded):
H, W, N = map(int, raw_input().split())
D = dict()

for i in range(N):
    a, b = map(int, raw_input().split())
    for a_add in [-1, 0, 1]:
        for b_add in [-1, 0, 1]:
            c = a + a_add
            d = b + b_add
            if c-1 in range(1, H-1) and d-1 in range(1, W-1):
                if str([c, d]) in D.keys():
                    D[str([c, d])] += 1
                else:
                    D[str([c, d])] = 1

res_list = [0]*10
for s in D.keys():
    res_list[D[s]] += 1

res_list[0] = (H-2) * (W-2) - sum(res_list)

for i in range(10):
    print res_list[i]

Fixed submission:
H, W, N = map(int, raw_input().split())
D = dict()

for i in range(N):
    a, b = map(int, raw_input().split())
    for a_add in [-1, 0, 1]:
        for b_add in [-1, 0, 1]:
            c = a + a_add
            d = b + b_add
            if c-1 in range(1, H-1) and d-1 in range(1, W-1):
                if D.has_key(str([c, d])):
                    D[str([c, d])] += 1
                else:
                    D[str([c, d])] = 1

res_list = [0]*10
for s in D.keys():
    res_list[D[s]] += 1

res_list[0] = (H-2) * (W-2) - sum(res_list)

for i in range(10):
    print res_list[i]
Buggy python submission (verdict: Runtime Error):
x, k, d = list(map(lambda x: int(x), input().split()))

min_pos = x % d
min_neg = min_pos - d

num_to_min_pos = x // d
if k <= num_to_min_pos:
    print(x - d * k)
    
else:
    if (k - num_to_min_pos) % 2 == 0:
        print(min_pos)
    else:
        print(abs(min_neg))


Fixed submission:
import re
s = input()
array = re.split(r'S+', s)
print(max([len(e) for e in array]))
Buggy python submission (verdict: Runtime Error):
x, k, d = list(map(lambda x: int(x), input().split()))

min_pos = x % d
min_neg = min_pos - d

num_to_min_pos = x // d
if k <= num_to_min_pos:
    print(x - d * k)
    
else:
    if (k - num_to_min_pos) % 2 == 0:
        print(min_pos)
    else:
        print(abs(min_neg)


Fixed submission:
x, k, d = list(map(lambda x: int(x), input().split()))


x = abs(x)
min_pos = x % d
min_neg = min_pos - d

num_to_min_pos = x // d
if k <= num_to_min_pos:
    print(x - d * k)
    
else:
    if (k - num_to_min_pos) % 2 == 0:
        print(min_pos)
    else:
        print(abs(min_neg))
Buggy python submission (verdict: Runtime Error):
import sys
k = int(input())

remainders = set()
remainder = 7 % k
remainders.add(remainder)

counter = 1
while True:
    counter += 1
    remainder = remainder * 10 % k
    if remainder in remainders:
        print('-1')
        sys.exit()
    remainders.add(remainder)
    print(remainders)
    if sum(remainders) % k == 0:
        print(counter)
        sys.exit()

Fixed submission:
import sys

k = int(input())
n = 7
counter = 1
remainders = set()

while True:
    remainder = n % k
    if remainder == 0:
        print(counter)
        sys.exit()
    if remainder in remainders:
        print(-1)
        sys.exit()
    remainders.add(remainder)
    
    n = remainder * 10 + 7
    counter += 1

Buggy python submission (verdict: Runtime Error):
import sys
k = int(input())

remainders = set()
current_remainder = 7 % k
remainders.add(current_remainder)

counter = 1
while True:
    counter += 1
    remainder = remainder * 10 % k
    if remainder in remainders:
        print('-1')
        sys.exit()
    remainders.add(remainder)
    print(remainders)
    if sum(remainders) % k == 0:
        print(counter)
        sys.exit()

Fixed submission:
import sys

k = int(input())
n = 7
counter = 1
remainders = set()

while True:
    remainder = n % k
    if remainder == 0:
        print(counter)
        sys.exit()
    if remainder in remainders:
        print(-1)
        sys.exit()
    remainders.add(remainder)
    
    n = remainder * 10 + 7
    counter += 1
Buggy python submission (verdict: Time Limit Exceeded):
import sys
def first_white(c):
    for i,ele in enumerate(c):
        if ele == 0:
            return i
    return -1
        
def last_red(c):
    for i in range(len(c)-1, -1, -1):
        if c[i] == 1:
            return i
    return -1
  
n = int(input())
c = [0 if x=='W' else 1 for x in input()]
counter = 0
while True:
    first_w = first_white(c)
    last_r = last_red(c)
    if (len(c) == 0) or (first_w < 0) or (last_r < 0) or (last_r < first_w):
        print(counter)
        sys.exit()
    c = c[first_w+1:last_r]    
    counter += 1

Fixed submission:
import sys

n = int(input())
c = [0 if x=='W' else 1 for x in input()]
counter = 0

white_index = [i for i,ele in enumerate(c) if ele == 0]
red_index = [i for i in range(len(c)-1, -1, -1) if c[i] == 1]
    
    
for i in range(min(len(white_index), len(red_index))):
    if white_index[i] < red_index[i]:
        counter += 1
print(counter)
Buggy python submission (verdict: Runtime Error):
a,b,c = map(lambda x: int(x), input().split())
k = int(input())

for _ in range(k):
    if b < a:
        b = 2 * b
        continue
    if c < b:
        c = 2 * c
        continue
    print('Yes')
    sys.exit()
print('No')

Fixed submission:
import sys
 
def main():
  a,b,c = map(lambda x: int(x), input().split())
  k = int(input())
 
  for _ in range(k):
      if b <= a:
          b = 2 * b
          continue
      if c <= b:
          c = 2 * c
          continue
      print('Yes')
      return
 
  if (a < b) & (b < c):
      print('Yes')
      return
  print('No')
 
if __name__ == '__main__':
    main()
Buggy python submission (verdict: Runtime Error):
n = int(input())
a_list = list(map(lambda x: int(x), input().split()))
possesion = 1000
num_stock = 0

for i in range(len(a_list) - 1):
    a_today = a_list[i]
    for a in a_list[i+1:]:
        if a != a_today:
            a_next = a
            break
    
    if a_today < a_next:
        # 買えるだけ買う
        possesion_yesterday = possesion
        possesion = possesion % a_today
        num_stock += possesion_yesterday // a_today
    if a_today > a_next:
        # うれるだけうる
        possesion += num_stock * a_today
        num_stock = 0

# 最終日は買えるだけ買う
possesion += num_stock * a_list[-1]
print(possesion)

Fixed submission:
import sys

n = int(input())
a_list = list(map(lambda x: int(x), input().split()))
possesion = 1000
num_stock = 0

# print(a_list)
for i in range(len(a_list) - 1):
    a_today = a_list[i]
    for a in a_list[i+1:]:
        a_next = a
        if a != a_today:
            break
    # これからずっと値段が変わらない場合は全部売ってあと放置
    if a_next == a_today:
        possesion += num_stock * a_list[-1]
        print(possesion)
        sys.exit()
    
    if a_today < a_next:
        # 買えるだけ買う
        possesion_yesterday = possesion
        possesion = possesion % a_today
        num_stock += possesion_yesterday // a_today
    if a_today > a_next:
        # うれるだけうる
        possesion += num_stock * a_today
        num_stock = 0
#     print(a_today, a_next, possesion, num_stock)

# 最終日は買えるだけ買う
possesion += num_stock * a_list[-1]
print(possesion)
Buggy python submission (verdict: Runtime Error):
def main():
  name = input()
  print(name)
	
  
  
  
if __name__ == '__main__'
	main()

Fixed submission:
name = input('')
print(name[:3])

Buggy python submission (verdict: Runtime Error):
def main():
  name = input()
  print name
	
  
  
  
if __name__ == '__main__'
	main()

Fixed submission:
name = input('')
print(name[:3])