Harryxun/stf_run huggingface dataset:
c = input()
if c = "a" or c = "i" or c = "u" or c = "e" or c = "o":
	print("vowel")
    
else:
	print("consonant")

### FIXED CODE ###

c = input()
if c == "a" or c == "i" or c == "u" or c == "e" or c == "o":
	print("vowel")
    
else:
	print("consonant")
import sys
sys.setrecursionlimit(500*500)

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


for i in range(1, K+1) :
    if A >0:
        A -= 1
    elif B > 0 :
        B -= 1
        
print(A, B)
    

### FIXED CODE ###

A, B, K = map(int, input().split())

a = max(A-K, 0)
K -= A - a
b = max(B-K, 0)

print(a, b)
def Product(a,b):
  if (a*b)%2 == 0:
    return 'even'
  else:
    return 'odd'

Product(a,b)

### FIXED CODE ###

a, b = map(int, input().split())
print("Even" if a*b % 2 == 0 else "Odd")
k, x = map(int, input().split())
 if 500 * k >= x:
  print('Yes')
 else:
  print('No)

### FIXED CODE ###

k, x = map(int, input().split())
if 500 * k >= x:
    print('Yes')
else:
    print('No')
N, K = map(int, input().split())
mem = set()
for _ in range(K):
  _ = input()
  mem = mem | {input().split()}

mem_count = len(mem)
print(N-mem_count)

### FIXED CODE ###

N, K = map(int, input().split())
mem = set()
for _ in range(K):
  _ = input()
  mem = mem | set(map(int, input().split()))

mem_count = len(mem)
print(N-mem_count)
N, K = map(int, input().split())
proba = 0
if K == 1:
    print(1)
else:
    for n in range(0, N+1):
        for ii in range(17):
            if n * (2 ** ii) >= K:
                proba += (1 / N) * (2 ** (-ii))
                break
            
	print(proba)

### FIXED CODE ###

N, K = map(int, input().split())
proba = 0
for n in range(0, N+1):
    for ii in range(18):
        if n * (2 ** ii) >= K:
            proba += (1 / N) * (0.5 ** ii)
            break

print(proba)
input()
coords = input.split()
print(max(coords) - min(coords))

### FIXED CODE ###

input()
coords = list(map(int, input().split()))

print(max(coords) - min(coords))
a=int(input())
b=int(input())

print((a*b)-a-b+1)

### FIXED CODE ###

a,b=map(int,input().split())

print((a*b)-a-b+1)
a,b= map(int,raw_input().split());
if a<b ;
  print 'a<b';
else if a>b ;
  print 'a>b';
else
  print 'a==b' ;

### FIXED CODE ###

a,b= map(int,input().split());
if a < b :
	print("a < b" );
elif a > b :
	print("a > b" );
elif a == b :
	print("a == b") ;
i = input()


if i == "SSS":
    print(0)
elif i == "RRR":
    print(3)
elif i == "RSR" or "SSR" or "RSS" or "SRS":
    print(1)
elif i = "RRS" or "SRR":
    print(2)


### FIXED CODE ###

i = input()


if i == "SSS":
    print(0)
elif i == "RRR":
    print(3)
elif i == "RSR" or i == "SSR" or i=="RSS" or i=="SRS":
    print(1)
elif i == "RRS" or i=="SRR":
    print(2)
# coding:utf-8

N = int(input())
H = [int(hi) for hi in input().split()]

cost1, cost2 = 0, 0

def jump(_k: int, k: int, cost: int) -> int:
    global H, N
    cost += abs(H[_k] - H[k])
    if k == N-1:
        return cost
    if k+1 <= N-1:
        cost1 = jump(k, k+1, cost)
    if k+2 <= N-1:
        cost2 = jump(k, k+2, cost)
    else:
        cost2 = cost1
    if cost1 <= cost2:
        return cost1
    else:
        return cost2

if N == 2:
    cost1 = jump(0, 1, 0)
    print(cost1)
else:
    cost1 = jump(0, 1, 0)
    cost2 = jump(0, 2, 0)
    if cost1 > cost2:
        print(cost2)
    else:
        print(cost1)


### FIXED CODE ###

# coding:utf-8

N = int(input())
H = [int(hi) for hi in input().split()]
dp = [0]*N
dp[1] = abs(H[0]-H[1])

for i in range(2, N):
    dp[i] = min(abs(H[i]-H[i-2])+dp[i-2],abs(H[i]-H[i-1])+dp[i-1])
    
print(dp[N-1])
a, b, c, d = map(int, input().split())
import math
lcm = c * d / math.gcd(c, d)
#1~a
a_count = (a-1)//c + (a-1)//d - (a-1)//lcm
b_count = b//c + b//d - b//lcm
answer = b_count - a_count
print(b - a + 1 - answer)


### FIXED CODE ###

def gcd(x, y):
    if x == 0:
        return y
    else:
        return gcd(y % x, x)


def lcm(x, y):
    return x * y // gcd(x, y)


def calc(n, x, y):
    z = lcm(x, y)
    return n // x + n // y - n // z


a, b, c, d = map(int, input().split())
ans = calc(b, c, d) - calc(a-1, c, d)
print(b - a + 1 - ans)
import numpy as np
K=int(input()) 

S=""
count=-1

for i in range(K):
  S += "7"
  M = int(S):
  if( M%K == 0):
    count = i+1
    break

print(count)

### FIXED CODE ###

import numpy as np
K=int(input()) 

S=0
count=-1

for i in range(K):
  S = (S*10)%K
  S = (S+7)%K
  if( S == 0):
    count = i+1
    break

print(count)
n = int(input())
m = int(input())
print((n -1 )*(m - 1))

### FIXED CODE ###

n, m = map(int, input().split())
print((n-1)*(m-1))
import numpy as np
N = int(input())
T = []

for i in range(N):
    t = int(input())
    T.append(t)

print(np.lcm.reduce(T))


### FIXED CODE ###

import fractions
n=int(input())
ans=int(input())
for i in range(n-1):
  t=int(input())
  ans=(ans*t)//fractions.gcd(t,ans)
print(ans)
from fratcions import gcd

n = int(input())
ans = 1

for _ in range(n):
	i = int(input())
	ans = int(ans / gcd(ans, i) * i)

print(ans)

### FIXED CODE ###

from fractions import gcd

n = int(input())
ans = 1

for _ in range(n):
	i = int(input())
	ans = ans // gcd(ans, i) * i

print(ans)
val, size = map(int, input().split())
disabledList = [int(x) for x in input().split()] # number
enableList = list(set(range(10)) - set(disabledList)) # number
resultList = [] # int, must reverse
isTenOver = False
for char in list(str(val)).reverse():
  targetInt = int(char)
  if isTenOver:
    targetInt += 1
  if int(char) in enableList:
    isTenOver = False
    resultList.append(char)
  elif int(char) > max(enableList):
    isTenOver = True
    resultList.append(str(min(enableList)))
  else:
    isTenOver = False
    minNum = min(filter(lambda x:x > int(char), enableList))
    resultList.append(str(minNum))

if isTenOver:
  minNum = min(filter(lambda x:x > 0, enableList))
  resultList.append(str(minNum))
print(''.join(resultList.reverse()))

### FIXED CODE ###

val, size = map(int, input().split())
disabledList = [int(x) for x in input().split()] # number
enableList = list(set(range(10)) - set(disabledList)) # number
resultList = [] # str, must reverse
isTenOver = False
for char in reversed(list(str(val))):
  targetInt = int(char)
  if isTenOver:
    targetInt += 1
  if targetInt in enableList:
    isTenOver = False
    resultList.append(str(targetInt))
    continue
  resultList = [str(min(enableList))] * len(resultList)
  if targetInt > max(enableList):
    isTenOver = True
    resultList.append(str(min(enableList)))
  else:
    isTenOver = False
    minNum = min(filter(lambda x:x > targetInt, enableList))
    resultList.append(str(minNum))

if isTenOver:
  minNum = min(filter(lambda x:x > 0, enableList))
  resultList.append(str(minNum))
print(''.join(reversed(resultList)))
n = int(input())
list_a = list(map(int, input().split()))

list_a.sort()

counts = []

for i in range(1, 100000):
    if i in list_a:
        counts.append(list_a.count(i))
    else:
        counts.append(0)

q = int(input())
ans = sum(list_a)

for i in range(q):
    b, c = map(int, input().split())

    ans += counts[b-1] * (c - b)

    counts[c-1] += counts[b-1]
    counts[b-1] = 0

    print(ans)


### FIXED CODE ###

import numpy as np

n = int(input())
list_a = list(map(int, input().split()))

counts = np.zeros(100000, dtype=int)

ans = 0

for i in range(len(list_a)):
    counts[list_a[i]-1] += 1
    ans += list_a[i]

q = int(input())

for i in range(q):
    b, c = map(int, input().split())

    ans += counts[b-1] * (c - b)

    counts[c-1] += counts[b-1]
    counts[b-1] = 0

    print(ans)
a = [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 = input()
print(a[k+1])

### FIXED CODE ###

a = [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 = input()
print(a[int(k)-1])
def resolve():
    N = int(input())
    As = list(map(int, input().split(" ")))
    pos = []
    neg = []
    for a in As:
        if a >= 0:
            pos.append(a)
        else:
            neg.append(a)
    pos.sort()
    neg.sort()
    x = 0
    y = 0
    ops = []
    while True:
        if len(pos) > 0 and len(neg) > 0:
            if len(pos) > len(neg):
                x = neg.pop(0)
                y = pos.pop()
            else:
                x = pos.pop()
                y = neg.pop(0)
        elif len(pos) > 1 and len(neg) == 0:
                x = pos.pop(0)
                y = pos.pop()
        elif len(neg) > 1 and len(pos) == 0:
                x = pos.pop()
                y = pos.pop(0)
        else:
            raise Exception("Unreachable?")
        
        ops.append("{} {}".format(x, y))
        xmy = x - y

        if xmy >= 0:
            pos.append(xmy)
        else:
            neg.insert(0, xmy)
        
        if len(pos + neg) == 1:
            print((pos + neg)[0])
            break
    
    [print(i) for i in ops]

if '__main__' == __name__:
    resolve()

### FIXED CODE ###

from collections import deque
def resolve():
    N = int(input())
    As = list(map(int, input().split(" ")))
    pos = []
    neg = []
    for a in As:
        if a >= 0:
            pos.append(a)
        else:
            neg.append(a)
    pos = deque(sorted(pos))
    neg = deque(sorted(neg))
    x = 0
    y = 0
    ops = []
    while True:
        if len(pos) > 0 and len(neg) > 0:
            if len(pos) > len(neg):
                x = neg.popleft()
                y = pos.pop()
            else:
                x = pos.pop()
                y = neg.popleft()
        elif len(pos) > 1 and len(neg) == 0:
                x = pos.popleft()
                y = pos.pop()
        elif len(neg) > 1 and len(pos) == 0:
                x = neg.pop()
                y = neg.popleft()
        else:
            raise Exception("Unreachable?")
        
        ops.append("{} {}".format(x, y))
        xmy = x - y

        if len(pos) == 0 and len(neg) == 0:
            print(xmy)
            break

        if xmy >= 0:
            pos.append(xmy)
        else:
            neg.appendleft(xmy)
        
    [print(i) for i in ops]

if '__main__' == __name__:
    resolve()
n, m = map(int, input().split())

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

ikeru = [set() for _ in range(m+1)]

for i,j in tsuro:
    ikeru[i].add(j)
    ikeru[j].add(i)

ans = [0]*(n+1)
visited = [n+5]*(n+1)

def dfs(mae,heya,kaiso):
    if visited[heya] <= kaiso:
        return True
    else:
        visited[heya] = kaiso
        ans[heya] = mae
        for j in ikeru[heya]:
            dfs(heya, j, kaiso+1)
        return True

hantei = True
dfs(0,1,0)
for i in range(1, n+1):
    if visited[i] == n+5:
        hantei = False
if hantei:
    print('Yes')
    for j in range(2,n+1):
        print(ans[j])
else:
    print('No')


### FIXED CODE ###

from collections import deque

n, m = map(int,input().split())
graph =[[] for _ in range(n+1)]
for _ in range(m):
    a,b =map(int, input().split())
    graph[a].append(b)
    graph[b].append(a)
queue = deque([1])
visited = [False] * (n+1)
visited[0] = True
ans = [0] * (n+1)
while queue:
    node = queue.popleft()
    for xnode in graph[node]:
        if visited[xnode]:
            continue
        ans[xnode]=node
        visited[xnode]=True
        queue.append(xnode)
print("Yes")
for a in ans[2:]:
    print(a)
def main():
    n, m = map(int, raw_input().split())
    min_id = 1
    max_id = n
    for _ in xrange(m):
        l, r = map(int, raw_input().split())
        min_id = max(min_id, l)
        max_id = min(max_id, r)e
    print max(0, max_id - min_id + 1)


if __name__ == '__main__':
    main()


### FIXED CODE ###


def main():
    n, m = map(int, raw_input().split())
    min_id = 1
    max_id = n
    for _ in xrange(m):
        l, r = map(int, raw_input().split())
        min_id = max(min_id, l)
        max_id = min(max_id, r)
    print max(0, max_id - min_id + 1)


if __name__ == '__main__':
    main()
N,M=map(int,input().split())
x=map(int,input().split())
x=sorted(x)
leng=list()

if(M==1):
    print(0)
    exit()
for i in range(0,len(x)-1):
    leng.append([x[i+1]-x[i],i])
leng=sorted(leng)

n=N
max=len(leng)-1
sets=list()
while n>1:
    n-=1
    sets.append(leng[max][1]+1)
    max-=1

for i in x:
    if(x.index(i) not in sets):
        sets.append(x.index(i))
        break
sets=sorted(sets)
ans=0

for i in range(0,len(sets)-1):
    ans+=x[sets[i+1]-1]-x[sets[i]]

ans+=x[-1]-x[sets[-1]]

print(ans)

### FIXED CODE ###

N,M=map(int,input().split())
x=list(map(int,input().split()))
x=sorted(x)
leng=list()

if(N>M):
    N=M
if(M==1):
    print(0)
    exit()
for i in range(0,len(x)-1):
    leng.append([x[i+1]-x[i],i])
leng=sorted(leng)

n=N
max=len(leng)-1
sets=list()
while n>1:
    n-=1
    sets.append(leng[max][1]+1)
    max-=1

for i in x:
    if(x.index(i) not in sets):
        sets.append(x.index(i))
        break
sets=sorted(sets) 
ans=0
for i in range(0,len(sets)-1):
    ans+=x[sets[i+1]-1]-x[sets[i]]

ans+=x[-1]-x[sets[-1]]

print(ans)
n = int(input())
a = list(map(int,input().split()))
q = int(input())

dp = [0] *( 10 ** 5)

bc = [input() for _ in range(q)]

for ai in a:
  dp[ai] += 1
ans = 0
for i in range(1,len(dp)):
  ans += dp[i] * i
  
for bci in bc:
  b,c = map(int,bci.split())
  ans += (dp[b] * c) -(dp[b] * b)
  print(ans)
  dp[c] += dp[b] 
  dp[b] = 0
  



### FIXED CODE ###

n = int(input())
a = list(map(int,input().split()))
q = int(input())

dp = [0] *( 10 ** 5 +10)

bc = [input() for _ in range(q)]

for ai in a:
  dp[ai] += 1
ans = 0
for i in range(1,len(dp)):
  ans += dp[i] * i
  
for bci in bc:
  b,c = map(int,bci.split())
  ans += (dp[b] * c) -(dp[b] * b)
  print(ans)
  dp[c] += dp[b] 
  dp[b] = 0
def main120():
    import sys
    S_org = input()
    S = []

    for s in range(len(S_org)):
        S.append(S_org[s])
    S = list(map(int, S))

    cont = True
    index = 0
    count = 0

    if len(S) == 1:
        print(0)
        sys.exit()

    else:
        while(cont):
            print(index)
            if S[index] == S[index+1]:
                index += 1
            else:
                count += 2
                S.pop(index)
                S.pop(index)
                if index > 0:
                    index -= 1

            if index == len(S) - 2:
                if S[index] != S[index+1]:
                    count += 2
                print(count)
                sys.exit()


main120()

### FIXED CODE ###

A, B, C = (int(x) for x in input().split())

count = int(B/A)
if count <= C:
    print(count)
else:
    print(C)
import sys

def main():
  input = sys.stdin.readline
  S = str(input().strip())
  ans = 0
  for c in S:
    if c == +:
      ans += 1
    else:
      ans -= 1
  print(ans)


if __name__ == '__main__':
  main()

### FIXED CODE ###

import sys

def main():
  input = sys.stdin.readline
  S = str(input().strip())
  ans = 0
  for c in S:
    if c == '+':
      ans += 1
    else:
      ans -= 1
  print(ans)


if __name__ == '__main__':
  main()
N= int(input());E = [input().split()[2:] for _ in range(N)]
frag, T, L,Q = [0]*N, [0]*N, [0]*N, [0]
a,frag[0] = 100, 1
def func(ide):
    for i in E[ide]:
        i = int(i) - 1
        if frag[i] != 1:frag[i] = 1;L[i] = L[ide] +1 ;Q.append(i) 
        else:return

while Q:top = Q[0];func(top);del Q[0]
for i in n:
    if L[i] == 0:
        L[i] == -1

for i in range(N):print(i + 1 ,int(L[i]))



### FIXED CODE ###

N= int(input())
E = [input().split()[2:] for _ in range(N)]
Q = [0]
L = [0] + [-1]*N
frag = [1] + [0]*N
def func(ide):
    global Q
    for i in E[ide]:
        i = int(i) - 1
        if frag[i] != 1:frag[i] = 1;L[i] = L[ide] +1 ;Q.append(i)
        
    

while Q:top = Q[0];func(top);del Q[0]

for i in range(N):print(i + 1 ,int(L[i]))
n,m,k = map(int,input().split())

for i in range(n):

    if (n-2*i) != 0 and (k-m*i) % (n-2*i) == 0:
        j = (k - m * i) // (n - 2 * i)
        if w*i + (n-2*i)*j == k:
            print('Yes')
            exit()
print('No')


### FIXED CODE ###

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

for i in range(n):

    if (n-2*i) != 0 and (k-m*i) % (n-2*i) == 0:
        j = (k - m * i) // (n - 2 * i)
        if 0 <= j <= m:
            print('Yes')
            exit()
print('No')
a=input()
def dfs(i,s,l):
    if i==3:
        if s==7:
            print(l+'=7')
    else:
        dfs(i+1,s+int(a[i+1]),l+'+'+a[i+1])
        dfs(i+1,s-int(a[i+1]),l+'-'+a[i+1])

dfs(dfs(0,int(a[0]),a[0]))

### FIXED CODE ###

def dfs(i, f, sum):
    if i == 3:
        if sum == 7:
            # 答えは1つ出力すれば良いので =7 になれば終了
            print(f + "=7")
            exit()

    else:
        # 式 f の末尾に符号と次の数字を追加し、その分 sum に加減する
        dfs(i + 1, f + "-" + s[i + 1], sum - int(s[i + 1]))
        dfs(i + 1, f + "+" + s[i + 1], sum + int(s[i + 1]))


s = input()

dfs(0, s[0], int(s[0]))
H, W = map(int, input().split())
maze = np.array([[c == '#' for c in input()] for _ in range(H)], dtype=bool)

n_walls = np.sum(maze)
n_aisle = W * H - n_walls

d = dict(enumerate(map(dict, map(enumerate, maze))))
directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
adj = {(i, j): {(i + k, j + l): 1 for k, l in directions if not d.get(i + k, {}).get(j + l, True)}
       for i in range(H) for j in range(W) if not d[i][j]}
start = (0, 0)
end = (H-1, W-1)
for i in adj.keys():
    for j in adj.keys():
        for k in adj.keys():
            distance = adj.get(i, {}).get(k, np.inf) + adj.get(k, {}).get(j, np.inf)
            if adj.get(i, {}).get(j, np.inf) > distance:
                adj[i][j] = distance
if np.isinf(adj[start][end]):
    print(-1)
else:
    print(n_aisle - adj[start][end] - 1)


### FIXED CODE ###

H, W = map(int, input().split())
maze = []
distances = []
n_aisle = 0
for i in range(H):
    row = input()
    maze.append(row)
    distances.append([100000000 for i in range(W)])
    n_aisle += row.count('.')

distances[0][0] = 0
directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]

visited = [(0, 0)]
queue = [(0, 0)]
while len(queue) > 0:
    y, x = queue.pop(0)
    for dy, dx in directions:
        y2, x2 = y + dy, x + dx
        if y2 < 0 or y2 >= H or x2 < 0 or x2 >= W:
            continue
        if (y2, x2) in visited:
            continue
        if maze[y2][x2] == '.':
            distances[y2][x2] = distances[y][x] + 1
            visited.append((y2, x2))
            queue.append((y2, x2))

if distances[H - 1][W - 1] == 100000000:
    print(-1)
else:
    print(n_aisle - distances[H - 1][W - 1] - 1)
#-*- coding:utf-8 -*-
N = int(input())
a1 = []
a2 = []
s,t = 0,0
for i in range(N):
	a1.append(int(input()))
for i in range(N):
	a2.append(int(input()))


for i in range(N-1):
	for j in range(i):
		t += a1[j]
	for k in range(N-1-i):
		t += a2[i+k]
	if t > s:
	    s = t
	t = 0
print(s)

### FIXED CODE ###

#-*- coding:utf-8 -*-
x = int(input())
a = int(input())
b = int(input())

print((x-a)-b*((x-a)//b))
if int(input())%10 == 3:
	print("bon")
  
elif int(input())%10 == 0 or1 or 6 or 8:
	print("pon")
 
else:
	print("hon")

### FIXED CODE ###

a=input()

if int(a)%10 == 3:
	print("bon")
  
elif int(a)%10 == 0:
	print("pon")
    
elif int(a)%10 == 1:
	print("pon")

elif int(a)%10 == 6:
	print("pon")
    
elif int(a)%10 == 8:
	print("pon")    
    
else:
	print("hon")
X=int(input())
import math
print(360*X//math.gcd(360,X)

### FIXED CODE ###

X=int(input())
import math
a=360*X//math.gcd(360,X)
print(a//X)
D=int(input())
if D==25:
    print('Christmas')
elif D==24:
    print('Christmas Eve')
elif D=23:
    print('Christmas Eve Eve')
else:
    print('Christmas Eve Eve Eve')

### FIXED CODE ###

D=int(input())
if D==25:
    print('Christmas')
elif D==24:
    print('Christmas Eve')
elif D==23:
    print('Christmas Eve Eve')
else:
    print('Christmas Eve Eve Eve')
N = int(input())
S = str(input())

if N % 2 != 0:
  print('No')

if S[:N / 2] == S[N / 2:]:
  print('Yes')

### FIXED CODE ###

N = int(input())
S = str(input())

if N % 2 == 0:
    T = S[:int(N/2)]
    if S == T + T:
        print('Yes')
    else:
      print('No')
else:
    print('No')
s = input()
li = ["A","T","C","G"]

cnt = 0
cntli = []
for i in range(len(s)):
    if s[i] in li:
        cnt += 1
    else:
        cntli.append(cnt)
        cnt = 0

print(max(cntli))

### FIXED CODE ###

s = input()
li = ["A","T","C","G"]

cnt = 0
cntli = []
for i in range(len(s)):
    if s[i] in li:
        cnt += 1
    else:
        cntli.append(cnt)
        cnt = 0
else:
    cntli.append(cnt)

print(max(cntli))
s=input()
l=soted(s)
if l[0]=='a' and l[1]=='b' and l[2]=='c':
  print('Yes')
else:
  print('No')

### FIXED CODE ###

s=list(input())
s.sort()
if s[0]=='a' and s[1]=='b' and s[2]=='c':
  print('Yes')
else:
  print('No')
X,N=map(int,input().split())
P=list(map(int,input().split()))

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

if X<min(P):
    ans=X
    print(ans)
    
elif X in range(min(P),max(P)+1):
    #大した大きい数じゃないので全探索すればいい
    ans_len=200 #ひとまずの仮定
    for i in range(min(P),max(P)+1):
        if i in P:
            continue
        else:
            l=abs(X-i)
            if l < ans_len:
                ans_len=l
                ans=i
    print(ans)
                
else:
    ans=X
    print(ans)

### FIXED CODE ###

X,N=map(int,input().split())
P=list(map(int,input().split()))

if N==0:
    print(X)
else:
    if X<min(P):
        ans=X
        print(ans)
    
    elif X in range(min(P),max(P)+1):
        #大した大きい数じゃないので全探索すればいい
        ans_len=200 #ひとまずの仮定
        for i in range(250):
            if i in P:
                continue
            else:
                l=abs(X-i)
                if l < ans_len:
                    ans_len=l
                    ans=i
        print(ans)
                
    else:
        ans=X
        print(ans)
s = input()
if(s[1:2]==s[2:3] and s[3:4]==s[4:5]){print("Yes")}
else{print("No")}

### FIXED CODE ###

s = input()
if(s[2:3]==s[3:4] and s[4:5]==s[5:6]):
  print("Yes")
else:
  print("No")
import sys
from collections import Counter

n, *s = sys.stdin.read().split()

def main():
    c = Counter(s)
    m = max(c.values())
    ans = [s for s, c in cnt.items if c == m]
    print(*sorted(ans), sep='\n')
         
if __name__ ==  '__main__':
    main()

### FIXED CODE ###

import sys
from collections import Counter

n = int(sys.stdin.readline().rstrip())
s = sys.stdin.read().split()

def main():
    c = Counter(s)
    ma = max(c.values())
    res = []
    for l, v in c.items():
        if v == ma:
            res.append(l)
    return sorted(res)

if __name__ == '__main__':
    ans = main()
    print(*ans, sep='\n')
from functools import lru_cache
@lru_cache(maxsize=1000)
def fib(n):
	if n < 2:
		return n
	else:
		return fib(n - 1) + fib(n - 2)



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

a.append(n)

b = []
for i in range(n+1):
	b.append(fib(i))
	
c = []
#if a[1] == 0:
	#c.append(1)
#else:
	#c.append(b[a[1] - a[0] ])
	
	
i = 0
while i <= m + 1:
	if a[i + 1] - a[i] - 2 >= 0:
		c.append(b[a[i + 1] - a[i]  - 2])
		i += 1
	#elif a[i + 1] - a[i] - 2 == 0:
		#c.append(1)
	else:
		c.append(0)
		break
#print(c)
d = c[0] 
i = 1
#print(d)
while i < len(c):
	d = d * c[i]
	i += 1

e = 1000000007
print(d % e)
#print(b[0])

### FIXED CODE ###

n,m = map(int,input().split())
mod = 10**9 + 7
a = [1] * (n+1)
for i in range(m):
    b = int(input())
    a[b] = 0

        
for i in range(2,n+1):
    if a[i] != 0:
        a[i] = a[i-1] + a[i-2]
#print(a)
print(a[n] % mod)