Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
s = list(input())
k_index = []
k = list('keyence')

for i in range(len(s)):
    if s[i] == k[0]:
        k_index.append(i)

ans = 'NO'
for i in k_index:
    j = 0
    flag = 0
    for a in s[i:]:
        if a == k[j]:
            j += 1
            if flag == 0:
                flag = 1 # reading 1st half
            elif flag == 2:
                flag = 3 # reading 2nd half
            if j == len(k):
                ans = 'YES'
        elif flag == 1: # end of 1st half
            flag = 2 # reading middle
        elif flag == 3:
            break

print(ans)

Fixed submission:
s = input()
k = 'keyence'

for i in range(len(s)):
    for j in range(i,len(s)):
        if s[:(i+1)]+s[j:] == 'keyence':
            print('YES')
            exit()

print('NO')

Buggy python submission (verdict: Runtime Error):
s = input()
k = 'keyence'
i = 0
flag = 0
ans = 'YES'
for a in s:
    if a == k[i]:
        i += 1
        if flag == 0:
            flag = 1 # reading 1st half
        elif flag == 2:
            flag = 3 # reading 2nd half
    elif flag == 1: # end of 1st half
        flag = 2 # reading middle
    elif flag == 3:
        ans = 'NO'
        break

if flag == 0:
    ans = 'NO'
print(ans)

Fixed submission:
s = input()
k = 'keyence'

for i in range(len(s)):
    for j in range(i,len(s)):
        if s[:(i+1)]+s[j:] == 'keyence':
            print('YES')
            exit()

print('NO')
Buggy python submission (verdict: Time Limit Exceeded):
s_l = list(input())
count_tot = 0

while True:
    count = 0
    for i in range(len(s_l)-1):
        if s_l[i] == 'B' and s_l[i+1] == 'W':
            s_l[i] = 'W'
            s_l[i+1] = 'B'
            count += 1
    count_tot += count
    if count == 0:
        break

print(count_tot)

Fixed submission:
s_l = list(input())
count_tot = 0
count = 0

for i in range(len(s_l)):
    if s_l[i] == 'W':
        count_tot += i - count
        count += 1

print(count_tot)
Buggy python submission (verdict: Runtime Error):
judge = 'Yes'
n = int(input())
txy_l = [0]
for i in range(n):
    txy_l.append(list(map(int,input().split())))

for i in range(n):
    t_dif = txy_l[i+1][0] - txy_l[i][0]
    x_dif = txy_l[i+1][1] - txy_l[i][1]
    y_dif = txy_l[i+1][2] - txy_l[i][2]
    spare_time = t_dif - (abs(x_dif)+abs(y_dif))
    if spare_time < 0 or spare_time%2 != 0:
        judge = 'No'

print(judge)

Fixed submission:
judge = 'Yes'
n = int(input())
txy_l = [[0,0,0]]
for _ in range(n):
    txy_l.append(list(map(int,input().split())))

for i in range(n):
    t_dif = txy_l[i+1][0] - txy_l[i][0]
    x_dif = txy_l[i+1][1] - txy_l[i][1]
    y_dif = txy_l[i+1][2] - txy_l[i][2]
    spare_time = t_dif - (abs(x_dif)+abs(y_dif))
    if spare_time < 0 or spare_time%2 != 0:
        judge = 'No'

print(judge)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
paper = set()
for _ in range(n):
    a = int(input())
    paper = set((a,))^paper

print(len(paper))

Fixed submission:
n = int(input())
paper = {}
for _ in range(n):
    a = int(input())
    if a in paper:
        paper[a] += 1
    else:
        paper[a] = 0

count = 0
for val in paper.values():
    if val%2 != 1:
        count += 1
print(count)
Buggy python submission (verdict: Runtime Error):
h, w = map(int,input().split())
n = int(input())
a_l = list(map(int,input().split()))

ans = []
for _ in range(h):
    ans.append([0]*w)

direction = 0
posx = 0
posy = 0
for i in range(n):
    for j in range(a_l[i]):
        ans[posy][posx] = i+1
        if direction == 0:
            posx += 1
            if posx == w-1:
                direction = 1
        elif direction == 1:
            posy += 1
            direction = 2
        elif direction == 2:
            posx -= 1
            if posx == 0:
                direction = 3
        elif direction == 3:
            posy += 1
            direction = 0

for val in ans:
    print(' '.join(map(str,val)))






Fixed submission:
h, w = map(int,input().split())
n = int(input())
a_l = list(map(int,input().split()))

ans = []
for _ in range(h):
    ans.append([0]*w)

direction = 0
posx = 0
posy = 0
for i in range(n):
    for j in range(a_l[i]):
        ans[posy][posx] = i+1
        if w == 1:
            direction = 1
        if direction == 0:
            posx += 1
            if posx == w-1:
                direction = 1
        elif direction == 1:
            posy += 1
            direction = 2
        elif direction == 2:
            posx -= 1
            if posx == 0:
                direction = 3
        elif direction == 3:
            posy += 1
            direction = 0

for val in ans:
    print(' '.join(map(str,val)))
Buggy python submission (verdict: Runtime Error):
#! python3
def main():
    N = input()
    ans = 0
    for i in range(1,N+1):
        ans += i
    print(ans)
main()

Fixed submission:
#! python3
def main():
    N = int(input())
    ans = 0
    for i in range(N):
        ans += (i+1)
    print(ans)
main()
Buggy python submission (verdict: Runtime Error):
def main():
    A, B, N = map(int, input().split(" "))
    max_score = -float("inf")

    if B <= N:
        x = B-1 
    else:
        x = N
    score = math.floor((A*x)/B) - A*math.floor(x/B)
    print(score)

if __name__ == "__main__":
    main()

Fixed submission:
import math

def main():
    A, B, N = map(int, input().split(" "))
    max_score = -float("inf")

    if B <= N:
        x = B-1 
    else:
        x = N
    score = math.floor((A*x)/B) - A*math.floor(x/B)
    print(score)

if __name__ == "__main__":
    main()

Buggy python submission (verdict: Time Limit Exceeded):
import math

def main():
    A, B, N = map(int, input().split(" "))
    max_score = -float("inf")
    log = []

    for x in range(1, min(B, N)+1):
        score = math.floor((A*x)/B) - A*math.floor(x/B)
        log.append(score)
        max_score = max(max_score, score)
    print(max_score)

if __name__ == "__main__":
    main()

Fixed submission:
import math

def main():
    A, B, N = map(int, input().split(" "))
    max_score = -float("inf")

    if B <= N:
        x = B-1 
    else:
        x = N
    score = math.floor((A*x)/B) - A*math.floor(x/B)
    print(score)

if __name__ == "__main__":
    main()
Buggy python submission (verdict: Runtime Error):
import math

r = int(intput())

print(math.pi * 2 * r)

Fixed submission:
import math

r = int(input())

print(r * 2 * math.pi)
Buggy python submission (verdict: Runtime Error):
def main():
  xs <- input().split("")

  if "7" in xs:
    print("Yes")
  else:
    print("No")
    
if __name__ == '__main__':
  main()

Fixed submission:
xs = input()

if "7" in xs:
  print("Yes")
else:
  print("No")
Buggy python submission (verdict: Runtime Error):
import math
from functools import reduce
from sys import stdin
import itertools

def gcd(*numbers):
    return reduce(math.gcd, numbers)
  
def main:
  N = int(stdin.readline())
  N_list = list(range(1, N+1))
  
  ans = 0
  
  for xs in itertools.combinations_with_replacement(N_list, 3):
    if len(set(xs)) == 1:
      ans += gcd(xs[0], xs[1], xs[2])
    elif len(set(xs)) == 2:
      ans += 3*gcd(xs[0], xs[1], xs[2])
    else:
      ans += 6*gcd(xs[0], xs[1], xs[2])
      
  print(ans)

if __name__ == '__main__':
  main()

Fixed submission:
import math
from functools import reduce
from sys import stdin
import itertools

def gcd(*numbers):
    return reduce(math.gcd, numbers)
  
def main():
  N = int(stdin.readline())
  N_list = list(range(1, N+1))
  
  ans = 0
  
  for xs in itertools.combinations_with_replacement(N_list, 3):
    if len(set(xs)) == 1:
      ans += gcd(xs[0], xs[1], xs[2])
    elif len(set(xs)) == 2:
      ans += 3*gcd(xs[0], xs[1], xs[2])
    else:
      ans += 6*gcd(xs[0], xs[1], xs[2])
      
  print(ans)

if __name__ == '__main__':
  main()

Buggy python submission (verdict: Runtime Error):
import math
from functools import reduce
from sys import stdin
import itertools

def gcd(*numbers):
    return reduce(math.gcd, numbers)
  
def main:
  N = int(stdin.readline())
  N_list = lsit(range(1, N+1))
  
  ans = 0
  
  for xs in itertools.combinations_with_replacement(N_list, 3):
    if len(set(xs)) == 1:
      ans += 6*gcd(xs[0], xs[1], xs[2])
    elif len(set(xs)) == 2:
      ans += 3*gcd(xs[0], xs[1], xs[2])
    else:
      ans += gcd(xs[0], xs[1], xs[2])
      
  print(ans)

Fixed submission:
import math
from functools import reduce
from sys import stdin
import itertools

def gcd(*numbers):
    return reduce(math.gcd, numbers)
  
def main():
  N = int(stdin.readline())
  N_list = list(range(1, N+1))
  
  ans = 0
  
  for xs in itertools.combinations_with_replacement(N_list, 3):
    if len(set(xs)) == 1:
      ans += gcd(xs[0], xs[1], xs[2])
    elif len(set(xs)) == 2:
      ans += 3*gcd(xs[0], xs[1], xs[2])
    else:
      ans += 6*gcd(xs[0], xs[1], xs[2])
      
  print(ans)

if __name__ == '__main__':
  main()
Buggy python submission (verdict: Runtime Error):
k = int(input())
s = int(input())

ans = 0

for x in range(k+1):
  for y in range(k+1):
    r = s - (x + y)
    if r >= 0 and r <= k:
      ans += 1

print(ans)
    
	


Fixed submission:
sentence = input()
print(sentence.replace(",", " "))
Buggy python submission (verdict: Runtime Error):
k = int(input())
s = int(input())

ans = 0

for x in range(k+1):
  for y in range(k+1):
    r = s - (x + y)
    if r >= 0 and r <= k:
      ans += 1

print(ans
    
	

Fixed submission:
k, s = map(int, input().split(" "))

 
ans = 0
 
for x in range(k+1):
  for y in range(k+1):
    r = s - (x + y)
    if r >= 0 and r <= k:
      ans += 1
 
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int, input().split()))

ans = 1

for i in range(n):
    ans *= a[i]

if ans > 10 ** 18:
    print(-1)
    exit()

print(ans)


Fixed submission:
n = int(input())
a = list(map(int, input().split()))

ans = 1

if 0 in a:
    print(0)
    exit()
for i in range(n):
    ans *= a[i]
    if ans > 10 ** 18:
        print(-1)
        exit()


print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
from collections import deque

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

path = [[0] * n for _ in range(n)]
dist = [-1] * n
signs = [-1] * n

for i in range(m):
    a, b = map(int, input().split())
    path[a - 1][b - 1] = 1
    path[b - 1][a - 1] = 1

q = deque()
dist[0] = 0
q.append(0)

while len(q) != 0:
    node = q.popleft()

    for i in range(n):
        if path[node][i] == 0:
            continue
        if dist[i] != -1:
            continue
        dist[i] = dist[node] + 1
        q.append(i)

for i in range(1, n):
    for j in range(n):
        if dist[i] - 1 == dist[j]:
            signs[i] = j + 1
            break
        if j == n - 1:
            print('No')
            exit()

for i in range(n):
    if i == 0:
        print('Yes')
    else:
        print(signs[i])

Fixed submission:
from collections import deque
n, m = map(int, input().split())

adjacent_list = [[] for _ in range(n + 1)]

for i in range(m):
    a, b = map(int, input().split())
    adjacent_list[a].append(b)
    adjacent_list[b].append(a)

signs = [-1 for _ in range(n + 1)]

que = deque()
que.append(1)

while que:
    node = que.popleft()
    for i in adjacent_list[node]:
        if signs[i] == -1:
            que.append(i)
            signs[i] = node


print('Yes')
for i in range(2, n + 1):
    print(signs[i])

Buggy python submission (verdict: Time Limit Exceeded):
from collections import deque

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

path = [[0] * n for _ in range(n)]
dist = [-1] * n
signs = [-1] * n

for i in range(m):
    a, b = map(int, input().split())
    path[a - 1][b - 1] = 1
    path[b - 1][a - 1] = 1

q = deque()
dist[0] = 0
q.append(0)

while len(q) != 0:
    node = q.popleft()

    for i in range(n):
        if path[node][i] == 0:
            continue
        if dist[i] != -1:
            continue
        dist[i] = dist[node] + 1
        q.append(i)

for i in range(1, n):
    for j in range(n):
        if dist[i] - 1 == dist[j]:
            signs[i] = j + 1
            break
        if j == n - 1:
            print('No')
            exit()

for i in range(n):
    if i == 0:
        print('Yes')
    else:
        print(signs[i])

Fixed submission:
from collections import deque
n, m = map(int, input().split())

adjacent_list = [[] for _ in range(n + 1)]

for i in range(m):
    a, b = map(int, input().split())
    adjacent_list[a].append(b)
    adjacent_list[b].append(a)

signs = [-1 for _ in range(n + 1)]

que = deque()
que.append(1)

while que:
    node = que.popleft()
    for i in adjacent_list[node]:
        if signs[i] == -1:
            que.append(i)
            signs[i] = node


print('Yes')
for i in range(2, n + 1):
    print(signs[i])
Buggy python submission (verdict: Time Limit Exceeded):
from math import floor
A, B, N = map(int, input().split())
AdB = A/B

m = 0
for x in range(1, N + 1):
    if x < B:
        n = floor(x * AdB)
        if n > m:
            m = n
    else:
        n = floor(x * AdB) - A * floor(x / B)
        if n > m:
            m = n
print(m)


Fixed submission:
from math import floor
A, B, N = map(int, input().split())
print(floor((min(N + 1, B) - 1) * A / B))

Buggy python submission (verdict: Time Limit Exceeded):
from math import floor
A, B, N = map(int, input().split())
AdB = A/B

m = 0
for x in range(1, N + 1):
    n = floor(x * AdB) - A * floor(x / B)
    if n > m:
        m = floor(x * AdB) - A * floor(x / B)
print(m)


Fixed submission:
from math import floor
A, B, N = map(int, input().split())
print(floor((min(N + 1, B) - 1) * A / B))
Buggy python submission (verdict: Runtime Error):
n, m = map(int, input().split())
a = list(map(int, input().split()))
if n - sum(a) >= 0:
    print(n - sum(a))
else:
    print(-1)


Fixed submission:
import math
r = int(input())
print(2 * r * math.pi)
Buggy python submission (verdict: Time Limit Exceeded):
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
for i in range(1, n):
    print(a.count(i))
print(0)


Fixed submission:
n = int(input())
a = list(map(int, input().split()))
b = [0] * n
for i in range(n - 1):
    b[a[i] - 1] += 1
for i in range(n):
    print(b[i])

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int, input().split()))
for i in range(1, n):
    print(a.count(i))
print(0)


Fixed submission:
n = int(input())
a = list(map(int, input().split()))
b = [0] * n
for i in range(n - 1):
    b[a[i] - 1] += 1
for i in range(n):
    print(b[i])

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int, input().split()))
b = [0] * (n + 1)
for i in range(1, n):
    print(a.count(i))
print(0)


Fixed submission:
n = int(input())
a = list(map(int, input().split()))
b = [0] * n
for i in range(n - 1):
    b[a[i] - 1] += 1
for i in range(n):
    print(b[i])

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int, input().split()))
b = [0] * (n + 1)
for i in range(1, n):
    b[i] += a.count(i)
for i in range(1, n + 1):
    print(b[i])


Fixed submission:
n = int(input())
a = list(map(int, input().split()))
b = [0] * n
for i in range(n - 1):
    b[a[i] - 1] += 1
for i in range(n):
    print(b[i])
Buggy python submission (verdict: Time Limit Exceeded):
from math import gcd
K = int(input())
sum = 0
for a in range(K):
    for b in range(K):
        for c in range(K):
            sum += gcd(gcd(a + 1, b + 1), c + 1)
print(sum)


Fixed submission:
from math import gcd
K = int(input())
sum = 0
for a in range(K):
    for b in range(K):
        g = gcd(a + 1, b + 1)
        for c in range(K):
            sum += gcd(g, c + 1)
print(sum)
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
P = list(map(int, input().split()))
count = 0
for i in range(N):
    for n in range(i + 1):
        if P[n] < P[i]:
            break
        if i == n:
            count += 1
print(count)


Fixed submission:
N = int(input())
P = list(map(int, input().split()))
MIN = list()
count = 0
MIN.append(P[0])
for i in range(1, N):
    MIN.append(min(MIN[i - 1], P[i]))
for i in range(0, N):
    if P[i] <= MIN[i]:
        count += 1
print(count)

Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
P = list(map(int, input().split()))
count = 0
for i in range(N):
    flag = True
    for n in range(i + 1):
        if P[n] < P[i]:
            flag = False
        if i == n and flag:
            count += 1
print(count)


Fixed submission:
N = int(input())
P = list(map(int, input().split()))
MIN = list()
count = 0
MIN.append(P[0])
for i in range(1, N):
    MIN.append(min(MIN[i - 1], P[i]))
for i in range(0, N):
    if P[i] <= MIN[i]:
        count += 1
print(count)
Buggy python submission (verdict: Runtime Error):
from math import ceil


def dfs(i, sum, count, residue):
    global ans
    if i == d:
        if sum < g:
            use = max(residue)
            n = min(pc[use - 1][0], ceil((g - sum) / (use * 100)))
            count += n
            sum += n * use * 100

        if g <= sum:
            ans = min(ans, count)

    else:
        dfs(i + 1, sum, count, residue)
        dfs(i + 1, sum + pc[i][0] * (i + 1) * 100 + pc[i][1], count + pc[i][0], residue - {i + 1})


d, g = map(int, input().split())

pc = [list(map(int, input().split())) for _ in range(d)]

ans = float('inf')

dfs(0, 0, 0, set(range(1, d + 1)))
print(ans)


Fixed submission:
def dfs(i, f, result):
    if i == l - 1:
        if result == 7:
            print(f + '=7')
            exit()
    else:
        dfs(i + 1, f + '-' + s[i + 1], result - int(s[i + 1]))
        dfs(i + 1, f + '+' + s[i + 1], result + int(s[i + 1]))


s = input()
l = len(s)

dfs(0, s[0], int(s[0]))
Buggy python submission (verdict: Runtime Error):
import numpy as np

n = int(input())

t = [int(input()) for _ in range(n)]

print(np.lcm.reduce(np.array(t)))


Fixed submission:
from fractions import gcd

n = int(input())

t = [int(input()) for _ in range(n)]

ans = t[0]
for i in range(1, n):
    ans = ans * t[i] // gcd(ans, t[i])
print(ans)
Buggy python submission (verdict: Runtime Error):
str = input()
str_len = len(str)
h_flag = 0
for cat_i in range(str_len):
  if h_flag == 0 & str[cat_i] == 'h':
    h_flag = 1
  elif h_flag == 1 & str[cat_i] == 'i':
    h_flag = 0
  else:
    print('No')
    break;
    
  if cat_i == (str_len - 1):
    print('Yes')


Fixed submission:
str = input()
str_len = len(str)
h_flag = 0
for cat_i in range(str_len):
  if str_len % 2 == 1:
    print('No')
    break
  
  if h_flag == 0 and str[cat_i] == 'h':
    h_flag = 1
  elif h_flag == 1 and str[cat_i] == 'i':
    h_flag = 0
  else:
    print('No')
    break
    
  if cat_i == (str_len - 1):
    print('Yes')

Buggy python submission (verdict: Runtime Error):
str = input()
str_len = len(str)
for cat_i in range(str_len):
  if str[cat_i] == 'h':
    h_flag = 1
  elif h_flag == 1 & str[cat_i] == 'i':
    h_flag = 0
  else:
    print('No')
    break;
    
  if cat_i == (str_len - 1):
    print('Yes')

Fixed submission:
str = input()
str_len = len(str)
h_flag = 0
for cat_i in range(str_len):
  if str_len % 2 == 1:
    print('No')
    break
  
  if h_flag == 0 and str[cat_i] == 'h':
    h_flag = 1
  elif h_flag == 1 and str[cat_i] == 'i':
    h_flag = 0
  else:
    print('No')
    break
    
  if cat_i == (str_len - 1):
    print('Yes')
Buggy python submission (verdict: Runtime Error):
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))

Fixed submission:
import fractions

def lcm(x, y):
    ans = (x * y)// fractions.gcd(x, y)

    return ans

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

print(lcm(A, B))
Buggy python submission (verdict: Runtime Error):
N = int(input())

f = [0]*(N + 1)
f[0] = 1
f[1] = 1
for i in range(2, N + 1):
    f[i] = i * f[i - 2]

count = 0
while f[N] % 10 == 0:
    count += 1
    f[N] = f[N] // 10
    #print(count, f[N])

print(count)

if N % 2 == 1:
    print(0)
if N % 2 == 0:
    N_keta = len(str(N)) - 1

    num_10 = list()
    num_50 = list()
    for i in range(1, N_keta + 1):
        num_10.append(N // (10**i))
    sum_10 = sum(num_10)
    
    for i in range(1, N_keta + 1):
        num_50.append((N // (5 * (10**i))))

    print(num_50)
    for i in range(0, len(num_10) - 1):
        num_50[i] -= num_10[i+1]
    

    print(num_50)
    sum_50 = sum(num_50)
    print(sum_10 + sum_50)

Fixed submission:
N = int(input())
"""
f = [0]*(N + 1)
f[0] = 1
f[1] = 1
for i in range(2, N + 1):
    f[i] = i * f[i - 2]

count = 0
while f[N] % 10 == 0:
    count += 1
    f[N] = f[N] // 10
    #print(count, f[N])

print(count)
"""
if N % 2 == 1:
    print(0)
if N % 2 == 0:
    five_count = 0
    while N >= 5**five_count:
        five_count += 1
    
    num_5 = list()
    for i in range(1, five_count + 1):
        num = N // (5**i)

        num_5.append(num//2)
        
    sum_5 = sum(num_5)
    print(sum_5)
Buggy python submission (verdict: Runtime Error):
X = int(input())

item_value = [100, 101, 102, 103, 104, 105]
dp = [0] * (X + 1)
for value in item_value:
    dp[value] = 1

for i in range(200, X + 1):
    for value in item_value:
        if dp[i - value] == 1:
            dp[i] = 1

print(dp[X])

Fixed submission:
X = int(input())

item_value = [100, 101, 102, 103, 104, 105]
dp = [0] * (100001)
for value in item_value:
    dp[value] = 1

for i in range(200, X + 1):
    for value in item_value:
        if dp[i - value] == 1:
            dp[i] = 1

print(dp[X])

Buggy python submission (verdict: Runtime Error):
X = int(input())

item_list = [100, 101, 102, 103, 104, 105]

pre_list = []
sum_value = 0
for i in range(1, 1001):
    tmp_list = []
    for value in item_list:
        tmp_list.append(i * value)
    
    pre_list.append(tmp_list)

sum_list = [[0] * 7 for i in range(1001)]
for i in range(1000):
    for j in range(6):
            sum_list[i + 1][j + 1] = sum_list[i][j + 1] + sum_list[i + 1][j] - sum_list[i][j] + pre_list[i][j]

flag = 0
for i1 in range(0, 1000):
    for i2 in range(i1+1, 1001):
        for j1 in range(0, 6):
            for j2 in range(j1+1, 7):
                    value = sum_list[i2][j2] - sum_list[i1][j2] - sum_list[i2][j1] + sum_list[i1][j1]  
                if X == value:
                    flag = 1

print(flag)

Fixed submission:
X = int(input())

item_value = [100, 101, 102, 103, 104, 105]
dp = [0] * (100001)
for value in item_value:
    dp[value] = 1

for i in range(200, X + 1):
    for value in item_value:
        if dp[i - value] == 1:
            dp[i] = 1

print(dp[X])
Buggy python submission (verdict: Runtime Error):
N = int(input())

flag = 0
for i in range(10):
    if N % i == 0:
        a = N // i
        if a <= 9:
            print("Yes")
            flag = 1

if flag == 0:
    print("No")

Fixed submission:
N = int(input())

flag = 0
for i in range(1, 10):
    if N % i == 0:
        a = N // i
        if a <= 9:
            flag = 1

if flag == 0:
    print("No")
else:
    print("Yes")
Buggy python submission (verdict: Runtime Error):
import time

N, K = [int(i) for i in input().split()]
h = [int(i) for i in input().split()]

count = 0

for i in range(N):
    if n[i] >= K:
        count += 1

print(count)

Fixed submission:
N, K = [int(i) for i in input().split()]
h = [int(i) for i in input().split()]

count = 0

for i in range(N):
    if h[i] >= K:
        count += 1

print(count)

Buggy python submission (verdict: Runtime Error):
N, K = [int(i) for i in input().split()]
h = [int(i) for i in input().split()]

h.sort()

left = 0
right = len(h) - 1
center = 0

if right == 0:
    if a[0] >= K:
        print(1)
    else:
        print(0)
else:
    while right - left >= 1:
        center = int((left + right) / 2)
        if h[center] >= K:
            right = center
        else:
            left = center
        
    print(len(h) - center)

Fixed submission:
N, K = [int(i) for i in input().split()]
h = [int(i) for i in input().split()]

count = 0

for i in range(N):
    if h[i] >= K:
        count += 1

print(count)