Harryxun/stf_run huggingface dataset:
File Edit Options Buffers Tools Python YASnippet Help                               
import sys

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

flag = 0

for i in range(len(H) - 1):
    if H[i] > H[i+1] + 1:
        print('No')
        sys.exit()

    elif H[i] == H[i+1] + 1:
        if flag == 0:
            flag = 1
            continue
        else:
            print('No')
            sys.exit()

    if flag == 1:
        if H[i] > H[i+1]:
            print('No')
            sys.exit()
        else:
            flag = 0

print('Yes')

### FIXED CODE ###

import sys
N = int(input())
H = [int(x) for x in input().split()]

flag = 0
key = 0

for i in range(len(H)-1):
    if flag == 1:
        if H[i+1] < key:
            print('No')
            sys.exit()

    if i < len(H) - 1:
        if H[i] > H[i+1] + 1:
            print('No')
            sys.exit()

        elif H[i] == H[i+1] + 1:
            flag = 1
            key = H[i+1]
	
print('Yes')
a = [ input() for i in range(n)]
n = int(a[0])
s = a[0]
if n % 2 == 1:
  print("No")

if s[0:n/2] == s[n/2:]:
  print("Yes")
else:
  print("No")


### FIXED CODE ###

n = int(input())
s = input()
if n % 2 == 1:
  print("No")
else:
	if s[0:n//2] == s[n//2:]:
  		print("Yes")
	else:
  		print("No")
import math

def factorization(n):
    arr = []
    tmp = n
    for div in range(2, int(math.sqrt(n)) + 2):
        if tmp % div == 0:
            cnt = 0
            while tmp % div == 0:
                cnt += 1
                tmp //= div
            arr.append([div, cnt])

    if tmp != 1:
        arr.append([tmp, 1])

    if len(arr) == 0:
        arr.append([n, 1])

    return arr

if __name__ == '__main__':
    A, B = map(int, input().split())
    gcd = math.gcd(A, B)
    if gcd == 1:
        print(1)
        exit()
    facts = factorization(gcd)
    print(len(facts) + 1)

### FIXED CODE ###

import math
import fractions
gcd = math.gcd if hasattr(math, "gcd") else fractions.gcd

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

def factorize(n):
    b = 2
    fct = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            fct.append(b)
        b = b + 1
    if n > 1:
        fct.append(n)
    return fct

g = gcd(A, B)

print(len(set(factorize(g)))+1)
def inpl(): return list(map(int, input().split()))
W, H, x, y = inpl()
if x > W/2:
    x = W-x
if y > H/2:
    y = H-y

a = W*y
b = H*x
if x == 0 or y == 0:
    print(H*W/2, 0)
elif W/H == x/y:
    print(H*W/2, int(W/2==x))
elif a > b:
    print(a, int(2*x == W))
else:
    print(b, int(2*y == H))
    raise

### FIXED CODE ###

W, H, x, y = map(int, input().split())
print(H*W/2, int((2*y == H)&(2*x == W)))
study = (60*H2 + M2) - (60*H1 + M1) - K
study

### FIXED CODE ###

h1,m1,h2,m2,k = map(int, input().split())
print( 60* (h2-h1) + m2 - m1 - k )
L=int(input())
R=int(input())
d=int(input())
count=int(0)
for i in range(L,R):
    if i%d==0:
        count+=1
print count

### FIXED CODE ###

L,R,d = map(int,input().split())
count=int(0)
for i in range(L,R+1):
    if i%d==0:
        count+=1
print(count)
def index(a, x):
    'Find leftmost index of item greater than or equal to x'
    i = bisect_left(a, x)
    if i != len(a):
        return i
    return False

def main():
    N = int(input())
    S = input()
    lst = list(S)

    a = []
    for i,j,k in itertools.combinations(range(N), 3):
        if i < j < k:
            s = int(str(lst[i])+str(lst[j])+str(lst[k]))

            idx = bisect_left(a, s)

            if idx == len(a):
                a.append(s)
            
            elif a[idx] != s:
                a.insert(idx, s)

    print(len(a))

if __name__ == "__main__":
    main()

### FIXED CODE ###

def main():
    N = int(input())
    S = input()
    lst = list(S)

    a = ['{:03d}'.format(i) for i in range(1000)]
    count = 0
    for i in range(len(a)):
        m,n,o = 0,1,2
        s = list(a[i])
        while m < n < o < len(lst) :
            if s[0] != lst[m]:
                m += 1
                n += 1
                o += 1
            elif s[1] != lst[n]:
                n += 1
                o += 1
            elif s[2] != lst[o]:
                o += 1
            else:
                count += 1
                break

    print(count)

if __name__ == "__main__":
    main()
n,a,b,c,d = map(int,input().split())
s = input()
flg = False
if c < d:
    #最後まで動かす
    flg = True
else:#c>d
    if '...' in s[a-1:]:
        flg = True
        if not('...' in s[:d-1]):
            flg = False
        else if (b>3):
            if '...' in s[:b]:
                flg = False
if '##' in s:
    flg = False
if flg:
    print('Yes')
else:
    print('No')


### FIXED CODE ###

n,a,b,c,d = map(int,input().split())
s = input()
flg = False
if c < d:
    #最後まで動かす
    flg = True
else:#c>d
    if '...' in s[b-2:d+1]:
        flg = True
if '##' in s[a-1:max(d,c)-1]:
    flg = False
if flg:
    print('Yes')
else:
    print('No')
S = input()
s = s[0]
ans = 0
for i in S:
    if s != i:
        ans += 1
        s = i
print(ans)

### FIXED CODE ###

S = list(input())
flag = S[0]
flag_num = 0
ans = 0


for i in range(len(S)):
    if flag != S[flag_num]:
        ans += 1
        flag = S[flag_num]
    
    flag_num += 1
print(ans)
import sys

sys.setrecursionlimit(500 * 500)

n, m = map(int, input().split())
graph = [[] for _ in range(n + 1)]
for _ in range(n):
    a, b = map(int, input().split())
    graph[a].append(b)
    graph[b].append(a)

visit = [0] * (n + 1)
ans = 0


def dfs(now, depth):
    global ans
    if visit[now]:
        pass
    if depth == n:
        ans += 1

    visit[now] = 1
    if graph[now]:
        for i in graph[now]:
            if visit[i] == 0:
                dfs(i, depth + 1)
    visit[now] = 0


dfs(1, 1)
print(ans)


### FIXED CODE ###

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)

visit = [0] * (n + 1)


def dfs(now, depth):
    if visit[now]:
        return 0
    if depth == n:
        return 1

    count = 0
    visit[now] = 1
    if graph[now]:
        for i in graph[now]:
            count += dfs(i, depth + 1)
    visit[now] = 0

    return count


ans = dfs(1, 1)
print(ans)
s=input()
a=list(input.split(","))
print(*a)

### FIXED CODE ###


s=input()
a=list(s.split(","))
print(*a)
N = int(input())
num = input().sprit()

count = 0

for i in range(N-3):
  if num[i] < num[i+1] < num[i+2]:
    count += 1
  elif num[i] > num[i+1] > num[i+2]:
    count += 1

print(count)
    

### FIXED CODE ###

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

count = 0

for i in range(N-2):
  if num[i]>num[i+1]>num[i+2] or num[i]<num[i+1]<num[i+2]:
    count += 1

print(count)
x, n = map(int,input().split())

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

p.append(x)

d =100

for i in range(1,101):
    if i not in p:
        d_temp = abs(x-i)
        if d_temp < d:
            d = d_temp
            n_i = i

            
if n == 0:
    print(x)
else:
    print(n_i)


### FIXED CODE ###

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

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

d =100
num = 0

if n == 0:
    num = x
else:
    for i in range(102):
        if i not in p:
            d_temp = abs(x-i)
            if d_temp < d:
                d = d_temp
                num = i
print(num)
import numpy as np

n=int(input())
a=np.array(list(map(int,input().split())))
b=np.array(list(map(int,input().split())))

c=[]
for i in range(n):
    c.append(a[i] - b[i])

c.sort(reverse=True)
d=np.array(c)
z=np.sum(d < 0)

x=np.sum(d[ d < 0])
y=np.sum(d[ d > 0])

if x == 0:
    print("0")
    exit()

if x + y < 0:
    print("-1")
    exit()    

for i,num in enumerate(c)
    x += num
    if x >= 0:
        print(z+i+1)

### FIXED CODE ###

import numpy as np

n=int(input())
a=np.array(list(map(int,input().split())))
b=np.array(list(map(int,input().split())))

c=[]
for i in range(n):
    c.append(a[i] - b[i])

c.sort(reverse=True)
d=np.array(c)
z=np.sum(d < 0)

x=np.sum(d[ d < 0])
y=np.sum(d[ d > 0])

if x == 0:
    print("0")
    exit()

if x + y < 0:
    print("-1")
    exit()    

for i,num in enumerate(c):
    x += num
    if x >= 0:
        print(z+i+1)
        exit()
N, K = map(int, input().split())
h = list(map(int, input().split()))
dp = [None] * N

def solve(n):
    if dp[n] is not None:
        return dp[n]

    if n == 0:
        dp[n] = 0
    elif n == 1:
        dp[n] = abs(h[0] - h[1])
    else:
        ans = 10**10
        for i in range(1, K+1):
            if n - i < 0:
                break
            if dp[n - i] is not None:
                temp = dp[n - i]
            else:
                temp = solve(n - i)
            ans = min(ans, temp + abs(h[n - i] - h[n]))
        dp[n] = ans

    return dp[n]

print(solve(N-1))

### FIXED CODE ###

n, k = map(int, input().split())
h = list(map(int, input().split()))
dp = [0] * n

for i in range(n):
    if i == 0:
        dp[0] = 0
    elif i == 1:
        dp[1] = abs(h[0]-h[1])
    else:
        costs = []
        for j in range(1, k+1):
            if j > i:
                break
            if abs(h[i-j]-h[i]) == 0:
                costs.append(dp[i-j])
                break
            costs.append(dp[i-j] + abs(h[i-j]-h[i]))

        # if i == 3:
        #     print(costs)
        dp[i] = min(costs)

#print(dp)
print(dp[n-1])
# D - Match Matching

N, M = map(int, input().split())
A = sorted(list(map(int, input().split())), reverse = True)

n_match = [-1,2,5,5,4,5,6,3,7,6]

dp = [-1] * (N+1) # dp[i]はちょうどi本のマッチ棒で作れる最も桁数の多い整数の桁数

dp[0] = 0
for idx in range(1,N+1):
    tmp = []
    for x in A:
        if idx - n_match[x] >= 0:
            tmp.append(dp[idx - n_match[x]] + 1)
    if tmp:
        dp[idx] = max(tmp)

ans = ""
rest_match = N
while len(ans) <= N//2 and rest_match > 0:
    for x in A:
        if dp[rest_match - n_match[x]] == dp[rest_match] - 1:
            ans += str(x)
            rest_match -= n_match[x]
            break
            
print(ans)

### FIXED CODE ###

# D - Match Matching

N, M = map(int, input().split())
A = sorted(list(map(int, input().split())), reverse = True)

n_match = [-1,2,5,5,4,5,6,3,7,6]

dp = [-1] * (N+1) # dp[i]はちょうどi本のマッチ棒で作れる最も桁数の多い整数の桁数

dp[0] = 0
for idx in range(1,N+1):
    tmp = []
    for x in A:
        if idx - n_match[x] >= 0:
            tmp.append(dp[idx - n_match[x]] + 1)
    if tmp:
        dp[idx] = max(tmp)

ans = ""
rest_match = N
while len(ans) <= N//2 and rest_match > 0:
    for x in A:
        if rest_match - n_match[x] >= 0 and dp[rest_match - n_match[x]] == dp[rest_match] - 1:
            ans += str(x)
            rest_match -= n_match[x]
            break
            
print(ans)
from random import randint
import sys #追加
sys.setrecursionlimit(10**8)
N,K=map(int,input().split())
A=list(map(int,input().split()))
ans=[]
def saiki(B):
    if len(B)==K+1:
        ans.append(B)
        print(B[-1])
        return
    B.append(A[B[-1]-1])
    saiki(B)
saiki([1])
#print(ans)


### FIXED CODE ###

N,K=map(int,input().split())
A=list(map(int,input().split()))
kari=set()
hako=set()
count=1
cnt=1
zahyo=0
ans=0
kari.add(zahyo)
if K<=10**6:
    for i in range(K):
        ans=A[ans]-1
    print(ans+1)
    exit()
for i in range(N):
    zahyo=A[zahyo]-1
    if zahyo not in kari:
        kari.add(zahyo)
        count+=1
    else:
        break

hako.add(zahyo)
for i in range(N):
    zahyo=A[zahyo]-1
    if zahyo not in hako:
        hako.add(zahyo)
        cnt+=1
    else:
        break
count=len(kari)
cnt=len(hako)
kaisu=K-count
#print(zahyo)
if kaisu>N:
    kaisu=kaisu%cnt
for i in range(kaisu):
    zahyo=A[zahyo]-1
#print(zahyo,kaisu,count,cnt)
#print(kari,hako)
print(zahyo+1)
N = int(input())
zeinuki = math.floor(N / 1.08)
print(':('if N != math.floor(zeinuki * 1.08) else zeinuki)

### FIXED CODE ###

import math
N = int(input())
zeinuki = math.floor(N / 1.08)
if N != math.floor(zeinuki * 1.08):
  if N != math.floor((zeinuki + 1) * 1.08):
    print(':(')
  else:
    print(zeinuki + 1)
else:
  print(zeinuki)
S = input()
S_list = list(set(S))
string = "qazwsxedcrfvtgbyhnujmikolp"
str_list = list(string)
str_list.sort()
for a in S_list:
    str_list.remove(a)
print(str_list.pop(0))

### FIXED CODE ###

S = input()
S_list = list(set(S))
string = "qazwsxedcrfvtgbyhnujmikolp"
str_list = list(string)
str_list.sort()
for a in S_list:
    str_list.remove(a)
if str_list == []:
    print("None")
else:
    print(str_list.pop(0))
import queue
from itertools import product

test_lines = test_input.split("\n")
H, W = map(int, test_lines.pop(0).split())
road_grid = [row for row in test_lines]

# for each start point, find the furthest travellable point
# then return largest path length of all these
# ps y is down, x is right
furthest_so_far = -1
for y_init, x_init in product(range(H), range(W)):
    if road_grid[y_init][x_init] == "#": continue
    boundary = queue.Queue()
    boundary.put((y_init, x_init))
    steps_taken = [[-1]*W for _ in range(H)]
    steps_taken[y_init][x_init] = 0
    while not boundary.empty():
        y, x = boundary.get()
        neighbours = [(y+1, x), (y, x+1), (y-1, x), (y, x-1)]
        for (new_y, new_x) in neighbours:
            if (0 <= new_y < H and 0 <= new_x < W
                and steps_taken[new_y][new_x] == -1 and road_grid[new_y][new_x] == "."):
                steps_taken[new_y][new_x] = steps_taken[y][x] + 1
                boundary.put((new_y, new_x))
    furthest_so_far = max(furthest_so_far, max(max(steps_taken)))
print(furthest_so_far)


### FIXED CODE ###

from itertools import product
import queue
 
H, W = map(int, input().split())
road_grid = list()
for _ in range(H):
  road_grid.append(input())

# for each start point, find the furthest travellable point
# then return largest path length of all these
# ps y is down, x is right
furthest_so_far = -1
for y_init, x_init in product(range(H), range(W)):
    if road_grid[y_init][x_init] == "#": continue
    boundary = queue.Queue()
    boundary.put((y_init, x_init))
    steps_taken = [[-1]*W for _ in range(H)]
    steps_taken[y_init][x_init] = 0
    while not boundary.empty():
        y, x = boundary.get()
        neighbours = [(y+1, x), (y, x+1), (y-1, x), (y, x-1)]
        for (new_y, new_x) in neighbours:
            if (0 <= new_y < H and 0 <= new_x < W
                and steps_taken[new_y][new_x] == -1 and road_grid[new_y][new_x] == "."):
                steps_taken[new_y][new_x] = steps_taken[y][x] + 1
                boundary.put((new_y, new_x))
    furthest_here = max(max(row) for row in steps_taken)
    furthest_so_far = max(furthest_so_far, furthest_here)
print(furthest_so_far)
import math
n,k = map(int,input().split())

def ncr(n,r):
    f = math.factorial
    return (f(n) // f(r) // f(n-r))


for i in range(1,k+1):
    print(ncr(n-k+1, i) * ncr(k-1,i-1) % (10**9+7))

### FIXED CODE ###

import math
n,k = map(int,input().split())

def ncr(n,r):
    f = math.factorial
    return (f(n) // f(r) // f(n-r))


for i in range(1,k+1):
    if n-k+1 < i:
        print(0)
    else:
        print(ncr(n-k+1, i) * ncr(k-1,i-1) % (10**9+7))
N = int(input())

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

color = [0] * 9

a = 400 
flag = 1
    
for i in range(0,N):
    if 8*a <= rate[i]:
        color[8] += 1
    else:
        flag = 0
        if rate[i] < a:
            color[0] = 1
        elif a <= rate[i] < 2*a:
            color[1] = 1
        elif 2*a <= rate[i] < 3*a:
            color[2] = 1
        elif 3*a <= rate[i] < 4*a:
            color[3] = 1
        elif 4*a <= rate[i] < 5*a:
            color[4] = 1
        elif 5*a <= rate[i] < 6*a:
            color[5] = 1
        elif 6*a <= rate[i] < 7*a:
            color[6] = 1
        elif 7*a <= rate[i] < 8*a:
            color[7] = 1

min_color = 0
max_color = 0


min_color = color.count(1)
max_color = min_color + color[8]
if max_color >= 8:
    max_color = 8

print(min_color,max_color)

### FIXED CODE ###

r,g,b = map(int, input().split())

if (g*10 + b) % 4 == 0:
    print("YES")
else:
    print("NO")
ini=input().split()
ini=[int(i) for i in ini]
N=ini[0]
K=ini[1]
a=input().split()
a=[int(i) for i in a]


count=0
ans=0
x=0
lena=len(a)

for i in range(lena):
    for j in range(N-i):
        #print(i,j,a[i+j])
        x += a[i+j]
#        print(i,j,x,count)
        if x >= K:
#            print("aaa",i,j,x,count,ans)
            count = N-j-i
            x=0
            break
        if j==N-i-1:
            x=0
#    print(i,j,ans)
    ans+=count
    count=0
print(ans)

### FIXED CODE ###

alfa=input()

X=alfa[0]
A=alfa[2]

if X<A:
    print("0")
else:
    print("10")
D,G = list(map(int,input().split()))
P = []
C = []

for i in range(D):
    p,c = list(map(int,input().split()))
    P.append(p)
    C.append(c)

for c in range(2**D):
    score = 0
    solved = 0
    remain = []
    for i,b in enumerate(format(c,'b').zfill(D)):
        if b == '1':
            score += P[i]*100*(i+1) + C[i]
            solved += P[i]
        else:
            remain.append(i)
    if score < G:
        R = G - score
        j = remain[-1]
        if (P[j]-1)*(j+1)*100 < R:
            continue
        solved += (R//(100*(j+1)))
    ans = min(solved, ans)

print(ans)

### FIXED CODE ###

D,G = list(map(int,input().split()))
P = []
C = []

for i in range(D):
    p,c = list(map(int,input().split()))
    P.append(p)
    C.append(c)

ans = 10000

for c in range(2**D):
    score = 0
    solved = 0
    remain = []
    for i,b in enumerate(format(c,'b').zfill(D)):
        if b == '1':
            score += P[i]*100*(i+1) + C[i]
            solved += P[i]
        else:
            remain.append(i)
    if score < G:
        R = G - score
        j = remain[-1]
        if (P[j]-1)*(j+1)*100 < R:
            continue
        solved += -(-R//(100*(j+1)))
    ans = min(solved, ans)

print(ans)
A, B, C = map(int, input().split())
msg = 'YES' if A == B and B == C else 'NO'
print(mssg)

### FIXED CODE ###

A, B, C = map(int, input().split())
msg = 'Yes' if A == B and B == C else 'No'
print(msg)
a,b=map(int, input().split())

cnt=0
for i in range(a,b):
    if str(i) == str(i)[::-1]:
        cnt+=1

print(cnt)


### FIXED CODE ###

import math
n = int(input())
d, x = map(int, input().split())
ans = 0
for _ in range(n):
    a = int(input())
    ans += math.ceil(d/a)

print(ans + x)
a, b = map(int, input().split())
sum = a + b
if sum >= 10:
  print('error')
else:
  print(ans)

### FIXED CODE ###

a, b = map(int, input().split())
temp_ans = a + b
if temp_ans >= 10:
  print('error')
else:
  print(temp_ans)
l=[int(x) for x in input().rstrip().split()]
l.sort(reverse = True)

ans=0

del l[0:a]
ans = a
print(sum(l))

### FIXED CODE ###

h,a = [int(x) for x in input().rstrip().split()]
l=[int(x) for x in input().rstrip().split()]
l.sort(reverse = True)

ans=0

del l[0:a]
ans = a
print(sum(l))
import sys

def dfs(n:int, heights: int, a_index:int):
    if n < heights:
        return

    if a_index <= len(a) -1 and a[a_index] == heights:
        memo[heights] = 0
        a_index += 1
        #print("10",heights)
    else:
        memo[heights] = memo[heights-1] + memo[heights -2]
        #print("13",heights)
    dfs(n,heights+1,a_index)
    return
    

n,m = list(map(int, input().split()))
memo = [1]*(n+1)
a = []
a_index = 0
for i in range(m):
    tmp = int(input())
    if i >= 1 and tmp -1 == a[len(a)-1]:
        print(0)
        sys.exit()
    else:
        a.append(tmp)
        #print(i,a)

if a[0] == 1:
    memo[1] = 0
    a_index += 1

dfs(n,2,a_index)
#print(memo)
print(memo[n] % (10**9+7))


### FIXED CODE ###

import sys
sys.setrecursionlimit(10**6)

def dfs(heights: int, a_index:int, a_n_1, a_n_2):
    if n < heights:
        return
    
    if m != 0 and a_index <= len(a) -1 and a[a_index] == heights:
        memo[2] = 0
        a_index += 1
        #print("10",heights)
    else:
        memo[2] = a_n_1 + a_n_2 #memo[1] + memo[0]
        #print("13",heights)
    dfs(heights+1,a_index,memo[2],a_n_1)
    return
    

n,m = list(map(int, input().split()))
memo = [1]*(3)
a = []
a_index = 0
if m != 0:
    for i in range(m):
        tmp = int(input())
        if i >= 1 and tmp -1 == a[len(a)-1]:
            print(0)
            sys.exit()
        else:
            a.append(tmp)
            #print(i,a)

    if a[0] == 1:
        memo[1] = 0
        a_index += 1
#a = list(set(a))
#a.sort()
dfs(2,a_index,memo[1],memo[0])
#print(memo)
print(memo[2] % (10**9+7))
a=input()
li=[q,w,e,r,t,y,u,i,o,p,a,s,d,f,g,h,j,k,l,z,x,c,v,b,n,m]
if a in li:
  print("a")
else:
  print("A")

### FIXED CODE ###

a=input()
li=["q","w","e","r","t","y","u","i","o","p","a","s","d","f","g","h","j","k","l","z","x","c","v","b","n","m"]
if a in li:
  print("a")
else:
  print("A")
N = int(input())
if N % 2 == 0:
    print(N)
else:
    print(2 * N)


### FIXED CODE ###

N = int(input())
if N % 2 == 0:
    print(N)
else:
    print(2 * N)
N=int(input())
if 1<=N<=9:
  print(N)
elif 1<=N<=99:
  print(9)
elif 100<=N<=999:
  print(9+N-100+1)
elif 1000<=N<=9999:
  print(909)
elif 10000<=N<=99999:
  print(909+N-10000+1)
elif N=100000:
  print(90909)

### FIXED CODE ###

N=int(input())
if 1<=N<=9:
  print(N)
elif 1<=N<=99:
  print(9)
elif 100<=N<=999:
  print(9+N-100+1)
elif 1000<=N<=9999:
  print(909)
elif 10000<=N<=99999:
  print(909+N-10000+1)
elif N==100000:
  print(90909)
N = int(input())
P = [int(x) for x in input().split()]
count = 0
check = 0
for i in range(N):
    check = 0
    for j in range(i):
        if P[i] > P[j]:
            check = 1
            break
    if check == 0:
    count += 1

print(count)


### FIXED CODE ###

N = int(input())
P = [int(x) for x in input().split()]
count = 0
check = 0
min = 10**9
for i in P:
    check = 0
    if min > i:
        min = i
    if i <= min:
        count += 1

print(count)
import sys
from collections import deque
par = []
rank = []
def init(n):
    for i in range(n):
        par.append(i)
        rank.append(sys.maxsize)
    rank[0] = 0
 
def root(x):
    if par[x] == x:
        return x
    else:
        return root(par[x])
        
 
def same(x,y):
    if root(x) == root(y):
        return True
    else:
        return False
 
def unite(x,y):
    #print(par[x],par[y],rank[root(x)],rank[root(y)])
    if par[x]==par[y]:
        return
    if rank[x] != sys.maxsize and rank[x] == rank[y]:
        pass
    elif(rank[x] < rank[y]):
        par[y] = x
        rank[y] = rank[x] + 1
    else:
        par[x] = y
        rank[x] = rank[y] + 1
        #if rank[x]==rank[y]:
         #   rank[x] += 1
    #print(par,rank)
 
n,m = map(int,input().split())

turo = [[] for i in range(n)]
q = deque()
his = []

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

init(n)
q.append(0)
his.append(0)

while len(q) > 0:
    #print(q)
    room = q.popleft()
    #print(room+1)
    for room2 in turo[room]:
        if room2 not in his:
            his.append(room2)
            q.append(room2)
            unite(room,room2)

print(turo,par)
for i in range(1,n):
    if (root(i) != 0):
        print("No")
        exit()
 
print("Yes")
for i in range(1,n):
    print(par[i]+1)

### FIXED CODE ###

from collections import deque
import sys
n,m = map(int,input().split())
 
turo = [[] for i in range(n)]
q = deque()
his = [False]*n
for i in range(m):
    a,b = map(int,input().split())
    turo[a-1].append(b-1)
    turo[b-1].append(a-1)
 
par = [i for i in range(n)]
rank = [sys.maxsize for i in range(n)]
rank[0] = 0
q.append(0)
 
while len(q) > 0:
    #print(q)
    room = q.popleft()
    
    if not his[room] :
        his[room] = True
    else:
        continue
    for room2 in turo[room]:
        if rank[room] < rank[room2]:
            q.append(room2)
            par[room2] = room
            rank[room2] = rank[room]+1
 
if len(his) < n:
    print("No")
    exit()
 
print("Yes")
for i in range(1,n):
    print(par[i]+1)