Harryxun/stf_run huggingface dataset:
from collections import deque
h,w = map(int,input().split())
d = [input() for i in range(h)]
count = 0
for i in range(h):
    for j in range(w):
        if d[i][j] == '#':
            count+=1
visited = [[0 for i in range(w)] for i in range(h)]
def bfs(sy,sx,gy,gx):
    que = deque()
    que.append((sy,sx))
    visited[sy][sx] = 0
    while que:
        y,x = que.popleft()
        if y == gy and x == gx:
            return visited[y][x]
        for dy,dx in [(-1,0),(1,0),(0,-1),(0,1)]:
            ny,nx = y+dy, x+dx
            if ny < 0 or nx < 0 or ny >= h or nx >= w:
                continue
            elif d[ny][nx] == '#':
                continue
            elif visited[ny][nx] != 0:
                continue
            else:
                visited[ny][nx] = visited[y][x] + 1
                que.append((ny,nx))
    return visited[gy][gx]
ans = bfs(0,0,h-1,w-1)
if ans = 0:
    print(-1)
    exit()
print(h*w - ans - count - 1)

### FIXED CODE ###

from collections import deque
h,w = map(int,input().split())
d = [input() for i in range(h)]
count = 0
for i in range(h):
    for j in range(w):
        if d[i][j] == '#':
            count+=1
visited = [[0 for i in range(w)] for i in range(h)]
def bfs(sy,sx,gy,gx):
    que = deque()
    que.append((sy,sx))
    visited[sy][sx] = 0
    while que:
        y,x = que.popleft()
        if y == gy and x == gx:
            return visited[y][x]
        for dy,dx in [(-1,0),(1,0),(0,-1),(0,1)]:
            ny,nx = y+dy, x+dx
            if ny < 0 or nx < 0 or ny >= h or nx >= w:
                continue
            elif d[ny][nx] == '#':
                continue
            elif visited[ny][nx] != 0:
                continue
            else:
                visited[ny][nx] = visited[y][x] + 1
                que.append((ny,nx))
    return visited[gy][gx]
ans = bfs(0,0,h-1,w-1)
if ans == 0:
    print(-1)
    exit()
print(h*w - ans - count - 1)
#! env/bin/local python3
# -*- coding: utf-8 -*-

s = input()
if s[2] == s[3] and s[4] == 2[6]:
    print('Yes')
else:
    print('No')

### FIXED CODE ###

#! env/bin/local python3
# -*- coding: utf-8 -*-

s = input()
if s[2] == s[3] and s[4] == s[5]:
    print('Yes')
else:
    print('No')
print('YES' if sum(divmod(int(input()), 2)) >= int(inpu()) else 'NO')

### FIXED CODE ###

def a_anti_adjacency(N, K):
    if N % 2 == 0:
        ans = 'YES' if N // 2 >= K else 'NO'
    else:
        ans = 'YES' if (1 + N // 2) >= K else 'NO'
    return ans

N, K = [int(i) for i in input().split()]
print(a_anti_adjacency(N, K))
str1 = input()
str2 = input()

if str1 == str2:
    print('Yes')

for i in range(len(str1) - 1):
    
    str1 = str1[-1] + str1[:-1]
    
    if str1 == str2:
        print('Yes')

print('No')

### FIXED CODE ###

tasks = input()

tasks = [int(t) for t in tasks.split()]

# 0, 1, 2
cost0 = abs(tasks[1] - tasks[0]) + abs(tasks[2] - tasks[1])

# 0, 2, 1
cost1 = abs(tasks[2] - tasks[0]) + abs(tasks[2] - tasks[1])

# 1, 0, 2
cost2 = abs(tasks[1] - tasks[0]) + abs(tasks[2] - tasks[0])

# 1, 2, 0
cost3 = abs(tasks[1] - tasks[2]) + abs(tasks[2] - tasks[0])

# 2, 0, 1
cost4 = abs(tasks[2] - tasks[0]) + abs(tasks[0] - tasks[1])

# 2, 1, 0
cost5 = abs(tasks[2] - tasks[1]) + abs(tasks[0] - tasks[1])

min_cost = min([cost0, cost1, cost2, cost3, cost4, cost5])

print(min_cost)
if __name__ == '__main__':
    N, K, L = map(int, input().split())
    PQ = [None]*K
    RS = [None]*L
    roads = [set() for _ in range(N)]
    rails = [set() for _ in range(N)]
    answer = [None]*N
        
    for i in range(K):
        PQ[i] = list(map(int, input().split()))
    #PQ = sorted(PQ, key=min)
    
    
    for i in range(K):
        if not roads[PQ[i][1] - 1]:
            roads[PQ[i][0] - 1].add(PQ[i][0] - 1)
            roads[PQ[i][0] - 1].add(PQ[i][1] - 1)
            roads[PQ[i][1] - 1] = roads[PQ[i][0] - 1]
        else:
            roads[PQ[i][1] - 1].add(PQ[i][0] - 1)
            roads[PQ[i][1] - 1].add(PQ[i][1] - 1)
            roads[PQ[i][0] - 1] = roads[PQ[i][1] - 1]

    for i in range(L):
        RS[i] = list(map(int, input().split()))
    #RS = sorted(RS, key=min)
    
    for i in range(L):
        if not rails[PQ[i][1] - 1]:
            rails[RS[i][0] - 1].add(RS[i][0] - 1)
            rails[RS[i][0] - 1].add(RS[i][1] - 1)
            rails[RS[i][1] - 1] = rails[RS[i][0] - 1]
        else:
            rails[RS[i][1] - 1].add(RS[i][0] - 1)
            rails[RS[i][1] - 1].add(RS[i][1] - 1)
            rails[RS[i][0] - 1] = rails[RS[i][1] - 1]

    for n in range(N):
        roads[n].add(n)
        rails[n].add(n)
        answer[n]= len(roads[n] & rails[n])
    
    
            
    print(' '.join(map(str, answer)))

### FIXED CODE ###

from collections import defaultdict
def build_tree(N, edges):
    root_list = [i for i in range(N)]
    for p, q in edges:
        p -= 1
        q -= 1
        root_p = get_root(root_list, p)
        root_q = get_root(root_list, q)
        root_now = min(root_p, root_q, p)
        root_list[p] = root_now
        root_list[q] = root_now
        root_list[root_p] = root_now
        root_list[root_q] = root_now
    return root_list

def get_root(root_list, city):
    if root_list[city] == city:
        return city
    else: 
        root_list[city] = get_root(root_list, root_list[city])
        return root_list[city]

if __name__ == '__main__':
    N, K, L = map(int, input().split())
    roads = [None]*K
    rails = [None]*L
    for k in range(K):
        roads[k] = list(map(int, input().split()))
    for l in range(L):
        rails[l] = list(map(int, input().split()))
    
    
    '''N = 2*10**5
    L = int(N/2)
    K = int(N/2)
    roads = [None]*K
    rails = [None]*L
    for i in range(L):
        roads[i] = [2*i, 2*i+1]
    for i in range(K):
        rails[i] = [2*i, 2*i+1]'''
    
    road_roots = build_tree(N, roads)
    rail_roots = build_tree(N, rails)
    
    railroads = defaultdict(int)
    RR = []
    for n in range(N):
        rr = (get_root(road_roots, n), get_root(rail_roots, n))
        RR.append(rr)
        railroads[rr] += 1
    answer = [railroads[key] for key in RR]
    print(' '.join(map(str, answer)))
tar, max = map(int, input(),sprit())
if max <= tar * 500:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

tar, max = map(int, input().split())
if max <= tar*500:
  print('Yes')
else:
  print('No')
s=input()
n=len(s)
ans=0
for i in range(n):
    for j in range(i,n):
        bubun=s[i:j+1]
        flag=True
        for c in bubun:
            if(c not in ['A','G','C','T']):
            flag = False
        if(flag):
            ans = max(ans,len(bubun))
print(ans)


### FIXED CODE ###

s = input()
n = len(s) # 文字列の長さを取得しておく

res = 0 # 条件になければ0
for i in range(n): # Sの部分文字列を全探索するループ：重複を許す（i==jの時は1文字の部分文字列になる）が入替を許さないループ
    for j in range(i, n):
        sub = s[i: j+1] # i文字目からからj文字目までの部分文字列

        flg = True
        for c in sub: # Python的for文
            if(c not in ['A', 'G', 'C', 'T']): flg = False # こちらも、in はこういう時便利です

        if(flg): res = max(res, len(sub)) # ACGT文字列の長さnumの最大値を保持する

print(res)
a,b,k = map(int,input().split())
if a + b <= k:
    print(0,0)
elif a <= k:
    print(0, a+b-k)
else 
    print(a-k,0)

### FIXED CODE ###

a,b,k = map(int,input().split())
if a + b <= k:
    print(0,0)
elif a <= k:
    print(0, a+b-k)
else:
    print(a-k,b)
n = int(input())
#日
d = int(input())
#合宿終了後のチョコレートの個数
x = int(input())




#i人目のA日目に食べた数を数える
num = 0

#配列
a = []

#３人分
for i in range(n):
    a.append(int(input()))

for i in range(n):
    for j in range(d):
        if a[i]*j +1 <= d:
            num += 1
        
    
    
    
    
            
print(num+x)

### FIXED CODE ###


n = int(input())
#日
d,x = input().split()
#合宿終了後のチョコレートの個数





#i人目のA日目に食べた数を数える
num = 0

#配列
a = []

#３人分
for i in range(n):
    a.append(int(input()))
    for j in range(int(d)):
        if a[i]*j +1 <= int(d):
            num += 1
    
    
    
    
            
print(num+int(x))
from sys import stdin
s=[int(x) for x in list(stdin.readline().rstrip())]
abs_seven=[abs(7-i) for i in s]
min_num=min(abs_seven)
indices=[]
nums=[]
for i, n in enumerate(abs_seven):
    if n == min_num:
        indices.append(i)

for i in indices:
    try:
        n=s[i:i+3]
        nums.append(n[0]*100+n[1]*10+n[2])
    except:
        pass
nums=[abs(753-n) for n in nums]
print(min(nums))


### FIXED CODE ###

from sys import stdin
s=stdin.readline().rstrip()
print(min([abs(int(s[i:i+3])-753) for i,n in enumerate(s[:-2])]))
n,a,b=map(int,input().split())
x=list(map(int,input().split()))
ret=0
for i in range(n-1):
  ret+=min(a*(x[i+1]-x[i]),b)
print ret

### FIXED CODE ###

n,a,b=map(int,input().split())
x=list(map(int,input().split()))
ret=0
for i in range(n-1):
  ret+=min(a*(x[i+1]-x[i]),b)
print(ret)
import numpy as np
N = int(input())
S = list(map(ord, list(input())))
mod = 10**9+7
base = 100
power = [1]*(N+1)
for i in range(1, N+1):
    power[i] = power[i-1]*base%mod
def check(m):
    if N-m<m:
        return False
    rolling_hash = [0]*(N-m+1)
    res = 0
    for i in range(m):
        res+=S[i]*power[m-i-1]
        res%=mod
    rolling_hash[0] = res
    dic = {res:0}
    for i in range(N-m):
        tmp = ((rolling_hash[i]-S[i]*power[m-1])*base
                             +S[i+m])%mod
        rolling_hash[i+1] = tmp
        if tmp in dic.keys():
            index = dic[tmp]
            if index +m<=i+1:
                return True
        else:
            dic[rolling_hash[i+1]] = i+1
    return False
ok = 0
ng = N+1
while ng-ok>1:
    mid = (ok+ng)//2
    if check(mid):
        ok = mid
    else:
        ng = mid
print(ok)
        


### FIXED CODE ###

N = int(input())
S = input()
ans = 0
for i in range(N):
    if N-i<ans:
        break
    if S[i+1:].find(S[i-ans:i+1])>=0:
        ans += 1
print(ans)
a = raw_input()

if a == "ABC":
  print(ARC)
 elif a == "ARC":
  print(ABC)

### FIXED CODE ###

a = input()

if a == "ABC":
  print("ARC")
elif a == "ARC":
  print("ABC")
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
c.append(0)
for i in range(n-1):
  if a[i]!=a[i+1]-1:
    c[a[i]]=0
print(sum(b)+sum(c))

### FIXED CODE ###

n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
c.append(0)
for i in range(n-1):
  if a[i]!=a[i+1]-1:
    c[a[i]-1]=0
c[a[n-1]-1]=0
print(sum(b)+sum(c))
import sys
input = sys.stdin.readline

ta_c,ao_c,num = map(int,input().split())

for _ in [0]*num:
    if ta_c > 0:
        ta_c -=1
    elif ao_c >0:
        ao_c -=1

print(ta_c,ao_c)

### FIXED CODE ###

ta_c,ao_c,num = map(int,input().split())

if num <= ta_c:
    print(ta_c-num,ao_c)
elif ta_c < num <= ta_c + ao_c:
    ao_c = ta_c+ao_c - num
    ta_c = 0
    print(ta_c,ao_c)
else:
    ta_c, ao_c = 0,0
    print(ta_c,ao_c)
import sys
N, M = map(int, input().split())
xrd = [[] for i in range(N)]
x = [None]*N


def check(s):
    global xrd,x
    for t, d in xrd[s]:
        if x[t] is None:
            x[t] = x[s] + d
            check(t)
        else:
            if x[t] != x[s] + d:
                print("No")
                sys.exit()


for i in range(M):
    L, R, D = map(int, input().split())
    xrd[L-1].append([R-1, D])
    xrd[R-1].append([L-1, -D])

for i in range(N):
    if x[i] is None:
        x[i] = 0
        check(i)


print("Yes")


### FIXED CODE ###

import sys
sys.setrecursionlimit(200002)

N, M = map(int, input().split())
G = [[] for _ in range(N)]
x = [None] * N

def fail():
    print("No")
    exit()

def dfs(s):
    global x, G
    for t, d in G[s]:
        if x[t] is None:
            x[t] = x[s] + d
            dfs(t)
        else:
            if x[t] != x[s] + d:
                fail()

for _ in range(M):
    L, R, D = map(int, input().split())
    G[L-1].append([R-1,  D])
    G[R-1].append([L-1, -D])

for i in range(N):
    if x[i] is None:
        x[i] = 0
        dfs(i)

print("Yes")
houseTime = int(input())
place = input().split() 
place = int(i) for i in place
place = sorted(place)
print(place[houseTime - 1] - place[0])


### FIXED CODE ###

houseTime = int(input())
place = input().split() 
place = [int(i) for i in place]
place = sorted(place)
print(place[houseTime - 1] - place[0])
s = input()
s = s[::-1]
t_list = ['dream', 'dreamer', 'erase', 'eraser']
t_list = [i[::-1] for i in t_list]
i = 0

while i < len(s):
    can = False
    for j in range(4):
        if s[i:i+len(t_list[j])] == t_list[j]:
            i+=len(t_list[j])
            can = True
    if can == False: # うまくいっても最後には`can=False`になる
        break

if can == True
    print('YES')
else:
    print('NO')

### FIXED CODE ###

s = input()
s = s[::-1]
t_list = ['dream','dreamer','erase','eraser']
t_list = [t[::-1] for t in t_list]
 
ans = 'NO'
i = 0
while i < len(s):  
  p = i
  for t in t_list:        
    if s[i:i+len(t)] == t:      
      i += len(t)
      if i == len(s):
        ans ='YES'
      break
  if p==i or ans=='YES':
    break
 
print(ans)
n = int(input())
arr = list(map(int, input().split()))

a = [arr[i] for i in range(0,n,2)]
b = [arr[y] for y in range(1,n,2)]

import collections
acnt = collections.Counter(a)
bcnt = collections.Counter(b)

lsacnt = sorted(acnt.items(), key=lambda x: x[1],reverse=True)
lsbcnt = sorted(bcnt.items(), key=lambda j: j[1],reverse=True)

def val(abcnt, ablscnt):
	if len(list(abcnt)) < 2:
		return 0
	else:
		return ablscnt[1][1]

if lsacnt[0][0] != lsbcnt[0][0]:
	ans = n - lsacnt[0][1] - lsbcnt[0][1]
elif lsacnt[0][0] == lsbcnt[0][0]:
	if lsacnt[0][1] > lsbcnt[0][1]:
		ans = n - lsacnt[0][1] - val(bcnt,lsbcnt)
	elif lsacnt[0][1] < lsbcnt[0][1]:
		ans = n - val(acnt,lsacnt) - lsbcnt[0][1]
	elif lsacnt[0][1] == lsbcnt[0][1]:
		ans = n - lsacnt[0][1] - max(lsacnt[1][1],lsbcnt[1][1])

print(ans)

### FIXED CODE ###

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

a = [arr[i] for i in range(0,n,2)]
b = [arr[y] for y in range(1,n,2)]

import collections
acnt = collections.Counter(a)
bcnt = collections.Counter(b)

lsacnt = sorted(acnt.items(), key=lambda x: x[1],reverse=True)
lsbcnt = sorted(bcnt.items(), key=lambda j: j[1],reverse=True)

def val(abcnt, ablscnt):
	if len(list(abcnt)) < 2:
		return 0
	else:
		return ablscnt[1][1]

if lsacnt[0][0] != lsbcnt[0][0]:
	ans = n - lsacnt[0][1] - lsbcnt[0][1]
elif lsacnt[0][0] == lsbcnt[0][0]:
	if lsacnt[0][1] > lsbcnt[0][1]:
		ans = n - lsacnt[0][1] - val(bcnt,lsbcnt)
	elif lsacnt[0][1] < lsbcnt[0][1]:
		ans = n - val(acnt,lsacnt) - lsbcnt[0][1]
	elif lsacnt[0][1] == lsbcnt[0][1]:
		ans = n - lsacnt[0][1] - max(val(acnt,lsacnt),val(bcnt,lsbcnt))

print(ans)
import sys
import numpy as np


read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


def c(A):
    N = len(A)
    B = np.zeros_like(A)
    for i, a in enumerate(A):
        l = max(0, i - a)
        r = min(N - 1, i + a)
        B[l] += 1
        if r + 1 < N:
            B[r + 1] -= 1

    B = np.cumsum(B)
    return B


def main():
    N, K = map(int, readline().split())
    A = np.array(map(int, readline().split()))


    K = min(K, 50)
    for _ in range(K):
        A = c(A)

    print(' '.join(A.astype(str)))


if __name__ == '__main__':
    main()

### FIXED CODE ###

import sys
import numpy as np
from numba import njit


read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

@njit('(i8[::1],)', cache=True)
def c(A):
    N = len(A)
    B = np.zeros_like(A)
    for i, a in enumerate(A):
        l = max(0, i - a)
        r = min(N - 1, i + a)
        B[l] += 1
        if r + 1 < N:
            B[r + 1] -= 1

    B = np.cumsum(B)
    return B


def main():
    N, K = map(int, readline().split())
    A = np.array(readline().split(), np.int64)


    K = min(K, 50)
    for _ in range(K):
        A = c(A)

    print(' '.join(A.astype(str)))


if __name__ == '__main__':
    main()
def main():
    z = input()
    x = int(z)

    sum = 0
    while x > 0.5:
        y = int(x % 10)
        sum = int(sum + y)
        x = int(x / 10)

    if int(sum%9)==0:
        print('Yes')
    else:
        print('No')

if __name__ == '__main__':
    main()


### FIXED CODE ###

def main():
    z = input()
    x = int(z)

    if x%9==0:
        print('Yes')
    else:
        print('No')

if __name__ == '__main__':
    main()
N = input()
a = list(map(int,input().split()))
over3200 = 0
syurui_min = 0
syurui_max = 0
b = [0] * 8
for i in a:
    if 3200 <= i and i <= 4800:
        over3200 += 1
    else:
        b[min(i // 400)] = 1
for i in b:
    if(i == 1):
        syurui_min += 1
syurui_max = syurui_min + over3200
if syurui_min == 0:
    syurui_min = 1
print("{0} {1}".format(syurui_min, syurui_max))


### FIXED CODE ###

N = input()
a = list(map(int,input().split()))
over3200 = 0
syurui_min = 0
syurui_max = 0
b = [0] * 8
for i in a:
    if 1 <= i and i <= 399:
        b[0] = 1
    if 400 <= i and i <= 799:
        b[1] = 1
    if 800 <= i and i <= 1199:
        b[2] = 1
    if 1200 <= i and i <= 1599:
        b[3] = 1
    if 1600 <= i and i <= 1999:
        b[4] = 1
    if 2000 <= i and i <= 2399:
        b[5] = 1
    if 2400 <= i and i <= 2799:
        b[6] = 1
    if 2800 <= i and i <= 3199:
        b[7] = 1
    if 3200 <= i and i <= 4800:
        over3200 += 1
for i in b:
    if(i == 1):
        syurui_min += 1
syurui_max = syurui_min + over3200
if syurui_min == 0:
    syurui_min = 1
print("{0} {1}".format(syurui_min, syurui_max))
x = input(int())
for i in range(2, 10):
  if 200*i <= x < 200*(i+1)-1:
    pprint(10-i)

### FIXED CODE ###

x = int(input())
for i in range(2,10):
  if 200*i <= x < 200*(i+1):
    print(10-i)
import math
A,B,K=map(int,input().split())
C=math.gcd(A,B)
cnt=0
for x in range(C,0,-1):
    if C%x==0:
        cnt+=1
        if cnt==K:
            print(x)
            break



### FIXED CODE ###

import fractions
A,B,K=map(int,input().split())
C=fractions.gcd(A,B)
cnt=0
for x in range(C,0,-1):
    if C%x==0:
        cnt+=1
        if cnt==K:
            print(x)
            break
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

Q, A, B, C = map(int, readline().split())
N = A + B + C
S = read().split()

S = tuple(0 if s == b'BC' else 1 if s == b'AC' else 2 for s in S)

assert N != 2

def solve_1(N, A, B, C, S):
    nums = [A, B, C]
    for s in S:
        if nums[s] == N:
            raise Exception
        i, j = (0, 1) if s == 2 else (0, 2) if s == 1 else (1, 2)
        if nums[i] < nums[j]:
            i, j = j, i
        yield j
        nums[j] += 1
        nums[i] -= 1


def solve_2(N, A, B, C, S):
    nums = [A, B, C]
    s = S[0]
    # 初手で死亡
    if nums[s] == N:
        raise Exception
    # あとはできる。きわどいときは 2 手読み
    S = S + (0, )
    for s, t in zip(S, S[1:]):
        i, j = (0, 1) if s == 2 else (0, 2) if s == 1 else (1, 2)
        if (nums[i], nums[j]) != (1, 1):
            if nums[i] < nums[j]:
                i, j = j, i
        if s != t:
            i, j = t, 3 - s - t
        yield j
        nums[j] += 1
        nums[i] -= 1

def large(N, A, B, C, S):
    nums = [A, B, C]
    for s in S:
        if nums[s] == N:
            raise Exception
        i, j = (0, 1) if s == 2 else (0, 2) if s == 1 else (1, 2)
        if nums[i] < nums[j]:
            i, j = j, i
        yield j
        nums[j] += 1
        nums[i] -= 1

f = solve_1 if N == 1 else solve_2 if N == 2 else large

try:
    cmds = list(f(N,A,B,C,S))
    print('Yes')
    answer = ('ABC'[i] for i in cmds)
    print('\n'.join(answer))
except Exception:
    print('No')
    exit()


### FIXED CODE ###

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

Q, A, B, C = map(int, readline().split())
N = A + B + C
S = read().split()

S = tuple(0 if s == b'BC' else 1 if s == b'AC' else 2 for s in S)

def solve_1(N, A, B, C, S):
    nums = [A, B, C]
    for s in S:
        if nums[s] == N:
            raise Exception
        i, j = (0, 1) if s == 2 else (0, 2) if s == 1 else (1, 2)
        if nums[i] < nums[j]:
            i, j = j, i
        yield j
        nums[j] += 1
        nums[i] -= 1

def solve_2(N, A, B, C, S):
    nums = [A, B, C]
    s = S[0]
    # 初手で死亡
    if nums[s] == N:
        raise Exception
    # あとはできる。きわどいときは 2 手読み
    S = S + (0, )
    for s, t in zip(S, S[1:]):
        i, j = (0, 1) if s == 2 else (0, 2) if s == 1 else (1, 2)
        if (nums[i], nums[j]) != (1, 1):
            if nums[i] < nums[j]:
                i, j = j, i
        elif s != t:
            i, j = t, 3 - s - t
        yield j
        nums[j] += 1
        nums[i] -= 1

def large(N, A, B, C, S):
    nums = [A, B, C]
    for s in S:
        if nums[s] == N:
            raise Exception
        i, j = (0, 1) if s == 2 else (0, 2) if s == 1 else (1, 2)
        if nums[i] < nums[j]:
            i, j = j, i
        yield j
        nums[j] += 1
        nums[i] -= 1

f = solve_1 if N == 1 else solve_2 if N == 2 else large

try:
    cmds = list(f(N, A, B, C, S))
    print('Yes')
    answer = ('ABC' [i] for i in cmds)
    print('\n'.join(answer))
except Exception:
    print('No')
N,Q=map(int,(input()).split())
S=input()
l_list=[]
r_list=[]
for i in range(Q):
  l,r=input().split()
  l_list.append(int(l))
  r_list.append(int(r))
for i in range(Q):
  S_i=S[l_list[i]-1,r_list[i]]
  n=0
  while "AC" in S_i:
    n+=1
  print(n)

### FIXED CODE ###

N,Q=map(int,(input()).split())
S=input()
l_list=[]
r_list=[]
for i in range(Q):
  l,r=input().split()
  l_list.append(int(l))
  r_list.append(int(r))
count=0
AC_count=[0]
for i in range(1,N+2):
  if S[i-1:i+1]=="AC":
    count+=1
  AC_count.append(count)
AC_count.append(count)
k=0
for j in range(Q):
  k=AC_count[r_list[j]-1]-AC_count[l_list[j]-1]
  print(k)
class Dice:
    def _init_ (self,data):
        self.data = data

    def move(self,direction):
        if direction == 'E':
            self.data[0],self.data[3],self.data[5],self.data[2] = \
                    self.data[3].self.data[5],self.data[2],self.data[0]
        elif direction == 'N':
            self.data[0],self.data[4],self.data[5],self.data[1] = \
                    self.data[4].self.data[5],self.data[1],self.data[0]
        elif direction == 'S':
            self.data[0],self.data[1],self.data[5],self.data[4] = \
                    self.data[4].self.data[0],self.data[1],self.data[5]
        elif direction == 'W':
            self.data[0],self.data[2],self.data[5],self.data[3] = \
                    self.data[2].self.data[5],self.data[3],self.data[0]

    def getTop(self):
        return self.data[0]

dice = Dice(input().split())
cmd = input()
for i in range(len(cmd)):
    dice.move(cmd[i])
    print(dice.getTop())

### FIXED CODE ###

class Dice:
    def __init__ (self,data):
        self.data = data

    def move(self,direction):
        if direction == 'E':
            self.data[0],self.data[3],self.data[5],self.data[2] = \
                    self.data[3],self.data[5],self.data[2],self.data[0]
        elif direction == 'N':
            self.data[0],self.data[4],self.data[5],self.data[1] = \
                    self.data[1],self.data[0],self.data[4],self.data[5]
        elif direction == 'S':
            self.data[0],self.data[1],self.data[5],self.data[4] = \
                    self.data[4],self.data[0],self.data[1],self.data[5]
        elif direction == 'W':
            self.data[0],self.data[2],self.data[5],self.data[3] = \
                    self.data[2],self.data[5],self.data[3],self.data[0]

    def getTop(self):
        return self.data[0]

dice = Dice(input().split())
cmd = input()
for i in range(len(cmd)):
    dice.move(cmd[i])
print(dice.getTop())
n,k =(int(x) for x in input().split())
list = (int(x) for x in input().split())
p = 0
     
for i in range(0, n):
	if list[i] >= k:
		p = p + 1

print(p)

### FIXED CODE ###

n,k =(int(x) for x in input().split())
list = input().split()
p = 0
list = [int(s) for s in list]
     
for i in range(0, n):
    if list[i] >= k:
        p = p + 1

print(p)
a, b = map(int, raw_input().split())
print a*b + " " + (a+b)*2

### FIXED CODE ###

a, b = map(int, raw_input().split())
print a*b,
print (a+b)*2
a = int(input())
b = int(input())
c = int(input())
print(a,b,c)

temp = a
a = c
c = b
b = temp 

print(a,b,c)

### FIXED CODE ###

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