Harryxun/stf_run huggingface dataset:
a = map(str,input())

i = 0
while i <= len(a):
    c = a[i]
    if c == 7:
        print('yes')
        break
    
    i += 1
    if i==b:
        print('no')
        

### FIXED CODE ###

a = input()
if '7' in a:
   print('Yes')
else:
   print('No')
import sys
import heapq

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

if len(A) == 1:
    A[0] //= (2 ** M)
    print(sum(A))
    sys.exit()

h = [(1/a, a) for a in A]
heapq.heapify(h)

for m in range(M):
    x = heapq.heappop(h)
    _, a = x

    a //= 2

    heapq.heappush(h, (1/a, a))

print(sum([a for _, a in h]))


### FIXED CODE ###

import sys
import heapq

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

if len(A) == 1:
    A[0] //= (2 ** M)
    print(sum(A))
    sys.exit()

h = [(1/a, a) for a in A]
heapq.heapify(h)

for m in range(M):
    x = heapq.heappop(h)
    _, a = x

    a //= 2

    heapq.heappush(h, (1/a if a > 0 else float('inf'), a))

print(sum([a for _, a in h]))
import sys

N = input()

N = N.splitlines()

N_num = int(N[0])

if N_num < 1 or N_num > 1*10**5:
    #print('error')
    sys.exit()

AC_num = 0
WA_num = 0
TLE_num = 0
RE_num = 0

for i in range(N_num):
    #print(i+1)
    
    if 'AC' == N[i+1]:
        AC_num += 1
        #print(AC_num)
    
    elif 'WA' == N[i+1]:
        WA_num += 1
        #print(WA_num)

    elif 'TLE' == N[i+1]:
        TLE_num += 1
        #print(TLE_num)
    
    elif 'RE' == N[i+1]:
        RE_num += 1
        #print(RE_num)


print('AC x',AC_num)
print('WA x',WA_num)
print('TLE x',TLE_num)
print('RE x',RE_num)

### FIXED CODE ###

N_num = int(input())

N = []

for i in range(N_num):
    N.append(input())
    

AC_num = 0
WA_num = 0
TLE_num = 0
RE_num = 0

for i in range(N_num):
    #print(i+1)
    
    if 'AC' == N[i]:
        AC_num += 1
        #print(AC_num)
    
    elif 'WA' == N[i]:
        WA_num += 1
        #print(WA_num)

    elif 'TLE' == N[i]:
        TLE_num += 1
        #print(TLE_num)
    
    elif 'RE' == N[i]:
        RE_num += 1
        #print(RE_num)


print('AC x {}'.format(AC_num))
print('WA x {}'.format(WA_num))
print('TLE x {}'.format(TLE_num))
print('RE x {}'.format(RE_num))
def main():
    n, k = map(int, input().split())
    P = [int(x) for x in input().split()]
    p_e = list()
    exp = 0
    for p in P:
        # 期待値
        # 累積和
        exp += (1+p)/2
        p_e.append(exp)
    maxv = p_e[k] - p_e[0]
    for i in range(1, n-k):
        # 隣接するk個の期待値の和
        p_sum = p_e[k+i] - p_e[i]
        maxv = max(maxv, p_sum)
    print(maxv)

if __name__ == '__main__':
    main()
    

### FIXED CODE ###

def main():
    n, k = map(int, input().split())
    P = [int(x) for x in input().split()]
    p_e = list()
    exp = 0
    for p in P:
        # 期待値
        # 累積和
        exp += (1+p)/2
        p_e.append(exp)  
    if n == k:
        print(p_e[-1])
    else:
        # 初期値
        maxv = p_e[k-1] - p_e[0]
        for i in range(1, n-k):
            # 隣接するk個の期待値の和
            p_sum = p_e[k+i] - p_e[i]
            maxv = max(maxv, p_sum)
        print(maxv)

if __name__ == '__main__':
    main()
s, w = input(,)
if s >= w:
	print('safe')
else:
	print('unsafe')

### FIXED CODE ###

s, w = input('').split()
s= int(s)
w=int(w)
if s > w:
	print('safe')
else:
	print('unsafe')
import itertools

n, k = map(int, input().split())
array = {x for x in input().split()}
num_array = {str(x) for x in range(10)}
like_num = array^num_array

res = float("inf")
for i in range(1, 100000):
    tmp = set(list(str(i)))
    if tmp.issubset(like_num):
        if n <= i < res:
            res = i
print(res)

### FIXED CODE ###

a,b,c = map(int, input().split())
sum = [a, b, c]
if sum.count(5) == 2 and sum.count(7) == 1:
    print("YES")
else:
    print("NO")
def main():
    n = int(input())
    a = [int(i) for i in input().split()]
    
    max_num = max(a)
    dif = 99999
    for num in a:
        if(num != max_num and dif > abs((max_num/2) - num)):
            dif = abs((max_num/2) - num)
            ansnum = num
            
    print("{} {}".format(max_num, ansnum))
        
if __name__=="__main__":
    main()

### FIXED CODE ###

def main():
    n = int(input())
    a = [int(i) for i in input().split()]
    
    max_num = max(a)
    dif = 10**10
    ansnum = 0
    for num in a:
        if(num != max_num and dif > abs((max_num/2) - num)):
            dif = abs((max_num/2) - num)
            ansnum = num
            
    print("{} {}".format(max_num, ansnum))
        
if __name__=="__main__":
    main()
a,b = list(map(int, input().split()))

if a > b:
    ans = ''
    for target_list in range(a):
        ans = ans + str(b)

    print(ans)

if b > a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
    

if b == a:
ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)


### FIXED CODE ###

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

if a > b:
    ans = ''
    for target_list in range(a):
        ans = ans + str(b)

    print(ans)

if b > a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
    

if b == a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
a, b=input().split()
 
print(min(a＊(int(b)),b＊(int(a) ) )


### FIXED CODE ###

a, b = input().split()
 
print(min(a*int(b), b*int(a) ) )
N = int(raw_input())
num_list = map(int, raw_input().split())

c = 0
flag = 1
while flag==1:
    flag =0
    for j in range(N-1,0,-1):
        if num_list[j] < num_list[j-1]:
            a = num_list[j]
            num_list[j] = numlist[j-1]
            num_list[j-1] = a
            c += 1
            flag =1

print " ".join(map(str,num_list))
print c

### FIXED CODE ###

N = int(raw_input())
num_list = map(int, raw_input().split())

c = 0
flag = 1
while flag==1:
    flag =0
    for j in range(N-1,0,-1):
        if num_list[j] < num_list[j-1]:
            a = num_list[j]
            num_list[j] = num_list[j-1]
            num_list[j-1] = a
            c += 1
            flag =1

print " ".join(map(str,num_list))
print c
S = input()
power = 0
answer = 0
temps = int(S)
while True:
    temps = temps/10
    power += 1
    if temps < 10:
        break

SS = list(S)

for i in range(1 << power):
    output = []
    for j in range(power):
        if (i>>j)&1 == 1:
            output.append(SS[j])
            output.append('+')
        else:
            output.append(SS[j])
    output.append(SS[power])
    temp_string = ''.join(output)
    answer += eval(temp_string)
    
print(answer)

### FIXED CODE ###

S = input()
power = 0
answer = 0
temps = int(S)
while True:
    if temps < 10:
        break
    temps = temps/10
    power += 1

SS = list(S)

for i in range(1 << power):
    output = []
    for j in range(power):
        if (i>>j)&1 == 1:
            output.append(SS[j])
            output.append('+')
        else:
            output.append(SS[j])
    output.append(SS[power])
    temp_string = ''.join(output)
    answer += eval(temp_string)
    
print(answer)
X = int(input())

_range = int(pow(X,1/5))
for i in range(-1*_range-1,_range+2):
  for j in range(-1*_range-1,_range+2):
    if pow(i,5) - pow(j,5) == X:
      ans_a = i
      ans_b = j
      break
      
print(ans_a,ans_b)

### FIXED CODE ###

X = int(input())

_range = int(pow(X,1/5))
for i in range(-2*_range-1,2*_range+2):
  for j in range(-2*_range-1,2*_range+2):
    if pow(i,5) - pow(j,5) == X:
      ans_a = i
      ans_b = j
      break
      
print(ans_a,ans_b)
N,M = map(int, input().split())
p = [0]*M
S = [0]*M
for i in range(M):
    p[i],S[i] = input().split()
import numpy as np
p = [int(s) for s in p]
p1 = np.array(p)
S1 = [1 if i=="AC" else 0 for i in S]
N1 = list(set(p1 * S1))

A = 0
B = 0
for i in range(M):
    if p1[i] in N1:
        A += S1[i]
        B += (1-S1[i])
        if S1[i] ==1:
            N1.remove(p1[i])
print(str(A)+" "+str(B))

### FIXED CODE ###

N,M = map(int, input().split())
p = [0]*M
S = [0]*M
for i in range(M):
    p[i],S[i] = input().split()
q = [int(s)-1 for s in p]
X = [0]*N
Y = [0]*N
A = 0
B = 0
for i in range(M):
    if S[i] == "AC":
        if Y[q[i]]==0:
            Y[q[i]]+=1
            A += 1
            B += X[q[i]]
    else:
        if Y[q[i]]==0:
            X[q[i]] += 1
print(str(A)+" "+str(B))
from math import ceil

def main():
    N=int(input())
    A=[int(_) for _ in input().split()]

    def dp(i,k):
        print(i,k)
        if k<=0:
            return 0
        tmp=N-i
        if k>ceil(tmp/2):
            return -float('inf')
        return max(A[i]+dp(i+2,k-1),dp(i+1,k))

    print(dp(0,N//2))

main()

### FIXED CODE ###

def main():
    N=int(input())
    A=[int(_) for _ in input().split()]
    dp=[[0,0,0] for _ in range(N//2+1)]
    for i in range(N//2):
        dp[i+1][0]=dp[i][0]+A[i*2]
        dp[i+1][1]=max(dp[i][1],dp[i][0])+A[i*2+1]
        if N%2:
            dp[i+1][2]=max(dp[i][2],dp[i][1],dp[i][0])+A[i*2+2]
    if N%2:
        print(max(dp[-1]))
    else:
        print(max(dp[-1][:2]))

main()
import math

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


def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))


for i in range(1, k + 1):
    tmp1 = combinations_count(k - 1, k - (k - i + 1)) % 1000000007
    tmp2 = combinations_count(n - k + 1, i) % 1000000007
    print((tmp1 * tmp2) % 1000000007)


### FIXED CODE ###

import math

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


def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))


for i in range(1, k + 1):
    if n - k + 1 >= i:
        tmp1 = combinations_count(k - 1, i - 1) % 1000000007
        tmp2 = combinations_count(n - k + 1, i) % 1000000007
        ans = (tmp1 * tmp2) % 1000000007
        print(ans)
    else:
        print(0)
import math
N,Y=map(int,input().split())
YY=min(N,math.floor(Y/10000))
flag=False
for i in reversed(range(YY+1)):
    Y2=Y-i*10000
    N2=N-i
    YYY=min(N2,math.floor(YY2/5000))
    for j in reversed(range(YYY+1)):
        YY3=int((Y2-j*5000)/1000)
        if YY3==N2-j:
            print(i, j, YY3)
            flag=True
            break
        else:
            continue
if flag==False:
    print("-1 -1 -1")
else:
    exit

### FIXED CODE ###

N,Y=map(int,input().split())
flag=False
for i in range(N+1):
    if flag==True:
        break
    else:
        pass
    for j in range(N+1-i):
        k=N-i-j
        if 10000*i+5000*j+1000*k==Y:
            print(i, j, k)
            flag=True
            break
        else:
            continue
if flag==False:
    print("-1 -1 -1")
else:
    pass
from math import gcd

def seachPrimeNum(N):
  max = int(N**0.5)
  seachList = [i for i in range(2,N+1)]
  primeNum = list(range(N+1))
  while seachList[0] <= max:
    tmp = seachList[0]
    tmp2 = list(seachList)
    for i in tmp2:
      if i%tmp == 0:
          primeNum[i]=tmp
          seachList.remove(i)
  return primeNum

def prime_factorize(n, f):
    a = []
    while n % f == 0:
        a.append(f)
        n //= f
    
    if f == 2:
      f=3
    else:
      f+=2
      
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a
  
n = int(input())
a = list(map(int, input().split()))
d = seachPrimeNum(max(a))
dic = {}
g = a[0]
flg = True
for i in range(n):
  g = gcd(g, a[i])
  if flg:
    tmp = prime_factorize(a[i], d[a[i]])
    for j in set(tmp):
      if j in dic:
        flg = False
      else:
        dic[j]=1
        
if flg:
  print("pairwise coprime")
elif g == 1:
  print("setwise coprime")
else:
  print("not coprime")
  

### FIXED CODE ###

from math import gcd
def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return set(a)
  
n = int(input())
a = list(map(int, input().split()))
dic = {}
g = a[0]
flg = True
for i in range(n):
  g = gcd(g, a[i])
  if flg:
    tmp = prime_factorize(a[i])
    for j in tmp:
      if j in dic:
        flg = False
      else:
        dic[j]=1
        
if flg:
  print("pairwise coprime")
elif g == 1:
  print("setwise coprime")
else:
  print("not coprime")
#関数を持ってくる
from collections import deque

#入力(座標をリストで扱いやすいように-1する)
r,c = map(int,input().split())
c_list = [list(input()) for nesya in range(r)]
for hoge in c_list:
  hoge.insert(0,'#')
  hoge.append('#')
c_list.insert(0,['#']*(c+2))
c_list.append(['#']*(c+2))

ans = 0
for i in range(r+2):
  for j in range(c+2):
    #dequeオブジェクトを作る
    d = deque()
    #その座標を扱ったかを調べるためのリストを作る
    hoge_list = [[-1]*(c+2) for motsu in range(r+2)]
    if  c_list[j][i] == '#':
      continue
    else:
      #スタート位置をdに加え、到達時刻を0にする
      d.append((j,i))
      hoge_list[j][i] = 0

      #当該の座標から動かすためのリストを作る
      move =[[1,0],[-1,0],[0,1],[0,-1]]

      #座標に対して作業する
      while len(d) > 0:
        #今から扱う座標をcoordとする
        coord = d.popleft()
  
        #縦横に移動したときそれぞれのマスに作業する
        for k in range(4):
          #移動した後の座標
          x = coord[1] + move[k][1]
          y = coord[0] + move[k][0]
    
          #作業が終わっている座標であったら無視する
          if hoge_list[y][x] != -1:
            pass
          #マスが壁であった場合-2を代入して終わる
          elif c_list[y][x] == '#':
            hoge_list[y][x] = -2
          #作業するマス
          else:
            #当該座標から1移動したはずである
            hoge_list[y][x] = hoge_list[coord[0]][coord[1]] + 1
            ans = max(hoge_list[y][x],ans)
            #dequeに加える
            d.append((y,x))
    

#ゴールの移動回数を出力する
print(ans)


### FIXED CODE ###

#関数を持ってくる
from collections import deque

#入力(座標をリストで扱いやすいように-1する)
r,c = map(int,input().split())
c_list = [list(input()) for nesya in range(r)]
for hoge in c_list:
  hoge.insert(0,'#')
  hoge.append('#')
c_list.insert(0,['#']*(c+2))
c_list.append(['#']*(c+2))

ans = 0
for j in range(r+2):
  for i in range(c+2):
    #dequeオブジェクトを作る
    d = deque()
    #その座標を扱ったかを調べるためのリストを作る
    hoge_list = [[-1]*(c+2) for motsu in range(r+2)]
    if  c_list[j][i] == '#':
      continue
    else:
      #スタート位置をdに加え、到達時刻を0にする
      d.append((j,i))
      hoge_list[j][i] = 0

      #当該の座標から動かすためのリストを作る
      move =[[1,0],[-1,0],[0,1],[0,-1]]

      #座標に対して作業する
      while len(d) > 0:
        #今から扱う座標をcoordとする
        coord = d.popleft()
  
        #縦横に移動したときそれぞれのマスに作業する
        for k in range(4):
          #移動した後の座標
          x = coord[1] + move[k][1]
          y = coord[0] + move[k][0]
    
          #作業が終わっている座標であったら無視する
          if hoge_list[y][x] != -1:
            pass
          #マスが壁であった場合-2を代入して終わる
          elif c_list[y][x] == '#':
            hoge_list[y][x] = -2
          #作業するマス
          else:
            #当該座標から1移動したはずである
            hoge_list[y][x] = hoge_list[coord[0]][coord[1]] + 1
            ans = max(hoge_list[y][x],ans)
            #dequeに加える
            d.append((y,x))
    

#ゴールの移動回数を出力する
print(ans)
# 2019/09/28
from fractions import gcd

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


# 約数列挙

def divisors(n):
    div=[]
    for i in range(1,int(n**0.5)+1):
        if n%i==0:
            div.append(i)
            if i!=n//i:
                div.append(n//i)
    # div.sort()
    return div

diva=divisors(a)
divb=divisors(b)
div=set()
for aa,bb in zip(diva,divb):
    if aa in divb:
        div.add(aa)
    if bb in diva:
        div.add(bb)

# エラトステネスの篩
def sieve(n):
    end=int(pow(n,0.5))+1
    is_prime=[True]*(n+1) 
    is_prime[0]=False
    is_prime[1]=False

    for i in range(2,end):
        if not is_prime[i]:continue
        for j in range(i*2,n+1,i):
        #for j in range(i*(i|0),n+1,i):
            is_prime[j]=False
    return [i for i in range(n+1) if is_prime[i]]

prime=sieve(max(div))

cnt=1
res=[]
for e in div:
    if e in prime:
        res.append(e)


cnt+=len(res)
for i in div:
    if i==1:continue
    for j in res:
        if j==1:continue
        if i==j:continue
        if i in res and j in res:continue
        if gcd(i,j)==1:continue
        else:break
        cnt+=1
print(cnt)

### FIXED CODE ###

# 2019/09/30

from fractions import gcd

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

g=gcd(a,b)


def trial_div(n):
    from collections import Counter
    
    prime=Counter()

    for i in range(2,int(pow(n,0.5)+2)):
        while n%i==0:
            n//=i
            prime[i]+=1
    if n>1:prime[n]+=1
    
    return prime


res=trial_div(g)
print(1+len(res))
ls=list(input())
ans=0
ans_ls=[]
for i in range(len(ls)):
    if ls[i ]=='A' or ls[i] == 'C' or ls[i] == 'G' or ls[i] == 'T':
        ans=ans+1
    else:
        ans1=ans
        ans_ls.append(ans1)
        ans=0

print(max(ans_ls))

### FIXED CODE ###

import copy
ls=list(input())
ans=0
#ans1=0
ans_ls=[]
#print(ls)
for i in range(len(ls)):
    if ls[i]=='A' or ls[i] == 'C' or ls[i] == 'G' or ls[i] == 'T':
        ans=ans+1
        #print(ans)
    else:
        #print(ans)
        ans1=ans
        #print(ans1)
        ans_ls.append(ans1)
        ans=0
ans_ls.append(ans)
#print(ans_ls)
print(max(ans_ls))
n,x=map(int,input().split())
a=list(map(int,input().split()))
dp=[0]*n
for i in range(1,n):
    min1=10**9
    if 0<i-x:
        for j in range(i-x,i):
            if min1>dp[x-j]+abs(a[j]-a[x-j]):
                min1=dp[x-j]+abs(a[j]-a[x-j])
    else:
        for j in range(0,i):
            if min1>dp[x-j]+abs(a[j]-a[x-j]):
                min1=dp[x-j]+abs(a[j]-a[x-j])
    dp[i]=min1
print(dp[-1])



### FIXED CODE ###

n,x=map(int,input().split())
a=list(map(int,input().split()))
dp=[-1]*n
dp[0]=0
if n<=x:
    x=n-1
for i in range(1,x+1):
    dp[i]=abs(a[i]-a[0])

for i in range(x+1,n):
    min1=10**9
    for j in range(i-(x),i):  
        if min1>dp[j]+abs(a[j]-a[i]):               
            min1=dp[j]+abs(a[j]-a[i])
    dp[i]=min1
print(dp[-1])
from sys import stdin
 
X = stdin.readline().strip().split(" ")
 
n = 0
for i in range(len(X)):
  if X[i] == "0":
    n = i+1
    break
print n

### FIXED CODE ###

from sys import stdin
 
X = stdin.readline().strip().split(" ")
 
n = 0
for i in range(len(X)):
  if X[i] == "0":
    n = i+1
    break
print(n)
# coding: utf-8
 
n, m, x, y = map(int, input().split())
xn = list(map(int, input().split()))
ym = list(map(int, input().split()))
flg = 0

if x < y:
    for i in range(x, y+1):
        if max(xn) < i and min(ym)>=i:
            print("No War")
            flg = 1
        elif flg = 0 and i == y:
            print("War")
else:
    print("No War")

### FIXED CODE ###

# coding: utf-8
 
n, m, x, y = map(int, input().split())
xn = list(map(int, input().split()))
ym = list(map(int, input().split()))
xn.append(x)
ym.append(y)
flag = 0

if max(xn) < min(ym):
    print("No War")
else:
    print("War")
t=input();p=input()
for i in range(len(t)):
    if t[i:].startwith(p):print(i)

### FIXED CODE ###

t=input();p=input()
[print(i)for i in range(len(t))if t[i:].startswith(p)]
#!/usr/bin/env python3
    from collections import defaultdict,deque
    from heapq import heappush, heappop
    from bisect import bisect_left, bisect_right
    import sys, random, itertools, math
    sys.setrecursionlimit(10**5)
    input = sys.stdin.readline
    sqrt = math.sqrt
    def LI(): return list(map(int, input().split()))
    def LF(): return list(map(float, input().split()))
    def LI_(): return list(map(lambda x: int(x)-1, input().split()))
    def II(): return int(input())
    def IF(): return float(input())
    def S(): return input().rstrip()
    def LS(): return S().split()
    def IR(n): return [II() for _ in range(n)]
    def LIR(n): return [LI() for _ in range(n)]
    def FR(n): return [IF() for _ in range(n)]
    def LFR(n): return [LI() for _ in range(n)]
    def LIR_(n): return [LI_() for _ in range(n)]
    def SR(n): return [S() for _ in range(n)]
    def LSR(n): return [LS() for _ in range(n)]
    mod = 1000000007
    inf = float('INF')

    #solve
    def solve():
        t = S()
        for i in t:
            if i == "?":
                print("D", end="")
            else:
                print(i, end="")
        print()
        return


    #main
    if __name__ == '__main__':
        solve()


### FIXED CODE ###

#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')

#solve
def solve():
    t = S()
    for i in t:
        if i == "?":
            print("D", end="")
        else:
            print(i, end="")
    print()
    return


#main
if __name__ == '__main__':
    solve()
K, N = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]

b = A[0]+(K-A[N-1])

a = [A[i]-A[i-1] for i in range(1,N)]

c = max(a,b)

print(K-c)


### FIXED CODE ###

k,n = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
c = a[0] + (k - a[n-1])
for i in range(1,n):
  c = max(c,a[i] - a[i-1])
print(k-c)
N ,M = map(int,input().split( ))
P = []
Y = []

l = []
for i in range(N):
	l.append([])

for i in range(M):
	p, y = map(int,input().split( ))
	P.append(p)
	Y.append(y)
	l[P[i]-1].append(Y[i])

for i in range(N):
	l[i].sort()


for i in range(M):
	Y[i] = l[P[i]-1].index(Y[i]) + 1
	while len(str(P[i])) < 6 :
		P[i] = '0' + str(P[i])
	while len(str(Y[i])) < 6 :
		Y[i] = '0' + str(Y[i])
	print(P[i] + Y[i])


### FIXED CODE ###

N ,M = map(int,input().split( ))
l = []
for i in range(M):
	p, y = map(int,input().split( ))
	l.append((y, p, i))
l.sort()


p_count  = [0 for i in range(N)]

l_2 = []
for i in range(M):
	p_count[l[i][1]-1] += 1
	l_2.append((l[i][2], l[i][1], p_count[l[i][1]-1]))
l_2.sort()
for i in range(M):
	print(str(l_2[i][1]).zfill(6)+str(l_2[i][2]).zfill(6))
import sys
input = sys.stdin.readline

n, q = [int(x) for x in input().split()]

edge = [[] for _ in range(n)]

counter = [0] * n

for _ in range(n-1):
    a, b = [int(x) for x in input().split()]
    edge[a-1].append(b-1)
    edge[b-1].append(a-1)

for _ in range(q):
    a, b = [int(x) for x in input().split()]
    counter[a-1] += b

parent = [0]

for i in parent:
    for v in edge[i]:
        if v in parent:
            continue
        parent.append(v)
        counter[v] += counter[i]
        
print(" ".join(map(str, counter)))

### FIXED CODE ###

a = int(input())
s = input()

if a >= 3200:
    print(s)
else:
    print("red")