Harryxun/stf_run huggingface dataset:
N, K, M = map(int, input().split())
tests = map(int, input().split())

total = sum(tests)

for i in range(K):
    if (total + i) / N >= M:
        print(i)
        exit(0)
print(-1)


### FIXED CODE ###

C = input()
letters = "abcdefghijklmnopqrstuvwxyz"
list_letters = list(letters)
print(list_letters[letters.find(C)+1])
n, m = [int(i) for i in input().split()]
b = [0] * n
b[0], b[1] = 1, 2
c = [0]*n
a = [int(input()) for _ in range(m)]
for i in a:
    c[i - 1] = 1
    b[i - 1] = 0
for i in range(2, n):
    if c[i] == 0:
        b[i] = b[i - 1] + b[i - 2]
print(b[-1])


### FIXED CODE ###

n, m = [int(i) for i in input().split()]
b = [0] * (n+1)
b[0],b[1]=1,1
c = [0]*(n+1)
a = [int(input()) for _ in range(m)]
for i in a:
    c[i] = 1
    b[i]=0
for i in range(2, n+1):
    if c[i] == 0:
        b[i] = b[i - 1] + b[i - 2]
print(b[-1]%(10**9+7))
n,m = map(int,input().split())
a = list[map(int,input().split()) for i in range(n)]
ans = {i+1 for i in range(m)}
for b in a:
    ans = ans & set(a[1:])
print(len(ans))

### FIXED CODE ###

n,m = map(int,input().split())
A = [list(map(int,input().split()))for i in range(n)]
ans = {i+1 for i in range(m)}
for a in A:
    ans = ans & set(a[1:])
print(len(ans))
N,K= map(int,input().split())
D = [int(j) for j in input().split()]
D2 = list(set([i for i in range(0,10)])-set(D))
D1 = list(set([i for i in range(1,10)])-set(D))
ans =''
for i in reversed(range(-len(str(N)),0)):
    if int(str(N)[i]) not in D:
        ans+=str(N)[i]
    elif i==-len(str(N)):
        ans+=str(min(D1))
    else:
        ans+=str(min([d for d in D2 if d>int(str(N)[i])]))
print(int(ans[::-1]))

### FIXED CODE ###

N,K= map(int,input().split())
D = [int(j) for j in input().split()]
D2 = list(set([i for i in range(0,10)])-set(D))
def f(N,D):
    if len(set([int(i) for i in list((str(N)))])&set(D))==0:
        return True
    else:
        return False
if len(D2) ==0:
    print(N)
else:
    while not f(N,D):
        N+=1
print(N)
S = list(input())
T = list(input())
Ns = len(S)
Nt = len(T)
ans = S
flag = True
for i in range(Ns - Nt+1):
    for j in range(Nt):
        if not(S[i+j] == T[i+j] or S[i+j] == '?'):
            break
    else:
        flag = True
        break

if flag:
    for j in range(Nt):
        ans[i+j] = T[j]

    for k in range(Ns):
        if ans[k] == '?':
            ans[k] = 'a'
    ans = ''.join(ans)
else:
    ans = 'UNRESTORABLE'
    
print(ans)


### FIXED CODE ###


S = input()
T = input()
N = len(S)
K = len(T)

ans = []
flag = False
for i in range(N-K+1):
    for j in range(K):
        if not(S[i+j] == T[j] or S[i+j] == '?'):
            break
    else:
        flag = True
        tmp = list(S)
        for j in range(K):
            tmp[i+j] = T[j]
        for j in range(N):
            if tmp[j] == '?': tmp[j] = 'a'
        tmp = ''.join(tmp)
        ans.append(tmp)
        
if flag:
    ans.sort()
    print(ans[0])
else:
    print('UNRESTORABLE')
a = int(input())
s = input()
if a >= 3200:
    print(s)
else:
    print(red)

### FIXED CODE ###

a = int(input())
s = input()
if a >= 3200:
    print(s)
else:
    print("red")
li = []
lis = []
time = 0
for i in range(5):
    li.append(int(input()))
    lis.append(li[i] % 10)
lista = sorted(lis)
a = lista
for i in range(5):
    if lista[i] != 0:
        a = lista[i]
        break
last = lis.index(a)
for i in range(5):
    if i == last:
        continue
    elif lis[i] == 0:
        time += li[i]
    elif 1 <= li[i] <= 9:
        time += 10
    else:
        time += int(li[i] / 10) * 10 + 10
print(time + li[last])

### FIXED CODE ###

import itertools
C = []
for i in range(5):
    C.append(int(input()))

ans = float("inf")
for order in itertools.permutations(C, 5):
    total = 0
    for c in order:
        if total % 10 != 0:
            total = (total // 10 + 1) * 10
        total += c

    ans = min(total, ans)

print(ans)
from bisect import bisect_left,bisect_right
p=10**9+7
n,k=map(int,input().split())
a=sorted(list(map(int,input().split())))
minus=bisect_left(a,0) #負の数の個数
plus=n-bisect_right(a,0) #正の数の個数
neg=a[:minus] #負の数(絶対値大きい順)
pog=a[n-plus::][::-1] #正の数(絶対値大きい順)
zer=n-plus-minus #ゼロの数
ans=1
poi=0
nei=0
flag=0
co=0
sgn=1
if plus==1:
  alartp=1
else:
  alartp=0
if minus==1:
  alartn=1
else:
  alartn=0
if plus==0:
  if zer!=0 and k%2==1:
    print(0)
  else:
    for i in range(k):
      ans=ans*neg[-1-i]%p
    print(ans)
elif plus+minus<k:
  print(0)
elif minus==0:
  for _ in range(k):
    ans=ans*pog[poi]%p
    poi+=1
  print(ans)
else:
  i=0
  while (i<k-2) and (not alartn) and (not alartp):
    i+=1
    if -neg[nei]>pog[poi]:
      ans=ans*neg[nei]%p
      sgn*=-1
      nei+=1
      if nei==minus-1:
        alartn=1
    else:
      ans=ans*pog[poi]%p
      poi+=1
      if poi==plus-1:
        alartp=1
  if alartn:
    if sgn==-1:
      ans=ans*neg[nei]%p
      i+=1
    for _ in range(k-i):
      ans=ans*pog[poi]%p
      poi+=1
  elif alartp==1:
    if (sgn==1 and (k-i)%2==1) or (sgn==-1 and (k-i)%2==0):
      ans=ans*pog[poi]
      i+=1
    for _ in range(k-i):
      ans=ans*neg[nei]
      nei+=1
  else:
    if sgn==1:
      a=max(pog[poi]*pog[poi+1],neg[nei]*neg[nei+1])
      ans=ans*a%p
    else:
      ans=ans*pog[poi]*neg[nei]%p
  print(ans)


### FIXED CODE ###

from bisect import bisect_left,bisect_right
p=10**9+7
n,k=map(int,input().split())
a=sorted(list(map(int,input().split())))
pi=1
ni=0
ans=1
i=0
while i<k-1:
  if a[ni]*a[ni+1]>a[-pi]*a[-pi-1]:
    ans=ans*a[ni]*a[ni+1]%p
    ni+=2
    i+=2
  else:
    ans=ans*a[-pi]%p
    pi+=1
    i+=1
if i==k-1:
  ans=ans*a[-pi]%p
if a[-1]<0 and k%2==1:
  ans=1
  for i in a[n-k:]:
    ans=ans*i%p
print(ans)
import numpy as np

mod=998244353


n,m=map(int,input().split())
A=[list(map(float,input().split())) for i in range(n)]

A.sort(reverse=1)
A=np.array(A)

# if A[0][0]!=0

#print(A)
for i in range(min(n,m)):
    #print(A)
    A=list(A)
    A[i:].sort(reverse=1,key=lambda x:x[i])
    if A[i][i]==0 :
        A[i:].sort(key=lambda x:x[i])
    A=np.array(A)
    if A[i][i]!=0 :
        w=A[i][i]
        for k in range(m):
            
            A[i][k]/=w
        for j in range(i+1,n):
            A[j]-=A[i]*A[j][i]

#print(A)

r=0
j=0
for i in range(m):
    if A[j][i]!=0 :
        r+=1
        j+=1

for i in range(n):
    for i in range(m):
        A[i][j]=int(A[i][j])
#print(A)
#print(r) #rank

a=1
b=1

for i in range(n+m-1):
    a=(a*2)%mod
for i in range(n+m-1-r):
    b=(b*2)%mod
print((a-b)%mod)


### FIXED CODE ###

import numpy as np
import random

mod=998244353


n,m=map(int,input().split())
A=[list(map(int,input().split())) for i in range(n)]

#n,m=300,300
#A=[[int(random.randint(0,1)) for j in range(m)] for i in range(n)]


#A=np.array(A)

#print("A")
i=0
j=0
r=0 #rank
while i<n and j<m :
    #print(i)
    t=0
    if A[i][j]==0 :
        k=i
        while k<n and A[k][j]==0 :
            k+=1
        if k<n :
            A[i],A[k]=A[k],A[i]

            #print(A)
        else :
            t=1
            j+=1
    if t==0 :
        r+=1
        for p in range(i+1,n):
            if A[p][j]>0 :
                for kk in range(j,m):
                    A[p][kk]=(A[p][kk]-A[i][kk])%2
        i+=1
        j+=1



#r=0
#j=0
#for i in range(m):
#    if j<n :
#        if A[j][i]!=0 :
#            r+=1
#            j+=1

for i in range(n):
    for j in range(m):
        A[i][j]=int(A[i][j])
#print(A)
#print(r) #rank

a=1
b=1

for i in range(n+m-1):
    a=(a*2)%mod
for i in range(n+m-1-r):
    b=(b*2)%mod

print((a-b)%mod)
import sys
n = int(input())
ss =[]
for _ in range(n):
    ss.apend(input())
cnt_p = []
cnt_m = []
for i in range(n):
    left = 0
    right = 0
    for s in ss[i]:
        if(s == '('):
            left += 1
        elif(s == ')'):
            if(left > 0):
                left -= 1
            else:
                right += 1
    if(left-right > 0):
        cnt_p.append((right,left))
    else:
        cnt_m.append((right,left))
 
 
cnt_p = sorted(cnt_p, key=lambda x: (x[0]))
cnt_m = sorted(cnt_m, key=lambda x: (x[1]*-1))
cnt = cnt_p + cnt_m
num = 0
for right,left in cnt:
    num -= right
    if(num < 0):
        print('No')
        sys.exit()
    num += left
if(num==0):
    print('Yes')
else:
    print('No')

### FIXED CODE ###

import sys
n = int(input())
ss =[]
for _ in range(n):
    ss.append(input())
cnt_p = []
cnt_m = []
for i in range(n):
    left = 0
    right = 0
    for s in ss[i]:
        if(s == '('):
            left += 1
        elif(s == ')'):
            if(left > 0):
                left -= 1
            else:
                right += 1
    if(left-right > 0):
        cnt_p.append((right,left))
    else:
        cnt_m.append((right,left))
 
 
cnt_p = sorted(cnt_p, key=lambda x: (x[0]))
cnt_m = sorted(cnt_m, key=lambda x: (x[1]*-1))
cnt = cnt_p + cnt_m
num = 0
for right,left in cnt:
    num -= right
    if(num < 0):
        print('No')
        sys.exit()
    num += left
if(num==0):
    print('Yes')
else:
    print('No')
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6) #for deep recursion

N, Q = list(map(int, input().split()))
edges = [list(map(int, input().split())) for _ in range(N-1)]
counts = [0] * N
operations = [list(map(int, input().split())) for _ in range(Q)]

counts = [0] * N
for op in operations:
    p, x = op
    counts[p-1] += x
    
all_connected_vertices = {i: [] for i in range(1, 1+N)}
for a, b in edges:
    all_connected_vertices[a].append(b)
    all_connected_vertices[b].append(a)
    
def dfs(point, pre):
    connected_vertices = all_connected_vertices[point]
    for c in children:
        if c == pre:
            continue
        counts[c-1] += counts[point-1]
        dfs(c, point)
    
dfs(1, -1)
    
print(*counts)

### FIXED CODE ###

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6) #for deep recursion

N, Q = list(map(int, input().split()))
edges = [list(map(int, input().split())) for _ in range(N-1)]
operations = [list(map(int, input().split())) for _ in range(Q)]

counts = [0] * N
for op in operations:
    p, x = op
    counts[p-1] += x
    
all_connected_vertices = {i: [] for i in range(1, 1+N)}
for a, b in edges:
    all_connected_vertices[a].append(b)
    all_connected_vertices[b].append(a)
    
def dfs(point, pre):
    connected_vertices = all_connected_vertices[point]
    for c in connected_vertices:
        if c == pre:
            continue
        counts[c-1] += counts[point-1]
        dfs(c, point)
    
dfs(1, -1)
    
print(*counts)
a=raw_input().split();print((int(a[0])-1)*(int(a[1])-1));

### FIXED CODE ###

a=input().split();print((int(a[0])-1)*(int(a[1])-1));
m= int((input=().count('o'))
print(700+m*100)


### FIXED CODE ###

m=input().count("o")
print(700+m*100)
N, Q = map(int, input().split())
graph = [[] for _ in range(N)]

for _ in range(N-1):
    a, b = map(lambda x: int(x)-1, input().split())
    graph[a].append(b)
    graph[b].append(a) 

X = [0]*N
for _ in range(Q):
    p, x = map(int, input().split())
    X[p-1] += x

ans = [0]*N

def dfs(u, parent):
    ans[u] = ans[parent] + X[u]
    for v in graph[u]:
        if v != parent:
            dfs(v, u)
dfs(0, 0)
print(*ans)


### FIXED CODE ###

from collections import deque
N, Q = map(int, input().split())
graph = [[] for _ in range(N)]

for _ in range(N-1):
    a, b = map(lambda x: int(x)-1, input().split())
    graph[a].append(b)
    graph[b].append(a)

ans = [0]*N
for _ in range(Q):
    p, x = map(int, input().split())
    ans[p-1] += x

que = deque([0])
parent = [-1]*N
while que:
    node = que.pop()
    for v in graph[node]:
        if v == parent[node]:
            continue
        parent[v] = node
        que.append(v)
        ans[v] += ans[node] 

print(*ans)
n, m  = map(int, input().split())

A = [int(input().strip()) for _ in range(m)]

a0 = 1
a1 = 1 if A[0] !=1 else 0
mod = 1000000007

ANS=[0]*(n+1)
ANS[0]=a0
ANS[1]=a1
Next = A if a1 !=0 else A[1:]
next = 0
for i in range(2, n+1):
    if next <= len(Next)-1:
        if i == Next[next]:
            ANS[i] = 0
            next += 1
            continue
    ANS[i] = ANS[i-2] + ANS[i-1]

print(ANS[n]%mod)


### FIXED CODE ###

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

A = [int(input().strip()) for _ in range(m)]

a0 = 1
if len(A) == 0:
  a1 = 1
else:
  a1 = 1 if A[0] !=1 else 0
mod = 1000000007

ANS=[0]*(n+1)
ANS[0]=a0
ANS[1]=a1
Next = A if a1 !=0 else A[1:]
next = 0
for i in range(2, n+1):
    if next <= len(Next)-1:
        if i == Next[next]:
            ANS[i] = 0
            next += 1
            continue
    ANS[i] = ANS[i-2] + ANS[i-1]

print(ANS[n]%mod)
n, k = map(int, input().split())
h = [int(i) for i in input().split()]

inf = 10**5
dp = [inf for i in range(n)]
dp[0] = 0

for i in range(1, n):
    tmp = []
    for j in range(i-k, i):
        tmp.append(dp[j] + abs(h[j] - h[i]))
    dp[i] = min(tmp)
    
print(dp[-1])

### FIXED CODE ###

n, k = map(int, input().split())
h = [int(i) for i in input().split()]

inf = 10**5
dp = [inf for i in range(n)]
dp[0] = 0

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

print(dp[-1])
import math
from functools import reduce


def gcd(*numbers):
    return reduce(math.gcd, numbers)


def gcd_list(numbers):
    return reduce(math.gcd, numbers)


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

if N == 1:
    print(abs(X-xl[0]))
    exit(0)

xl.append(X)
xl.sort()

k = []
for i in range(1, N):
    tmp = xl[i]-xl[i-1]
    if not(tmp in k):
        k.append(tmp)

if len(k) <= 1:
    print(k[0])
else:
    print(gcd_list(k))


### FIXED CODE ###

def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)


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

if N == 1:
    print(abs(X-xl[0]))
    exit(0)

xl.append(X)
xl.sort()

k = []
for i in range(1, N+1):
    tmp = xl[i]-xl[i-1]
    if not(tmp in k):
        k.append(tmp)

if len(k) == 1:
    print(k[0])
elif len(k) == 2:
    ans = gcd(k[0], k[1])
    print(ans)
else:
    ans = gcd(k[0], k[1])
    for i in range(2, len(k)):
        ans = gcd(ans, k[i])
    print(ans)
a, b = map(int, input().split())
if a <= 2b:
  print(0)
else:
  print(a-2b)

### FIXED CODE ###

a, b = map(int, input().split())
if a <= 2*b:
  print(0)
else:
  print(a-2*b)
n,a = [input() for i in range(3)]
print(n**2-a)

### FIXED CODE ###

n,a = [int(input()) for i in range(2)]
print(n**2-a)
N = input()
a = [int(int(i)/400) for i in input().split()]
print(a)
scores = [0,0,0,0,0,0,0,0]
score8 = 0
for i,v in enumerate(a):
    if v > 7:
        score8 += 1
    else:
        scores[i] = 1
score1to7 = sum(scores)
saidai = min(score1to7 + score8, 8)
saisho = min(max(score1to7, score8), 8)
print(str(saisho) + " " + str(saidai))

### FIXED CODE ###

N = input()
a = input().split()
scores = [0,0,0,0,0,0,0,0]
score8 = 0
for i in a:
    check = int(int(i) / 400)
    if check > 7:
        score8 += 1
    else:
        scores[check] = 1
score1to7 = sum(scores)
saidai = score1to7 + score8
if score1to7 < 1:
    saisho = 1
else:
    saisho = score1to7
print(str(saisho) + " " + str(saidai))
N = int(input())
V = map(int, input().split())
a = (V[0] + V[1]) / 2
for i in range(2, N):
  a = (a + V[i]) / 2
print(a)

### FIXED CODE ###

N = int(input())
V = sorted(map(int, input().split()))
a = (V[0] + V[1]) / 2
for i in range(2, N):
  a = (a + V[i]) / 2
print(a)
import sys
sys.setrecursionlimit(10 ** 6)
from heapq import heappush, heappop


def dfs(s, v, step):
    if step == 3:
        edge3[s].add(v)
        edge3[v].add(s)
    else:
        for nv in edge[v]:
            if status[nv] == 0:
                status[nv] = 1
                dfs(s, nv, step + 1)


N = int(input())
edge = [[] for _ in range(N)]
for s in sys.stdin.readlines():
    a, b = map(int, s.split())
    a -= 1; b -= 1
    edge[a].append(b)
    edge[b].append(a)
edge3 = [set() for _ in range(N)]
for s in range(N):
    status = [0] * N
    status[s] = 1
    dfs(s, s, 0)

# print(edge3)
q = []
for i, e3 in enumerate(edge3):
    heappush(q, (-len(e3), i))

x = (y for y in range(N + 1) if y % 3 != 0)
z = 1
Z = N // 3
ans = [None] * N
for i in range(N):
    lenE3, v = heappop(q)
    if ans[v] is None:
        if z <= Z:
            ans[v] = 3 * z
            z += 1
        else:
            ans[v] = next(x)
        for e3 in edge3[v]:
            if ans[e3] is None:
                ans[e3] = next(x)
print(ans)


### FIXED CODE ###

import sys
sys.setrecursionlimit(10 ** 6)


def dfs(v, step):
    global node0, node1
    if step & 1:
        color[v] = 1
        node1 += 1
    else:
        color[v] = 0
        node0 += 1
    for nv in edge[v]:
        if color[nv] is None:
            dfs(nv, step + 1)


N = int(input())
edge = [[] for _ in range(N)]
for s in sys.stdin.readlines():
    a, b = map(int, s.split())
    a -= 1; b -= 1
    edge[a].append(b)
    edge[b].append(a)
color = [None] * N
node0 = node1 = 0
dfs(0, 0)

ans = [None] * N
num0 = N // 3
num1 = N // 3 + (N % 3 >= 1)
num2 = N // 3 + (N % 3 == 2)
if node0 > num0 and node1 > num0:
    cur = 0
    while num1 > 0:
        if color[cur] == 1:
            ans[cur] = 3 * num1 - 2
            num1 -= 1
        cur += 1
    cur = 0
    while num2 > 0:
        if color[cur] == 0:
            ans[cur] = 3 * num2 - 1
            num2 -= 1
        cur += 1
elif node0 <= num0:
    cur = 0
    while node0 > 0:
        if color[cur] == 0:
            ans[cur] = 3 * num0
            num0 -= 1
            node0 -= 1
        cur += 1
else:
    cur = 0
    while node1 > 0:
        if color[cur] == 1:
            ans[cur] = 3 * num0
            num0 -= 1
            node1 -= 1
        cur += 1

cur = 0
while num0 > 0:
    if ans[cur] is None:
        ans[cur] = 3 * num0
        num0 -= 1
    cur += 1
while num1 > 0:
    if ans[cur] is None:
        ans[cur] = 3 * num1 - 2
        num1 -= 1
    cur += 1
while num2 > 0:
    if ans[cur] is None:
        ans[cur] = 3 * num2 - 1
        num2 -= 1
    cur += 1


print(*ans)
K, S = map(int, input().split())
count = 0

for x in range(K + 1):
    for y in range(K + 1):
        z = S - (x + y)
        if 0 <= z and z <= K:
            count += 1

print(count)


### FIXED CODE ###

s = input()

print(s.replace(",", " "))
input_A = input()
input_T = input()
input_A, input_T = list(input_A), list(input_T)

if len(input_A) >= len(input_T):
    for i in range(len(input_A)-len(input_T), -1, -1):
        clear_flg = True
        for j in range(len(input_T)):
            if not (input_A[i + j] == '?' or input_A[i + j] == input_T[j]):
                clear_flg = False
                break

        if clear_flg is True:
            input_A[i:i + len(input_T)] = input_T
            input_A = ''.join(input_A).replace('?', 'a')
            break
        else:
            input_A = 'UNRESTORABLE'
else:
    input_A = 'UNRESTORABLE'
print(input_A)


### FIXED CODE ###

input_A = input()
input_T = input()
input_A, input_T = list(input_A), list(input_T)

if len(input_A) >= len(input_T):
    for i in range(len(input_A)-len(input_T), -1, -1):
        clear_flg = True
        for j in range(len(input_T)):
            if not (input_A[i + j] == '?' or input_A[i + j] == input_T[j]):
                clear_flg = False
                break

        if clear_flg is True:
            input_A[i:i + len(input_T)] = input_T
            input_A = ''.join(input_A).replace('?', 'a')
            break
else:
    clear_flg = False

if clear_flg is True:
    print(input_A)
else:
    print('UNRESTORABLE')
print(sum(sorted(list(map(int,input().split()))[:2]))

### FIXED CODE ###

L = list(map(int,input().split()))
L = sorted(L)
print(sum(L[:2]))
a, b = input().split()
a = int(a)
b = int(b * 1000)
x = int((a * b) // 1000)
print(x)

### FIXED CODE ###

a, b = input().split()
a = int(a)
b = int(float(b) * 1000)
x = (a * b) // 1000
print(x)
s = [int(x) for in list(input())]
cand = []
for c1, c2, c3 in zip(s, s[1:], s[2:]):
  res = abs(c1 * 100 + c2 * 10 + c3 - 754)
  cand.append(res)
print(min(cand))
  

### FIXED CODE ###

s = [int(x) for x in list(input())]
cand = []
for c1, c2, c3 in zip(s, s[1:], s[2:]):
  res = abs(c1 * 100 + c2 * 10 + c3 - 753)
  cand.append(res)
print(min(cand))
a, b = int(input().split())

print(a*b)


### FIXED CODE ###

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

print(a*b)
n = input()
ct = {}

if ct[1] == ct[2] and (ct[0]==ct[1] or ct[2]==ct[3]):
  print("Yes")
else:
  print("No")

### FIXED CODE ###

ct = input()


if ct[1] == ct[2] and (ct[0]==ct[1] or ct[2]==ct[3]):
  print("Yes")
else:
  print("No")
N, A, B, C, D = map(int, input().split())
S = input()

A, B, C, D = A - 1, B - 1, C - 1, D - 1
if (A < C < B < D) or (A < B < C < D):
    for i in range(A, C + 1):
        if S[i] == '#' and S[i + 1] == '#':
            print('No')
            exit()
    for i in range(B, D + 1):
        if S[i] == '#' and S[i + 1] == '#':
            print('No')
            exit()
    print('Yes')
    exit()

if A < B < D < C:
    for i in range(A, C + 1):
        if S[i] == '#' and S[i + 1] == '#':
            print('No')
            exit()

    for i in range(B, D + 1):
        if S[i] == '#' and S[i + 1] == '#':
            print('No')
            exit()

    for i in range(B + 1, D + 1):
        if S[i] == '.' and S[i + 1] == '.' and S[i + 2] == '.':
            print('Yes')
            exit()
    print('No')


### FIXED CODE ###

N, A, B, C, D = map(int, input().split())
S = input()

A, B, C, D = A - 1, B - 1, C - 1, D - 1
if (A < C < B < D) or (A < B < C < D):
    if '##' in S[A: C + 1]:
        print('No')
        exit()

    if '##' in S[B: D + 1]:
        print('No')
        exit()
    print('Yes')


if A < B < D < C:
    if '##' in S[A: C + 1]:
        print('No')
        exit()

    if '##' in S[B: D + 1]:
        print('No')
        exit()

    if '...' in S[B - 1: D + 2]:
        print('Yes')
    else:
        print('No')
import sys

for alpha in sys.stdin:
	sys.stdout.write(chr(ord(alpha)+1))

### FIXED CODE ###

alpha = input()
print(chr(ord(alpha)+1))
from functools import reduce
import math

def main():
    # 切り捨て
    # 4 // 3
    # 切り上げ
    #-(-4 // 3)
    
    # 初期値用:十分大きい数(100億)
    # 1e10

    # 初期値用:十分小さい数(-100億)
    # -1e10
    
    # 1文字のみを読み込み
    # 入力:2
    # a = input().rstrip()
    # 変数:a='2'
    
    # スペース区切りで標準入力を配列として読み込み
    # 入力:2 4 5 7
    # a, b, c, d = (int(_) for _ in input().split())  
    # 変数:a=2 b=4 c=5 d =7
    
    # 1文字ずつ標準入力を配列として読み込み
    # 入力:2 4 5 7
    # a = list(int(_) for _ in input().split())
    # 変数:a = [2, 4, 5, 7]    

    # 1文字ずつ標準入力を配列として読み込み
    # 入力:2457
    # a = list(int(_) for _ in input())
    # 変数:a = [2, 4, 5, 7]    
    N = int(input().rstrip())
    factor = []
    f = math.factorial(N)
    dict = {}
    ans = 1
    for num in range(2,int(math.sqrt(f))+2):
        while f % num == 0:
            f //= num
            factor.append(num)
            if num in dict:
                dict[num] += 1
            else:
                dict[num] = 1
    for v in dict.values():
        ans *= v + 1

    print(ans)
    
if __name__ == '__main__':
    main()


### FIXED CODE ###

from functools import reduce
import math

def main():
    # 切り捨て
    # 4 // 3
    # 切り上げ
    #-(-4 // 3)
    
    # 初期値用:十分大きい数(100億)
    # 1e10

    # 初期値用:十分小さい数(-100億)
    # -1e10
    
    # 1文字のみを読み込み
    # 入力:2
    # a = input().rstrip()
    # 変数:a='2'
    
    # スペース区切りで標準入力を配列として読み込み
    # 入力:2 4 5 7
    # a, b, c, d = (int(_) for _ in input().split())  
    # 変数:a=2 b=4 c=5 d =7
    
    # 1文字ずつ標準入力を配列として読み込み
    # 入力:2 4 5 7
    # a = list(int(_) for _ in input().split())
    # 変数:a = [2, 4, 5, 7]    

    # 1文字ずつ標準入力を配列として読み込み
    # 入力:2457
    # a = list(int(_) for _ in input())
    # 変数:a = [2, 4, 5, 7]    
    N = int(input().rstrip())
    factor = []
    f = math.factorial(N)
    dict = {}
    ans = 1
    for num in range(2,1000):
        while f % num == 0:
            f //= num
            factor.append(num)
            if num in dict:
                dict[num] += 1
            else:
                dict[num] = 1
    for v in dict.values():
        ans *= v + 1

    print(ans % (10**9 + 7))
    
if __name__ == '__main__':
    main()
N = int(input())
if (N[0] == N[1] and N[1] == N[2]) or (N[1] == N[2] and N[2] == N[3]):
  print("Yes")
else:
  print("No")


### FIXED CODE ###

N = input()
if (N[0] == N[1] and N[1] == N[2]) or (N[1] == N[2] and N[2] == N[3]):
  print("Yes")
else:
  print("No")