Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Time Limit Exceeded):
import math

def permutations_count(n, r):
    if (n < 2):
        return 0
    else:
        return math.factorial(n) // math.factorial(n - r)

N = int(input())
A = list(map(int, input().split()))

bar = {}

for i in range(N):
    if (A[i] in bar):
        bar[A[i]] = bar[A[i]] + 1
    else:
        bar[A[i]] = 1

partOfNum = {}
lackPartOfNum = {}

for j in bar.keys():
    tmp = permutations_count(bar[j], 2)
    partOfNum[j] = int(tmp / 2)
    tmp = permutations_count(bar[j] - 1, 2)
    lackPartOfNum[j] = int(tmp / 2)

allSum = 0
for l in partOfNum.keys():
    allSum += partOfNum[l]

for i in range(N):
    print(allSum - partOfNum[A[i]] + lackPartOfNum[A[i]])


Fixed submission:
import math

def permutations_count(n, r):
    if (n < 2):
        return 0
    else:
        return math.factorial(n) // math.factorial(n - r)

N = int(input())
A = list(map(int, input().split()))

bar = {}

for i in range(N):
    if (A[i] in bar):
        bar[A[i]] = bar[A[i]] + 1
    else:
        bar[A[i]] = 1

partOfNum = {}
lackPartOfNum = {}

for j in bar.keys():
    tmp = permutations_count(bar[j], 2)
    partOfNum[j] = int(tmp / 2)
#   tmp = permutations_count(bar[j] - 1, 2)
    lackPartOfNum[j] = partOfNum[j] - (bar[j] - 1)

allSum = 0
for l in partOfNum.keys():
    allSum += partOfNum[l]

for i in range(N):
    print(allSum - partOfNum[A[i]] + lackPartOfNum[A[i]])

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

def permutations_count(n, r):
    if (n < 2):
        return 0
    else:
        return math.factorial(n) // math.factorial(n - r)

N = int(input())
A = list(map(int, input().split()))

bar = {}

for i in range(N):
    if (A[i] in bar):
        bar[A[i]] = bar[A[i]] + 1
    else:
        bar[A[i]] = 1

partOfNum = {}

for j in bar.keys():
    tmp = permutations_count(bar[j], 2)
    partOfNum[j] = int(tmp / 2)

for i in range(N):
    jogai = A[i]
    seed = bar[jogai] - 1
    tmp2 = permutations_count(seed, 2)
    lackCombination = int(tmp2 / 2)
    for k in partOfNum.keys():
        if (k != jogai):
            lackCombination += partOfNum[k]
    print(lackCombination)


Fixed submission:
import math

def permutations_count(n, r):
    if (n < 2):
        return 0
    else:
        return math.factorial(n) // math.factorial(n - r)

N = int(input())
A = list(map(int, input().split()))

bar = {}

for i in range(N):
    if (A[i] in bar):
        bar[A[i]] = bar[A[i]] + 1
    else:
        bar[A[i]] = 1

partOfNum = {}
lackPartOfNum = {}

for j in bar.keys():
    tmp = permutations_count(bar[j], 2)
    partOfNum[j] = int(tmp / 2)
#   tmp = permutations_count(bar[j] - 1, 2)
    lackPartOfNum[j] = partOfNum[j] - (bar[j] - 1)

allSum = 0
for l in partOfNum.keys():
    allSum += partOfNum[l]

for i in range(N):
    print(allSum - partOfNum[A[i]] + lackPartOfNum[A[i]])
Buggy python submission (verdict: Time Limit Exceeded):
S = input()
NQ = int(input())

reverseFlag = False

for i in range(NQ):
    query = input().split()
    if (int(query[0]) == 1):
        reverseFlag = not reverseFlag
    else:
        if (reverseFlag):
            if (int(query[1]) == 1):
                S = S + query[2]
            else:
                S = query[2] + S
        else:
            if (int(query[1]) == 1):
                S = query[2] + S
            else:
                S = S + query[2]

if (reverseFlag):
    print(S[::-1])
else:
    print(S)



Fixed submission:
S = input()
NQ = int(input())

reverseFlag = False
prefix = ""
suffix = ""

for i in range(NQ):
    query = input().split()
    if (int(query[0]) == 1):
        reverseFlag = not reverseFlag
    else:
        if (reverseFlag):
            if (int(query[1]) == 1):
                suffix = suffix + query[2]
            else:
                prefix = query[2] + prefix
        else:
            if (int(query[1]) == 1):
                prefix = query[2] + prefix
            else:
                suffix = suffix + query[2]

if (reverseFlag):
    print(suffix[::-1] + S[::-1] + prefix[::-1])
else:
    print(prefix + S + suffix)

Buggy python submission (verdict: Time Limit Exceeded):
S = input()
NQ = int(input())

for i in range(NQ):
    query = input().split()
    if (int(query[0]) == 1):
        S = S[::-1]
    else:
        if (int(query[1]) == 1):
            S = query[2] + S
        else:
            S = S + query[2]

print(S)


Fixed submission:
S = input()
NQ = int(input())

reverseFlag = False
prefix = ""
suffix = ""

for i in range(NQ):
    query = input().split()
    if (int(query[0]) == 1):
        reverseFlag = not reverseFlag
    else:
        if (reverseFlag):
            if (int(query[1]) == 1):
                suffix = suffix + query[2]
            else:
                prefix = query[2] + prefix
        else:
            if (int(query[1]) == 1):
                prefix = query[2] + prefix
            else:
                suffix = suffix + query[2]

if (reverseFlag):
    print(suffix[::-1] + S[::-1] + prefix[::-1])
else:
    print(prefix + S + suffix)
Buggy python submission (verdict: Runtime Error):
S = input()

num = len(S)

bra = ""
ket = ""
if (num == 1):
    print(0)
else:
    if (num % 2 == 0):
        bra = S[0:int(num/2)]
        ket = S[num:int(num/2) - 1:-1]
    else:
        bra = S[0:int(num/2)]
        ket = S[num:int(num/2) - 2:-1]

    count = 0
    for i in range(int(num/2)):
        if (bra[i] != ket[i]):
            count += 1

    print(count)

Fixed submission:
S = input()

num = len(S)

bra = ""
ket = ""
if (num == 1):
    print(0)
elif (num < 4):
    if (S[0] != S[int(num / 2) + (num % 2)]):
        print(1)
    else:
        print(0)
else:
    if (num % 2 == 0):
        bra = S[0:int(num/2)]
        ket = S[num:int(num/2) - 1:-1]
    else:
        bra = S[0:int(num/2)]
        ket = S[num:int(num/2) - 2:-1]

    count = 0
    for i in range(int(num/2)):
        if (bra[i] != ket[i]):
            count += 1

    print(count)

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

num = len(S)

bra = ""
ket = ""
if (num % 2 == 0):
    bra = S[0:int(num/2)]
    ket = S[num:int(num/2) - 1:-1]
else:
    bra = S[0:int(num/2)]
    ket = S[num:int(num/2) - 2:-1]

count = 0
for i in range(int(num/2)):
    if (bra[i] != ket[i]):
        count += 1

print(count)

Fixed submission:
S = input()

num = len(S)

bra = ""
ket = ""
if (num == 1):
    print(0)
elif (num < 4):
    if (S[0] != S[int(num / 2) + (num % 2)]):
        print(1)
    else:
        print(0)
else:
    if (num % 2 == 0):
        bra = S[0:int(num/2)]
        ket = S[num:int(num/2) - 1:-1]
    else:
        bra = S[0:int(num/2)]
        ket = S[num:int(num/2) - 2:-1]

    count = 0
    for i in range(int(num/2)):
        if (bra[i] != ket[i]):
            count += 1

    print(count)
Buggy python submission (verdict: Time Limit Exceeded):
sum = 0
N = int(input())
for n in range(N):
    sum += n
print(sum)



Fixed submission:
N = int(input())

def summation(num):
    factor = divmod(num, 2)
    return (int(num / 2) * (1 + num)) + (factor[0] + 1) * factor[1]

tmp = int(summation(N))
print(tmp - N)
Buggy python submission (verdict: Time Limit Exceeded):
def main():
    N = int(input())
    count = 0
    for i in range(1, N):
        M = N // i + 1
        for j in range(1, M):
            k = N - i*j
            if k > 0 and N == i*j + k:
                count += 1

    print(count)


if __name__ == '__main__':
    main()


Fixed submission:

def main():
    N = int(input())
    count = 0
    for i in range(1, N):
        for j in range(1, N // i + 1):
            k = N - i*j
            if k > 0:
                count += 1
    print(count)

if __name__ == '__main__':
    main()
Buggy python submission (verdict: Runtime Error):
import sys
import math
sys.setrecursionlimit(10**6)

MOD = 10**9 + 7
def mod_pow(x, mod):
    xx = [1, x]
    def _pow(y, x=x):
        nonlocal xx
        if y == 0:
            return 1
        while len(xx) <= math.log(y, 2)+1:
            v = xx[-1] * xx[-1]
            v %= mod
            xx.append(v)
        i = 1
        result = 1
        while y > 0:
            if y % 2 == 1:
                result *= xx[i]
                result %= mod
            y = y >> 1
            i += 1
        return result
    return _pow

pow9 = mod_pow(9, MOD)

def f(n):
    if n == 1:
        return 0
    else:
        return 10 * f(n-1) + 2 * pow9(n-2)
def main():
    N = int(input())
    ans = f(N)
    print(ans)

if __name__ == '__main__':
    main()


Fixed submission:
import math
MOD = 10**9 + 7

def mod_pow(x, mod):
    xx = [1, x]
    def _pow(y, x=x):
        nonlocal xx
        if y == 0:
            return 1
        while len(xx) <= math.log(y, 2)+1:
            v = xx[-1] * xx[-1]
            v %= mod
            xx.append(v)
        i = 1
        result = 1
        while y > 0:
            if y % 2 == 1:
                result *= xx[i]
                result %= mod
            y = y >> 1
            i += 1
        return result
    return _pow

pow10 = mod_pow(10, MOD)
pow9 = mod_pow(9, MOD)
pow8 = mod_pow(8, MOD)

def f(n):
    ans = pow10(n) - (2 * pow9(n) - pow8(n))
    ans %= MOD
    return ans


def main():
    N = int(input())
    ans = f(N)
    print(ans)

if __name__ == '__main__':
    main()
Buggy python submission (verdict: Runtime Error):

def main():
    N = int(input())
    cases = dict()
    for _ in range(N):
        s = input()
        cases[s] = cases.get(s, 0) + 1
    
    results = ["AC", "WA", "TLE", "RE"]

    for r in results:
        print(f"{r} x {cases[r]}")
    

if __name__ == '__main__':
    main()


Fixed submission:

def main():
    N = int(input())
    cases = dict()
    for _ in range(N):
        s = input()
        cases[s] = cases.get(s, 0) + 1
    
    results = ["AC", "WA", "TLE", "RE"]

    for r in results:
        print(f"{r} x {cases.get(r, 0)}")
    

if __name__ == '__main__':
    main()
Buggy python submission (verdict: Runtime Error):
    #print(f"black={black}")
    for i in range(H+1):
        for iconb in comb(range(H), i):
            for j in range(W+1):
                for jconb in comb(range(W), j):
                    cells = np.copy(original)
                    cells[iconb, :] = '-'
                    cells[:, jconb] = '-'
                    black = np.count_nonzero(cells == '#')
                    #print(f"black={black} iconb={iconb} jconb={jconb}")
                    if black == K:
                        count += 1
    print(count)

if __name__ == '__main__':
    main()


Fixed submission:
from itertools import combinations as comb
from bisect import bisect_left

import numpy as np
def main():
    H, W, K = map(int, input().split())
    cells = []
    count = 0
    for _ in range(H):
        row = [w for w in input()]
        cells.append(row)

    original = np.copy(np.array(cells))
    black = np.count_nonzero(cells == '#')
    #print(f"black={black}")
    for i in range(H+1):
        for iconb in comb(range(H), i):
            for j in range(W+1):
                for jconb in comb(range(W), j):
                    cells = np.copy(original)
                    cells[iconb, :] = '-'
                    cells[:, jconb] = '-'
                    black = np.count_nonzero(cells == '#')
                    #print(f"black={black} iconb={iconb} jconb={jconb}")
                    if black == K:
                        count += 1
    print(count)

if __name__ == '__main__':
    main()
Buggy python submission (verdict: Time Limit Exceeded):

def resolver(N, A):
    A.sort(reverse=True)
    circle = []
    ans = 0

    for a in A:
        if len(circle) == 0:
            circle.append(a)
        elif len(circle) == 1:
            ans += circle[0]
            circle.append(a)
        else:
            idx = max(range(len(circle)), key=lambda i: min(circle[i-1], circle[i]))
            ans += min(circle[idx-1], circle[idx])
            circle.insert(idx, a)

    return ans

def main():

    N = int(input())
    A = list(map(int, input().split()))
    ans = resolver(N, A)
    print(ans)


if __name__ == '__main__':
    main()


Fixed submission:

def resolver(N, A):
    A.sort(reverse=True)
    ans = 0
    for i, _ in enumerate(A):
        if i == 0:
            continue
        elif i == 1:
            ans += A[0]
        else:
            j = (i // 2) 
            ans += A[j]
    
    return ans



def _resolver(N, A):
    A.sort(reverse=True)
    circle = []
    ans = 0

    for a in A:
        if len(circle) == 0:
            circle.append(a)
        elif len(circle) == 1:
            ans += circle[0]
            circle.append(a)
        else:
            idx = max(range(len(circle)), key=lambda i: min(circle[i-1], circle[i]))
            ans += min(circle[idx-1], circle[idx])
            circle.insert(idx, a)

    return ans

def main():

    N = int(input())
    A = list(map(int, input().split()))
    ans = resolver(N, A)
    print(ans)


if __name__ == '__main__':
    main()
Buggy python submission (verdict: Runtime Error):
    #test()
    N = int(input())
    ans = resolver(N)

    print(ans)

if __name__ == '__main__':
    main()


Fixed submission:
import numpy as np
def resolver(N):
    N -= 1
    digits = "abcdefghijklmnopqrstuvwxyz"
    i = 1
    while True:
        if N < 26**i:
            break
        N -= 26**i
        i += 1
    
    number = []
    for _ in range(i):
        tmp = N % 26 
        number.append(tmp)
        N //= 26

    ans = "".join([digits[i] for i in reversed(number)])
    return ans

def test():
    for i in range(1,100):
        ans = resolver(i)
        print(f"\ri={i:03} {ans}", end="")
    print()

def main():

    #test()

    N = int(input())
    
    ans = resolver(N)

    print(ans)



if __name__ == '__main__':
    main()
Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np
def main():
    N = int(input())
    A = list(map(int, input().split()))
    Q = int(input())
    BC = [list(map(int, input().split())) for _ in range(Q)]

    Aset = set(A)
    
    others = Aset - set([b for b ,_ in BC]) - set([c for _ ,c in BC])

    Adict = dict()
    for a in A:
        Adict[a] = Adict.get(a, 0) + 1
    
    sum_others = 0
    for o in others:
        v = Adict.pop(o)
        sum_others += o*v
    
    for b, c in BC:
        if b in Adict:
            tmp = Adict[b]
            Adict[c] = Adict.get(c, 0) + tmp
            Adict.pop(b)
        
        goukei = sum([k*v for k, v in Adict.items()]) + sum_others
        
        print(goukei)


if __name__ == '__main__':
    main()


Fixed submission:
def resolver(N, A, Q, BC):
    total = sum(A)
    counter = dict()
    ans = []
    for a in A:
        counter[a] = counter.get(a, 0) + 1
    
    for (b, c) in BC:
        c0 = counter.pop(b) if b in counter else 0
        counter[c] = counter.get(c, 0) + c0
        total -= c0 * b
        total += c0 * c
        ans.append(total)
    
    return ans

def test():
    pass

def main():

    #test()

    N = int(input())
    A = list(map(int, input().split()))
    Q = int(input())
    BC = []
    for _ in range(Q):
        bc = list(map(int, input().split()))
        BC.append(bc)

    ans = resolver(N, A, Q, BC)

    for a in ans:
        print(a)



if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np
def main():
    N = int(input())
    A = list(map(int, input().split()))
    Q = int(input())
    BC = [list(map(int, input().split())) for _ in range(Q)]


    Adict = dict()
    for a in A:
        Adict[a] = Adict.get(a, 0) + 1
    
    for b, c in BC:
        if b in Adict:
            tmp = Adict[b]
            Adict[c] = Adict.get(c, 0) + tmp
            Adict.pop(b)
        
        goukei = sum([k*v for k, v in Adict.items()])
        
        print(goukei)


if __name__ == '__main__':
    main()


Fixed submission:
def resolver(N, A, Q, BC):
    total = sum(A)
    counter = dict()
    ans = []
    for a in A:
        counter[a] = counter.get(a, 0) + 1
    
    for (b, c) in BC:
        c0 = counter.pop(b) if b in counter else 0
        counter[c] = counter.get(c, 0) + c0
        total -= c0 * b
        total += c0 * c
        ans.append(total)
    
    return ans

def test():
    pass

def main():

    #test()

    N = int(input())
    A = list(map(int, input().split()))
    Q = int(input())
    BC = []
    for _ in range(Q):
        bc = list(map(int, input().split()))
        BC.append(bc)

    ans = resolver(N, A, Q, BC)

    for a in ans:
        print(a)



if __name__ == '__main__':
    main()
Buggy python submission (verdict: Time Limit Exceeded):
def main():
    N = int(input())
    A = list(map(int, input().split()))

    counter = 0
    for i in range(N):
        for j in range(i, N):
            if j - i == A[i] + A[j]:
                counter += 1

    print(counter)

if __name__ == '__main__':
    main()


Fixed submission:
def test():
    import numpy as np
    N = 10000
    print(N)
    A = np.random.randint(0, 10, [N])
    print(count(N,A))


def count(N, A):
    #i < j
    #A[i] + A[j] == j - i
    #A[i] + i == j - A[j]
    left = dict()
    right = dict()
    for i in range(N):
        l = i+1 + A[i]
        r = i+1 - A[i]
        left[l] = left.get(l, 0) + 1
        right[r] = right.get(r, 0) + 1

    counter = 0
    for k, v in left.items():
        if k in right:
            counter += right[k] * v

    return counter

def main():
    #test()
    N = int(input())
    A = list(map(int, input().split()))

    result = count(N,A)
    print(result)

if __name__ == '__main__':
    main()
Buggy python submission (verdict: Runtime Error):
L = int(input())
print((L/3)**3

Fixed submission:
L = float(input())
print((L/3)**3)
Buggy python submission (verdict: Runtime Error):
[a, b, c] = map(int, input().split())
if(a==0 | b==0):
    Left = a+b
    Right = c
else:
    Left = 4*a*b
    Right = (c-a-b)*(c-a-b)
if(Left < Right):
    print('Yes')
else:
    print('No')

Fixed submission:
L = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K = int(input())
print(L[K-1])
Buggy python submission (verdict: Runtime Error):
A = int(input())
A_array = map(int, input().split())
A_sum = A_array[0] + A_array[1] + A_array[2]
if(A_sum < 22):
    print('win')
else:
    print('bust')


Fixed submission:
# coding: utf-8
A = list(map(int, input().split()))
A_sum = sum(A)
if(A_sum > 21):
    print('bust')
else:
    print('win')
Buggy python submission (verdict: Runtime Error):
import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
import sys
# sys.setrecursionlimit(1000000)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
# A = [LI() for _ in range(N)]

l = len(str(N))

if l <= 3:
    a = 1000 - N
elif N % 1000 == 0:
    a = 0
else:
    a = 1000 - (N % 1000) 

print(a)

Fixed submission:
import bisect,collections,copy,heapq,itertools,math,string
import sys
# sys.setrecursionlimit(1000000)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
# A = [LI() for _ in range(N)]

l = len(str(N))

if l <= 3:
    a = 1000 - N
elif N % 1000 == 0:
    a = 0
else:
    a = 1000 - (N % 1000) 

print(a)
Buggy python submission (verdict: Runtime Error):
import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]

mod = 10 ** 9 + 7

N, M, K = LS()
desk = LSR(2)
a, b = [0], [0]

# a = [0, 0 + A1, 0 + A1 + A2, ....]
# b = [0, 0 + B1, 0 + B1 + B2, ....]
for i in range(N):
    a.append(a[i] + desk[0][i])
for j in range(M):
    b.append(b[j] + desk[1][j])

# a + b <= K を求める　⇒　変形してb >= K - a とすることで、
# aは全件トライ、bのみ選択可能な最大値を算出することで計算量をO(N + M)に抑える
ans, j = 0, M 

for i in range(N + 1):
    if a > K:
        break
    while b[j] > K - a[i]:
        j -= 1
    ans = max(ans, i + j)

print(ans)

Fixed submission:
import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]

mod = 10 ** 9 + 7

N, M, K = LI()
desk = LIR(2)
a, b = [0], [0]

# a = [0, 0 + A1, 0 + A1 + A2, ....]
# b = [0, 0 + B1, 0 + B1 + B2, ....]
for i in range(N):
    a.append(a[i] + desk[0][i])
for j in range(M):
    b.append(b[j] + desk[1][j])

# a + b <= K を求める　⇒　変形してb >= K - a とすることで、
# aは全件トライ、bのみ選択可能な最大値を算出することで計算量をO(N + M)に抑える
ans, j = 0, M 

for i in range(N + 1):
    if a[i] > K:
        break
    while b[j] > K - a[i]:
        j -= 1
    ans = max(ans, i + j)

print(ans)
Buggy python submission (verdict: Runtime Error):
from _typeshed import ReadableBuffer
import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7

X, N = LI()
P = LI().sort()

# Pに含まれない整数（負も含まれる）で最もXに近くて最小の値を探す

if N == 0:
    print(X)
    sys.exit()

elif (X not in P) and (N != 0):
    print(X)
    sys.exit()

else:
    while X in P:
        X = X - 1
    print(X)
    sys.exit()

Fixed submission:
import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7

X, N = LI()
P = LI()
# u = X
# d = X
# Pに含まれない整数（負も含まれる）で最もXに近くて最小の値を探す

if N == 0:
    print(X)
    sys.exit()

elif (N != 0) and (X not in P):
    print(X)
    sys.exit()

Q = [q for q in range(-1, 102) if q not in P]  # -1以上101以下整数のうちPに存在しないもの
ans = min(Q, key=lambda x: (abs(x - X), x))  # maspyさん解法
# python の min() は、順序比較のためのキーを指定できて、abs(x-X) が最小のもののうち x が最小のものをとるとかはこんな感じで書いたりできます。
print(ans)