Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
a=input()
b=input()
s=[]
if len(a)==len(b):
    for i in range(len(a)):
        s.append(a[i])
        s.append(b[i])
else:
    for i in range(len(b)):
        s.append(a[i])
        s.append(b[i])
    s.append(a[-1])
print("".join(s))

Fixed submission:
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a,b,c = map(int, input().split())
if  (b−a) == (c−b):
    print("YES")
else:
    print("NO")

Fixed submission:
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a,b,c = map(int, input().split())
if  b−a == c−b:
    print("YES")
else:
    print("NO")

Fixed submission:
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a, b, c = map(int, input().split())
if  b−a == c−b:
    print("YES")
else:
    print("NO")

Fixed submission:
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a, b, c = map(int, input().split())
if  b−a == c−b:
  print("YES")
else:
  print("NO")

Fixed submission:
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a, b, c = map(int, input().split())
if  b−a == c−b:
  print ("YES")
else:
  print ("NO")

Fixed submission:
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a, b, c = map(int, input().split().split())
if  b−a == c−b:
  print ("YES")
else:
  print ("NO")

Fixed submission:
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a, b, c = map(int, input().split().split())
if  b−a == c−b:
  print ("YES")
else:
  print ("NO")

Fixed submission:
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a, b, c = map(int, input().split().split())
if  b−a == c−b:
  print ("YES")
else:
 print("NO")

Fixed submission:
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a, b, c = map(int, input().split().split())
if  b−a==c−b:
  print ("YES")
elif print("NO")

Fixed submission:
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a, b, c = map(int, input().split().split())
if  b−a=c−b:
  print ("YES")
elif print("NO")

Fixed submission:
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")
Buggy python submission (verdict: Runtime Error):
a=input()
b=input()
s=[]
if len(a)==len(b):
    for i in range(len(a)):
        s.append(a[i])
        s.append(b[i])
else:
    for i in range(len(b)):
        s.append(a[i])
        s.append(b[i])
    s.append(a[range(len(b))+1])
print("".join(s))

Fixed submission:
a=input()
b=input()
s=[]
if len(a)==len(b):
    for i in range(len(a)):
        s.append(a[i])
        s.append(b[i])
else:
    for i in range(len(b)):
        s.append(a[i])
        s.append(b[i])
    s.append(a[-1])
print("".join(s))

Buggy python submission (verdict: Runtime Error):
a=input()
b=input()
s=[]
for i in range(len(a)):
    s.append(a[i])
    s.append(b[i])
print("".join(s))

Fixed submission:
a=input()
b=input()
s=[]
if len(a)==len(b):
    for i in range(len(a)):
        s.append(a[i])
        s.append(b[i])
else:
    for i in range(len(b)):
        s.append(a[i])
        s.append(b[i])
    s.append(a[-1])
print("".join(s))

Buggy python submission (verdict: Runtime Error):
a=input()
b=input()
s=[]
for i in range(a):
    s.append(a[i])
    s.append(b[i])
print("".join(s))

Fixed submission:
a=input()
b=input()
s=[]
if len(a)==len(b):
    for i in range(len(a)):
        s.append(a[i])
        s.append(b[i])
else:
    for i in range(len(b)):
        s.append(a[i])
        s.append(b[i])
    s.append(a[-1])
print("".join(s))

Buggy python submission (verdict: Runtime Error):
a=input()
b=input()
s=[]
for i in range(a):
    s=append(s,a(i),b(i))


Fixed submission:
a=input()
b=input()
s=[]
if len(a)==len(b):
    for i in range(len(a)):
        s.append(a[i])
        s.append(b[i])
else:
    for i in range(len(b)):
        s.append(a[i])
        s.append(b[i])
    s.append(a[-1])
print("".join(s))
Buggy python submission (verdict: Runtime Error):
a, b=map(int, input().split())
2.c=a+b
3.if c<24:
4.  print (c)
5.elif c>=24:
6.  print (c-24)


Fixed submission:
a, b=map(int, input().split())
c=a+b
if c<24:
  print (c)
elif c>=24:
  print (c-24)
Buggy python submission (verdict: Runtime Error):
a= int(input())
b=int(input())
if a+b >= 10:
    print('error')
else:
    print(a+b)


Fixed submission:
rawIn= input()
rawIn= rawIn.split(' ')
a=int(rawIn[0])
b=int(rawIn[1])
if a+b >= 10:
    print('error')
else:
    print(a+b)
Buggy python submission (verdict: Runtime Error):
 b.py  a.py                                                                    X
l = raw_input().split(" ")


a=[1,3,5,7,8,10,12]
b=[4,6,9,11]
c=[2]

ans="No"

if (l[0] in a and l[1] in a):
    ans="Yes"
if (l[0] in b and l[1] in b):
    ans="Yes"
if (l[0] in c and l[1] in c):
    ans="Yes"

print(ans)


Fixed submission:
l = raw_input().split(" ")
#print(l[0])
#print(l[1])

a=[1,3,5,7,8,10,12]
b=[4,6,9,11]
c=[2]

ans="No"


if (int(l[0]) in a and int(l[1]) in a):
    ans="Yes"

if (int(l[0]) in b and int(l[1]) in b):
    ans="Yes"

if (int(l[0]) in c and int(l[1]) in c):
    ans="Yes"

print(ans)

Buggy python submission (verdict: Runtime Error):
 b.py  a.py                                                                    X
l = raw_input().split(" ")


a=[1,3,5,7,8,10,12]
b=[4,6,9,11]
c=[2]

ans="No"

if (l[0] in a and l[1] in a):
    ans="Yes"
if (l[0] in b and l[1] in b):
    ans="Yes"
if (l[0] in c and l[1] in c):
    ans="Yes"

print(ans)


Fixed submission:
l = raw_input().split(" ")
#print(l[0])
#print(l[1])

a=[1,3,5,7,8,10,12]
b=[4,6,9,11]
c=[2]

ans="No"


if (int(l[0]) in a and int(l[1]) in a):
    ans="Yes"

if (int(l[0]) in b and int(l[1]) in b):
    ans="Yes"

if (int(l[0]) in c and int(l[1]) in c):
    ans="Yes"

print(ans)

Buggy python submission (verdict: Runtime Error):
l = raw_input().split(" ")


a=[1,3,5,7,8,10,12]
b=[4,6,9,11]
c=[2]

ans="NO"

if (l[0] in a and l[1] in a):
    ans="YES"
if (l[0] in b and l[1] in b):
    ans="YES"
if (l[0] in c and l[1] in c):
    ans="YES"

print(ans)


Fixed submission:
l = raw_input().split(" ")
#print(l[0])
#print(l[1])

a=[1,3,5,7,8,10,12]
b=[4,6,9,11]
c=[2]

ans="No"


if (int(l[0]) in a and int(l[1]) in a):
    ans="Yes"

if (int(l[0]) in b and int(l[1]) in b):
    ans="Yes"

if (int(l[0]) in c and int(l[1]) in c):
    ans="Yes"

print(ans)
Buggy python submission (verdict: Runtime Error):
N, M = map(int ,raw_input().split())
s="#"*(M+2)
a=[]

a.append(s)
for i in range(N):
    a.append("#"+raw_input()+"#")

a.append(s)

for i in range(N+2):
    print(a[i])


Fixed submission:
N, M = map(int ,raw_input().split())
s="#"*(M+2)
a=[]

a.append(s)
for i in range(N):
    a.append("#"+raw_input()+"#")
a.append(s)

for i in range(N+2):
    print(a[i])
Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin

k, s = map(int, stdin.readline().split())

result = set()


def get_variants(target, maximum):
    result = []
    for x in range(maximum, -1, -1):
        y = target - x
        if 0 <= y <= maximum:
            result.append([x, y])
    return result

for z in range(k+1):
    variants = get_variants(s - z, k)
    for var in variants:
        result.add((z, var[0], var[1]))

print(len(result))


Fixed submission:
from sys import stdin

k, s = map(int, stdin.readline().split())

result = 0


def get_variants(target, maximum):
    result = 0
    for x in range(maximum, -1, -1):
        y = target - x
        if 0 <= y <= maximum:
            result += 1
    return result

for z in range(k+1):
    variants = get_variants(s - z, k)
    result += variants

print(result)
Buggy python submission (verdict: Runtime Error):
from sys import stdin

a = map((int(x) for x in stdin.readline().split()))

print(len(a))


Fixed submission:
from sys import stdin

a = set((int(x) for x in stdin.readline().split()))

print(len(a))
Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin

n = int(stdin.readline())

t_votes, a_votes = (int(x) for x in stdin.readline().split())

p_t, p_a = t_votes, a_votes

for _ in range(n-1):
    t, a = (int(x) for x in stdin.readline().split())
    if (t, a) == (p_t, p_a):
        continue
    for i in range(1, 1000000):
        t_v, a_v = t * i, a * i
        if t_v >= t_votes and a_v >= a_votes:
            break
    t_votes, a_votes = t_v, a_v
    p_t, p_a = t, a

print(t_votes + a_votes)


Fixed submission:
from sys import stdin

n = int(stdin.readline())

m = 10 ** 18 + 7


t_votes, a_votes = (int(x) for x in stdin.readline().split())

p_t, p_a = t_votes, a_votes

for _ in range(n-1):
    t, a = (int(x) for x in stdin.readline().split())
    if (t, a) == (p_t, p_a):
        continue
    for i in range(max(t_votes // t, a_votes // a) - 1, m):
        t_v, a_v = t * i, a * i
        if t_v >= t_votes and a_v >= a_votes:
            break
    t_votes, a_votes = t_v, a_v
    p_t, p_a = t, a

print(t_votes + a_votes)
Buggy python submission (verdict: Runtime Error):
group =[0,1,3,1,2,1,2,1,1,2,1,2,1]

input_lines=raw_input()
input_numbers=input_lines.split()
n=map(int,input_numbers)

if group[n[0]] == group[n[1]]
    print "Yes"
else:
    print "NO"

Fixed submission:
#coding: utf-8

group={'a':[1,3,5,7,8,10,12],'b':[4,6,9,11],'c':[2]}

input_lines=raw_input()
input_numbers=input_lines.split()
n=map(int,input_numbers)#n[0]とn[1]に数字

first_group = False
second_group = False

for i in group:
    for j in range(0,len(group[i])):
        if group[i][j] == n[0]:
            first_group = True
        if group[i][j] == n[1]:
            second_group = True
    if first_group == True and second_group==False or first_group == False and second_group == True:
        print "No"
        break

if first_group and second_group:
    print "Yes"

Buggy python submission (verdict: Runtime Error):
coding: utf-8

group={'a':[1,3,5,7,8,10,12],'b':[4,6,9,11],'c':[2]}

input_lines=raw_input()
input_numbers=input_lines.split()
n=map(int,input_numbers)#n[0]とn[1]に数字

first_group = False
second_group = False

for i in group:
    for j in range(0,len(group[i])):
        if group[i][j] == n[0]:
            first_group = True
        if group[i][j] == n[1]:
            second_group = True
    if first_group == True and second_group==False or first_group == False and second_group == True:
        print "No"
        break

if first_group and second_group:
    print "Yes"

Fixed submission:
#coding: utf-8

group={'a':[1,3,5,7,8,10,12],'b':[4,6,9,11],'c':[2]}

input_lines=raw_input()
input_numbers=input_lines.split()
n=map(int,input_numbers)#n[0]とn[1]に数字

first_group = False
second_group = False

for i in group:
    for j in range(0,len(group[i])):
        if group[i][j] == n[0]:
            first_group = True
        if group[i][j] == n[1]:
            second_group = True
    if first_group == True and second_group==False or first_group == False and second_group == True:
        print "No"
        break

if first_group and second_group:
    print "Yes"
Buggy python submission (verdict: Runtime Error):
coding:utf-8
import sys

H,W = raw_input().split()
a =[]
for line in range(int(H)):
    a.append(raw_input())

print a

for i in range(0,int(W)+2):
    sys.stdout.write("#")
print

for i in range(0,int(H)):
    sys.stdout.write("#")
    for j in range(0,int(W)):
        sys.stdout.write(a[i][j])
    sys.stdout.write("#")
    print

for i in range(0,int(W)+2):
    sys.stdout.write("#")
print

Fixed submission:
import sys

H,W = raw_input().split()
a =[]
for line in range(int(H)):
    a.append(raw_input())

for i in range(0,int(W)+2):
    sys.stdout.write("#")
print

for i in range(0,int(H)):
    sys.stdout.write("#")
    for j in range(0,int(W)):
        sys.stdout.write(a[i][j])
    sys.stdout.write("#")
    print

for i in range(0,int(W)+2):
    sys.stdout.write("#")
print
Buggy python submission (verdict: Runtime Error):
def max_score(edge,N):
    inf =float("inf")
    w = [-inf for i in range(int(N)+1)]
    w[1] = 0;
    while True:
        update = False
        negative = False
        for e in edge:
            if e[0] > e[1] and e[2]>0:
                negative = True
                update = True
                break

            elif w[e[0]] != -inf and w[e[1]] < w[e[0]]+e[2] and e[0] < e[1]:
                w[e[1]] = w[e[0]]+e[2]
                update = True

        if not update:
            break

    if not negative:
        return w[int(N)]
    else:
        return "inf"


N, M = raw_input().split()
edge = []
for i in range(int(M)):
    edge.append(map(int,raw_input().split()))

print max_score(edge,int(N))

Fixed submission:
#coding:utf-8

input_lines = raw_input().split()
n = map(int,input_lines)

if n[0] <= n[2] and n[2]<=n[1]:
    print "Yes"
else:
    print "No"
Buggy python submission (verdict: Runtime Error):
from math import sqrt

class Edge:
    def __init__(self, to, cost):
        self.to = to
        self.cost = cost

def dijkstra(G, s):
    from heapq import heappush, heappop
    l = len(G)
    dist = [float('inf')] * l
    done = [False] * l
    dist[s] = 0
    pq = []
    heappush(pq, (0, s))
    while pq:
        c, v = heappop(pq)
        done[v] = True
        for e in G[v]:
            cost = dist[v] + e.cost
            if cost < dist[e.to] and not done[e.to]:
                dist[e.to] = cost
                heappush(pq, (cost, e.to))
    return dist

xs, ys, xt, yt = map(int, input().split())
N = int(input())
xyr = [[int(i) for i in input().split()] for _ in range(N)]
xyr += [[xs, ys, 0], [xt, yt, 0]]

G = [[] for _ in range(N + 2)]

for i, (x, y, r) in enumerate(xyr):
    for j, (x2, y2, r2) in enumerate(xyr[i + 1:]):
        w = max(0, sqrt((x - x2)**2 + (y - y2)**2) - r - r2)
        G[i].append(Edge(i + j + 1, w))
        G[i + j + 1].append(Edge(i, w))

print(dijkstra(G, len(G) - 2)[-1])


Fixed submission:
_, x = map(int, input().split())
a = [int(i) for i in input().split()]
cnt = 0

for i in range(len(a) - 1):
    s = a[i] + a[i + 1]
    if x < s:
        sub = s - x
        a[i + 1] = max(0, a[i + 1] - sub)
        cnt += sub
print(cnt)
Buggy python submission (verdict: Runtime Error):
N, M = map(int, input().split())
m_list = [0] * (N + 1)
for i in range(M):
    a, b = map(int, input().split())
    m_list[a] += 1
    m_list[b] += 1
for j in m_list[1:]:
    print(j)


Fixed submission:
a, b, c = map(int, input().split())
if a <= c <= b:
    print("Yes")
else:
    print("No")
Buggy python submission (verdict: Time Limit Exceeded):
S = input()
T = input()
q = int(input())
A = [list(map(int, input().split())) for _ in range(q)]

for i in range(q):
  count_s = {"A": 0, "B": 0}
  count_t = {"A": 0, "B": 0}
  for j in range(A[i][0]-1, A[i][1]):
    if(S[j] == "B"):
      count_s["B"] += 1
    else:
      count_s["A"] += 1
  for k in range(A[i][2]-1, A[i][3]):
    if(T[k] == "B"):
      count_t["B"] += 1
    else:
      count_t["A"] += 1

  if(count_s["A"] - count_t["A"] > 0):
    tmp = count_s["A"] - count_t["A"] - (count_s["B"] - count_t["B"])
    if(tmp % 3 == 0):
      print("YES")
    else:
      print("NO")

  else:
    tmp = count_t["A"] - count_s["A"] - (count_t["B"] - count_s["B"])
    if(tmp % 3 == 0):
      print("YES")
    else:
      print("NO")

Fixed submission:
S = input()
T = input()
q = int(input())
A = [list(map(int, input().split())) for _ in range(q)]

count_s = [{"A": 0, "B":0} for i in range(len(S))]
count_t = [{"A": 0, "B":0} for i in range(len(T))]

for i in range(len(S)):
  if(S[i] == "A"):
    count_s[i]["A"] += 1
    if(i == len(S) -1):
      break
    count_s[i+1] = count_s[i].copy()
  else:
    count_s[i]["B"] += 1
    if(i == len(S) -1):
      break
    count_s[i+1] = count_s[i].copy()


for i in range(len(T)):
  if(T[i] == "A"):
    count_t[i]["A"] += 1
    if(i == len(T) -1):
      break
    count_t[i+1] = count_t[i].copy()
  else:
    count_t[i]["B"] += 1
    if(i == len(T) -1):
      break
    count_t[i+1] = count_t[i].copy()


for i in range(q):
  if(S[A[i][0] - 1] == "A"):
    count_S = {"A": count_s[A[i][1] - 1]["A"] - count_s[A[i][0] - 1]["A"] + 1, "B": count_s[A[i][1] - 1]["B"] - count_s[A[i][0] -1]["B"]}
  else:
    count_S = {"A": count_s[A[i][1] - 1]["A"] - count_s[A[i][0] - 1]["A"], "B": count_s[A[i][1] - 1]["B"] - count_s[A[i][0] -1]["B"] + 1}
  if(T[A[i][2] - 1] == "A"):
    count_T = {"A": count_t[A[i][3] - 1]["A"] - count_t[A[i][2] - 1]["A"] + 1, "B": count_t[A[i][3] - 1]["B"] - count_t[A[i][2] - 1]["B"]}
  else:
    count_T = {"A": count_t[A[i][3] - 1]["A"] - count_t[A[i][2] - 1]["A"], "B": count_t[A[i][3] - 1]["B"] - count_t[A[i][2] - 1]["B"] + 1}

  if(count_S["A"] - count_T["A"] > 0):
    tmp = count_S["A"] - count_T["A"] - (count_S["B"] - count_T["B"])
    if(tmp % 3 == 0):
      print("YES")
    else:
      print("NO")

  else:
    tmp = count_T["A"] - count_S["A"] - (count_T["B"] - count_S["B"])
    if(tmp % 3 == 0):
      print("YES")
    else:
      print("NO")
Buggy python submission (verdict: Runtime Error):
import sys

sys.setrecursionlimit(10000)


def memoize(f):
    cache = {}

    def func(*args):
        if args not in cache:
            cache[args] = f(*args)
        return cache[args]

    return func


@memoize



def combi(n, r):
  if r == 0 or n == r:
    return 1
  return combi(n-1, r-1) + combi(n-1, r)

n, a, b = map(int, input().split())
items = sorted(map(int, input().split()), reverse=True)
max_ave_list = items[:a]
print(sum(max_ave_list)/len(max_ave_list))

m = max_ave_list.count(max_ave_list[-1])
l = items.count(max_ave_list[-1])
if l == m:
  print(1)
elif max_ave_list[0] != max_ave_list[-1]:
  print(combi(l, m))
else:
  print(sum(combi(l, k) for k in range(m, min(b, l) + 1)))

Fixed submission:
b = input().split()
a = [int(b[i]) for i in range(len(b))]

if(a[0] + a[1] >= 24 ):
  print(a[0] + a[1] - 24)
else:
  print(a[0] + a[1])
Buggy python submission (verdict: Runtime Error):
a = map(int, input().split())

abs = max(a[1], a[2]) - min(a[1], a[2]) - a[0]

print(max(0, abs))

Fixed submission:
W, a, b = map(int, input().split())

abs = max(a, b) - min(a, b) - W

print(max(0, abs))
Buggy python submission (verdict: Time Limit Exceeded):
#coding:utf-8

import sys
from collections import defaultdict

if __name__ == "__main__":
    N, M = map(int, input().split(" "))

    V = set()
    E = []
    for i in range(M):
        a, b, c = map(int, input().split(" "))
        V.add(a)
        V.add(b)
        E.append((a, b, -c))

    dist = defaultdict(lambda :10**20 + 1)
    pre = {}
    dist[1] = 0


    for i in range(1, len(V)):
        for edge in E:
            u = edge[0]
            v = edge[1]

            if dist[v] > dist[u] + edge[2]:
                dist[v] = dist[u] + edge[2]
                pre[v] = u

    is_cycle = False
    cycle_node = []
    for edge in E:
        u = edge[0]
        v = edge[1]
        if dist[u] + edge[2] < dist[v]:
            is_cycle = True
            cycle_node.append(u)

    is_inf = False
    if is_cycle:
        next_node = N
        route = []
        while next_node != 1:
            route.append(next_node)
            next_node = pre[N]
        route.append(1)

        for n in cycle_node:
            if n in route:
                is_inf = True
                break

    if is_inf:
        print ("inf")
    else:
        print (-dist[N])


Fixed submission:
#coding:utf-8

import sys
from collections import defaultdict

if __name__ == "__main__":
    N, M = map(int, input().split(" "))

    V = set()
    E = []
    for i in range(M):
        a, b, c = map(int, input().split(" "))
        V.add(a)
        V.add(b)
        E.append((a, b, -c))

    dist = defaultdict(lambda :10**20 + 1)
    pre = {}
    dist[1] = 0


    for i in range(1, len(V)):
        for edge in E:
            u = edge[0]
            v = edge[1]

            if dist[v] > dist[u] + edge[2]:
                dist[v] = dist[u] + edge[2]
                pre[v] = u

    is_cycle = False
    cycle_node = []
    for edge in E:
        u = edge[0]
        v = edge[1]
        if dist[u] + edge[2] < dist[v]:
            is_cycle = True
            cycle_node.append(u)

    is_inf = False
    if is_cycle:
        route_node = N
        while route_node != 1:
            route_node = pre[route_node]
            if route_node in cycle_node:
                is_inf = True
                break


    if is_inf:
        print ("inf")
    else:
        print (-dist[N])
Buggy python submission (verdict: Runtime Error):
import math

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

# student input
student = []
for i in range(n):
    a, b = map(int, input().split())
    student.append([a, b])

# check point input
check = []
for j in range(n):
    c, d = map(int, input().split())
    check.append([c, d])

# calc
for s in student:
    distance = 10e9
    near = 0
    for index, k in enumerate(check):
        v = math.fabs(s[0] - k[0]) + math.fabs(s[1] - k[1])
        if v < distance:
            distance = v
            near = index + 1
    print(near)


Fixed submission:
import math

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

# student input
student = []
for i in range(n):
    a, b = map(int, input().split())
    student.append([a, b])

# check point input
check = []
for j in range(m):
    c, d = map(int, input().split())
    check.append([c, d])

# calc
for s in student:
    distance = 10e9
    near = 0
    for index, k in enumerate(check):
        v = math.fabs(s[0] - k[0]) + math.fabs(s[1] - k[1])
        if v < distance:
            distance = v
            near = index + 1
    print(near)
Buggy python submission (verdict: Runtime Error):
x = int(input())
# 5 or 6
if x % 11 == 0:
    ans = x // 11 * 2
elif x % 11 <= 6:
    ans = x // 11 * 2 + 1
else:
    ans = x // 11 * 2 + 2

print(ans

Fixed submission:
x = int(input())
# 5 or 6
if x % 11 == 0:
    ans = x // 11 * 2
elif x % 11 <= 6:
    ans = x // 11 * 2 + 1
else:
    ans = x // 11 * 2 + 2

print(ans)