Harryxun/stf_run huggingface dataset:
from collections import deque
import math

def explore(C, D):
    queue = deque([[C[0]-1, C[1]-1]])
    maze_visited[C[0]-1][C[1]-1] = 0
    while queue:
        y, x = queue.popleft()
        mv_cur = maze_visited[y][x]
        for i, j in [(1,0),(0,1),(-1,0),(0,-1)]:
            n_x, n_y = x + i, y + j
            if n_x >= 0 and n_y >= 0 and n_x < W and n_y < H:
                mv_n = maze_visited[n_y][n_x]
                if mv_n > mv_cur:
                    if S[n_y][n_x] == '.':
                        maze_visited[n_y][n_x] = mv_cur
                        queue.append([n_y, n_x])
        for i in range(-2, 3):
            for j in range(-2, 3):
                if abs(i) + abs(j) <= 1:
                    continue
                n_x, n_y = x + i, y + j
                if n_x >= 0 and n_y >= 0 and n_x < W and n_y < H:
                    mv_n = maze_visited[n_y][n_x]
                    if mv_n > mv_cur + 1:
                        if S[n_y][n_x] == '.':
                            maze_visited[n_y][n_x] = mv_cur + 1
                            queue.append([n_y, n_x])
    
H, W = list(map(int, input().split()))
C = list(map(int, input().split()))
D = list(map(int, input().split()))

S = [list(input()) for i in range(H)]

maze_visited = [[math.inf] * W for i in range(H)]

explore(C,D)

if maze_visited[D[0] - 1][D[1] - 1] == math.inf:
    print('-1')
else:
    print(maze_visited[D[0] - 1][D[1] - 1])

### FIXED CODE ###

from collections import deque
import math
 
def explore(C, D):
    queue = deque([(C[0]-1, C[1]-1)])
    maze_visited[C[0]-1][C[1]-1] = 0
    while queue:
        y, x = queue.popleft()
        mv_cur = maze_visited[y][x]
        for i, j in [(1,0),(0,1),(-1,0),(0,-1)]:
            n_x, n_y = x + i, y + j
            if n_x >= 0 and n_y >= 0 and n_x < W and n_y < H:
                mv_n = maze_visited[n_y][n_x]
                if mv_n > mv_cur:
                    if S[n_y][n_x] == '.':
                        maze_visited[n_y][n_x] = mv_cur
                        queue.appendleft((n_y, n_x))
        for i in range(-2, 3):
            for j in range(-2, 3):
                if abs(i) + abs(j) <= 1:
                    continue
                n_x, n_y = x + i, y + j
                if n_x >= 0 and n_y >= 0 and n_x < W and n_y < H:
                    mv_n = maze_visited[n_y][n_x]
                    if mv_n > mv_cur + 1:
                        if S[n_y][n_x] == '.':
                            maze_visited[n_y][n_x] = mv_cur + 1
                            queue.append((n_y, n_x))
    
H, W = list(map(int, input().split()))
C = list(map(int, input().split()))
D = list(map(int, input().split()))
 
S = [list(input()) for i in range(H)]
 
maze_visited = [[math.inf] * W for i in range(H)]
 
explore(C,D)
 
if maze_visited[D[0] - 1][D[1] - 1] == math.inf:
    print('-1')
else:
    print(maze_visited[D[0] - 1][D[1] - 1])
N = int(input())
ans = 0
for i in range(1, N + 1):
    if len(i) % 2 == 1:
        ans += 1
print(ans)


### FIXED CODE ###

N = int(input())
ans = 0
for i in range(1, N + 1):
    if len(str(i)) % 2 == 1:
        ans += 1
print(ans)
H, W, A, B = map(int, input().split())
if H==1:
    print("".join(map(str,[1]*A+[0]*(W-A))))
elif W==1:
    for i in [1]*B+[0]*(H-B):
        print(i)
elif W%A==0 and H%B==0 and A*(H//B)==W:
    a, b = 0, 0
    l = [[0]*W for _ in range(H)]
    while B*b<H and A*a<W:
        for i in range(A):
            for j in range(B):
                l[A*a+i][B*b+j] = 1
        a += 1
        b += 1
    for i in l:
        print("".join(map(str,i)))
else:
    print("No")

### FIXED CODE ###

H, W, A, B = map(int, input().split())
l = [[0]*W for _ in range(H)]

for i in range(B):
    for j in range(A):
        l[i][j] = 1

for i in range(B, H):
    for j in range(A, W):
        l[i][j] = 1

for i in l:
    print("".join(map(str, i)))
N=int(input())
if N[0]=="9" or N[1]=="9":
  print("Yes")
else:
  print("No")

### FIXED CODE ###

N=input()
if N[0]=="9" or N[1]=="9":
  print("Yes")
else:
  print("No")
N = int(input())
A = [int(input()) for i in range(N)]

for i in range(N):
    for j in range(N):
        A_list[j] = A[j]
    
    A_list[i] = 0
    print(max(A_list))

### FIXED CODE ###

N = int(input())
A = [int(input()) for i in range(N)]

Asort = sorted(A,reverse=True)
first = max(Asort)
second = max(Asort[1:N])

for i in range(N):
    if A[i] != first:
        print(max(first,A[i]))
    else:
        print(second)
while True:
    try:
        l = map(int, raw_input().split(","))
        v1 = l.pop(10)
        v2 = l.pop(10)
        p = v1*float(sum(l))/(v1+v2)
        for i in range(10):
            p -= l[i]
            if p <= 0:
                print i+1
                break


### FIXED CODE ###

while True:
    try:
        l = map(int, raw_input().split(","))
        v1 = l.pop(10)
        v2 = l.pop(10)
        p = v1*float(sum(l))/(v1+v2)
        for i in range(10):
            p -= l[i]
            if p <= 0:
                print i+1
                break
    except:
        break
from sys import stdin
#T = int(stdin.readline())
S = stdin.readline()

if S == 'AAA' or S == 'BBB':
    print("No")
else
    print("Yes")

### FIXED CODE ###

from sys import stdin
#T = int(stdin.readline())
S = stdin.readline().strip()

if S == "AAA" or S == "BBB":
    print('No')
else:
    print('Yes')
a = int(input().replace(' ', ''))

count = 1
while count < 100001
    if a = count ** 2:
        print('Yes')
        break
    count += 1

### FIXED CODE ###

a = [int(item) for item in input().split()]
seki = a[0] * a[1]
if seki % 2 == 0:
    print('Even')
else:
    print('Odd')
import numpy as np


from collections import deque
class Graph:
    edges = {}

    def append_edge(self, sv, ev, weight = 1):
        if sv in self.edges:
            self.edges[sv].append((ev, weight))
        else:
            self.edges[sv] = [(ev, weight)]

    def bfs(self, sv):
        dist = np.full(len(self.edges.keys()), -1)
        q = deque([])   # キュー
        q.append(sv)
        dist[sv] = 0
        connect_vtxs = []
        while len(q) > 0:
            p = q.popleft()     # キュー取りだし（先頭）
            connect_vtxs.append(p)
            for (ev, w) in self.edges[p]:
                if dist[ev] != -1:
                    continue
                q.append(ev)    # キュー追加
                dist[ev] = dist[p] + 1
        return dist, connect_vtxs

N, X, Y = list(map(int, input().split()))
g = Graph()
for i in range(N - 1):
    g.append_edge(i, i + 1)
    g.append_edge(i + 1, i)
g.append_edge(X - 1, Y - 1)
g.append_edge(Y - 1, X - 1)
dist_cnt = np.zeros(N)
for sv in range(N):
    dist, connect_vtxs = g.bfs(sv)
    for j in range(dist.shape[0]):
        if dist[j] == -1: continue
        dist_cnt[dist[j]] += 1

for i in range(N-1):
    print(int(dist_cnt[i+1]/2))


### FIXED CODE ###

s = input()
if s[2] == s[3] and s[4] == s[5]:
    print("Yes")
else :
    print("No")
A,B,K=input().split(" ")
if K<=A:
  A -= K
  print(str(A)+" "+str(B))
else:
  A = 0
  B -= K - A
  print(str(A)+" "+str(B))

### FIXED CODE ###

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

if K>=A:
  K -=A
  A = 0
  if K>=B:
    B = 0
  else:
    B -=K
else:
  A -=K
print(A,B)
import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

N=int(input())
ac=0
wa=0
tle=0
re=0
for i in range(N):
    S=ns()
    if(S=='AC'):
        ac+=1
    elif(S=='WA'):
        wa+=1
    elif(S=='TLE'):
        tle+=1
    elif(S=='RE'):
        re+=1


print('AC x '+str(ac))
print('WA x '+str(wa))
print('TLE x '+str(tle))
print('RE x '+str(re))


AC × 3
WA × 1
TLE × 2
RE × 0

### FIXED CODE ###

import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

N=int(input())
ac=0
wa=0
tle=0
re=0
for i in range(N):
    S=ns()
    if(S=='AC'):
        ac+=1
    elif(S=='WA'):
        wa+=1
    elif(S=='TLE'):
        tle+=1
    elif(S=='RE'):
        re+=1


print('AC x '+str(ac))
print('WA x '+str(wa))
print('TLE x '+str(tle))
print('RE x '+str(re))
import sys
lines = sys.stdin.readlines()
for i in range(lines.length):
    a = int(lines[i])
    if(a == 0):
        break
    else:
        print("Case {0}: {1}".format(i+1, a))


### FIXED CODE ###

import sys
lines = sys.stdin.readlines()
for i in range(len(lines)):
    a = int(lines[i])
    if(a == 0):
        break
    else:
        print("Case {0}: {1}".format(i+1, a))
N = int(input())
S = list(input())
Q = int(input())
set_dic = {}

for i, s in enumerate(S):
    if s not in set_dic.keys():
        set_dic[s] = {i+1}
    else:
        set_dic[s].add(i+1)

anslist = []
count = 0

for _ in range(Q):
    query = list(input())
    if query[0] == "1":
        i = int(query[2])
        c = query[4]
        for l in set_dic.values():
            l.discard(i)
        if c not in set_dic.keys():
            set_dic[c] = {i}
        else:
            set_dic[c].add(i)
    else:
        l = int(query[2])
        r = int(query[4])
        ansset = set()
        for i in range(l, r + 1):
            for key, eachset in set_dic.items():
                if i in eachset:
                    ansset.add(key)
                    break
        ans = len(ansset)
        anslist.append(ans)
        count += 1

for i in anslist:
    print(i)

### FIXED CODE ###

import bisect
import sys
input = sys.stdin.readline

def solve():
    N = int(input())
    S = list(input())
    Q = int(input())
    set_dic = {}

    for i, s in enumerate(S):
        if s not in set_dic:
            set_dic[s] = [i+1]
        else:
            bisect.insort_left(set_dic[s], i+1)

    anslist = []

    for _ in range(Q):
        query1, query2, query3 = input().split()
        if query1 == "1":
            i = int(query2)
            c = query3
            cap = S[i-1]
            if cap == c:
                continue
            set_dic[cap].remove(i)
            if c not in set_dic:
                set_dic[c] = [i]
            else:
                bisect.insort_left(set_dic[c], i)
            S[i-1] = c
        else:
            l = int(query2)
            r = int(query3)
            ansset = set()
            ans = 0
            for eachlist in set_dic.values():
                li = bisect.bisect_left(eachlist, l)
                ri = bisect.bisect_right(eachlist, r)
                if li != ri:
                    ans += 1
            anslist.append(ans)

    for i in anslist:
        print(i)

if __name__ == '__main__':
    solve()
N, Z, W = map(int, input().split())
A = [int(x) for x in input().split()]

memo = [[None for _ in range(2)] for _ in range(2010)]


def f(i, p, x, y):
    """
    i番目にx, yが手持ちのとき、プレイヤーpが引いたときのスコア
    """
    if i == N:
        return abs(x - y)
    if memo[i][p]:
        return memo[i][p]

    if p == 0:
        score = float('-inf')
        for j in range(i, N):
            score = max(score, f(j + 1, 1, A[j], y))
    else:
        score = float('inf')
        for j in range(i, N):
            score = min(score, f(j + 1, 0, x, A[j]))

    memo[i][p] = score
    return score


print(f(0, 0, Z, W))


### FIXED CODE ###

X, Y = input().split()

if X < Y:
    print('<')
elif X > Y:
    print('>')
else:
    print('=')
r = int(input())

if r > 0 and r < 10000:
    circle_length = (r * 2) * 3.14
    circle_area   = r * r * 3.14 

    print("{0:f} {1:f}".format(circle_area, circle_length))
else:
    pass

### FIXED CODE ###

import math

r = float(input())

if r > 0 and r < 10000:
    circle_length = (r * 2) * math.pi
    circle_area   = r * r * math.pi

    print("{0:f} {1:f}".format(circle_area, circle_length))
else:
    pass
R = int(input())
return R*R

### FIXED CODE ###

R = int(input())
print(R*R)
S = input()
T = input()


ans = [len(T) -1]
for i in range(len(S)):
  if S[i] == T[0]:
    s = 0
    for j in range(1,len(T)):
      if S[i + j] == T[j]:
        pass
      else:
        s += 1
    ans.append(s)

print(min(ans))
    

### FIXED CODE ###

S = input()
T = input()


ans = len(T)
for i in range(len(S) - len(T) + 1):
  s = 0
  for j in range(len(T)):
    if S[i + j] != T[j]:
      s += 1
  ans = min(ans, s)

print(ans)
a,b = map(int, raw_input().split())
d = int(a/b)
r = a%b
float(f) = float(a)/b

print '%d, %d, %f', d, r, f 

### FIXED CODE ###

a, b = map(int, raw_input().split())
d = a/b
r = a%b
f = float(a)/b

print'%d %d %f' % (d ,r ,f)
a = int(iput())
print(' ')
b = int(input())

print(a * b + ' ' + a * 2 + b * 2)



### FIXED CODE ###

a,b = input().split(' ')
x = int(a)
y = int(b)
print(str(x * y) + ' ' + str((x + y) * 2))
s = input()                    
def search(l):
    if l>=len(s):
        return 1
    a = b = c = d = 0
    if s[l:l+5]=="dream":
        a = search(l+5)
    if s[l:l+5]=="erase":
        b = search(l+5)
    if s[l:l+6]=="eraser":
        c = search(l+6) 
    if s[l:l+7]=="dreamer":
        d = search(l+7) 
    return max(a,b,c,d)

if search(0):
    print("YES")
else:
    print("NO")

### FIXED CODE ###

s = input()
s = s.replace('eraser', '')
s = s.replace('erase', '')
s = s.replace('dreamer', '')
s = s.replace('dream', '')
if len(s) == 0:
    print('YES')
else:
    print('NO')
def insertionSort(A,n,g):
	cnt = 0
	for i in range(g,n):
		v = A[i]
		j = i - g
		while j >= 0 and A[j] > v:
			A[j+g] = A[j]
			j = j - g
			cnt += 1
		A[j+g] = v

def shellsort(A,n):
	cnt = 0
	h = 0
	while(h <= n / 9): h = 3*h + 1
	G = []
	while h > 0:
		G.append(h)
		h /= 3
	print(len(G))
    print(" ".join(map(str,G)))
	for i in range(len(G)):
		insertionSort(A,n,G[i])
	for i in A:
		print(i)	
n = int(input())
A = []
for _ in range(n):
	A.append(int(input()))
shellsort(A,n)



### FIXED CODE ###

def insertionSort(A,n,g):
    cnt = 0
    for i in range(g,n):
        v = A[i]
        j = i - g
        while j >= 0 and A[j] > v:
            A[j+g] = A[j]
            j = j - g
            cnt += 1
            A[j+g] = v
    return cnt
    
def shellsort(A,n):
    cnt = 0
    h = 1
    G = []
    while h <= n:
        G.append(h)
        h = 3*h + 1
    G.reverse()
    m = len(G)
    print(m)

    print(" ".join(map(str,G)))
    for i in range(m):
        cnt += insertionSort(A,n,G[i])
    print(cnt)
    for i in A:
        print(i)
        
n = int(input())
A = []
for _ in range(n):
    A.append(int(input()))
shellsort(A,n)
n = int(input())
h = list(map(int,input().split()))
dp=[]
dp.append(0)
dp.append(abs(h[1]-h[0]))
for i in range(3,n):
    dp.append(min(dp[i-2] + abs(h[i]-h[i-2]), dp[i-1] + abs(h[i]-h[i-1])))
print(dp[n-1])

### FIXED CODE ###

n = int(input())
h = list(map(int,input().split()))
dp=[]
dp.append(0)
dp.append(abs(h[1]-h[0]))
for i in range(2,n):
    dp.append(min(dp[i-2] + abs(h[i]-h[i-2]), dp[i-1] + abs(h[i]-h[i-1])))
print(dp[n-1])
N = int(input())
A = list(map(float,input().split(",")))
tmp = 0
for i in range(N):
  tmp = tmp + 1/A[i]
  
print(1/tmp)

### FIXED CODE ###

N = int(input())
A = list(map(float,input().split()))
tmp = 0
for i in range(N):
  tmp = tmp + (1/A[i])
tmp= 1/tmp
print(tmp)
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=sys.stdin.readline
def resolve():
    n=int(input())
    s=input()
    if n==len(set(s)):
        print(0)
        return
    for w in range(2,n): # 幅数
        flag=False
        for i in range(n-w+1):
            if s.count(s[i:i+w])>=2:
                flag=True
        if flag is False:
            break
    print(w-1)
resolve()

### FIXED CODE ###

import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
# input=sys.stdin.readline
def resolve():
    n=int(input())
    s=input()
    dp=[[0]*(n+1) for _ in range(n+1)]
    from itertools import product
    for i,j in product(reversed(range(n)),repeat=2):
        if i>=j: continue # i<j
        if s[i]==s[j]:
            dp[i][j]=dp[i+1][j+1]+1
        else:
            dp[i][j]=0
    ans=0
    for i,j in product(reversed(range(n)),repeat=2):
        if i>=j: continue
        ans=max(ans,min(j-i,dp[i][j]))
    print(ans)


resolve()
a,b,c = map(int, input())

ans = "No"

if (a == b or a== c or b == c) and not (a==b==c): ans = "Yes"
  
print(ans)

### FIXED CODE ###

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

ans = "No"

if (a == b or a== c or b == c) and not (a==b==c): ans = "Yes"
  
print(ans)
n,k = map(int,input().split())	
a = list(map(int,input().split()))

m = sum(a)

w = []
p = 0
q = 0
for i in range(n):
    p += a[i]
    q += a[n-1-i]
    w.append(p)
    w.append(q)
w.sort()

res = m
for i in range(k-1):
    res = res&(m-w[i])    
print(res)

### FIXED CODE ###

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

b = []
for i in range(n):
    r = 0
    for j in range(i,n):
        r += a[j]
        b.append(r)


n2 = n*(n+1)//2

res = 0
for i in range(41):
    p = res + 2**(40-i)
    
    c = 0
    for j in range(n2):
        if p == p&b[j]:
            c+=1
    
    if c >= k:
        res = p

print(res)
import heapq
N, M = list(map(int,input()))
h = []
for x in input().split():
  heappush(h, x)
print(heappop(h))
print(heappop(h))

### FIXED CODE ###

import heapq
N, M = list(map(int,input().split()))
h = []
for x in input().split():
  heapq.heappush(h, -int(x))
for i in range(M):
  x = -heapq.heappop(h)
  x //= 2
  heapq.heappush(h,-x)
print(-sum(h))
N, L, T=map(int, input().split())
XW=[list(map(int, input().split())) for _ in range(N)]
X_=[(XW[i][0]+T)%L if XW[i][1]==1 else (XW[i][0]-T)%L for i in range(N)]
X_.sort()
A0_=(XW[0][0]+T)%L if XW[0][1]==1 else (XW[0][0]-T)%L
P0_=X_.index(A0_)
if P0_>0:
    X_=X_[P0_:]+X_[:P0_]
    
if XW[0][1]==1:
    C0_=round(sum([(T-(XW[i][0]-XW[0][0])/2)//(L/2)+1 if XW[i][1]!=1 and (XW[i][0]-XW[0][0])/2<=T else 0 for i in range(1, N)])%N)
else:
    C0_=round(N-sum([(T-(XW[0][0]+L-XW[i][0])/2)//(L/2)+1 if XW[i][1]!=2 and (XW[0][0]+L-XW[i][0])/2<=T else 0 for i in range(1, N)])%N)
    
if X_[0]==X_[1] and XW[0][1]==1:
  C0_=round((C0_-1)%N)
  
if C0_>0:
  X_=X_[N-C0_:]+X_[:N-C0_]
print(*X_, sep='\n')

### FIXED CODE ###

N, L, T=map(int, input().split())
XW=[list(map(int, input().split())) for _ in range(N)]
X_=[(XW[i][0]+T)%L if XW[i][1]==1 else (XW[i][0]-T)%L for i in range(N)]
X_.sort()
A0_=(XW[0][0]+T)%L if XW[0][1]==1 else (XW[0][0]-T)%L
P0_=X_.index(A0_)
if P0_>0:
    X_=X_[P0_:]+X_[:P0_]
    
if XW[0][1]==1:
    C0_=round(sum([(T-(XW[i][0]-XW[0][0])/2)//(L/2)+1 if XW[i][1]!=1 and (XW[i][0]-XW[0][0])/2<=T else 0 for i in range(1, N)])%N)
else:
    C0_=round(N-sum([(T-(XW[0][0]+L-XW[i][0])/2)//(L/2)+1 if XW[i][1]!=2 and (XW[0][0]+L-XW[i][0])/2<=T else 0 for i in range(1, N)])%N)
    
if N>1 and X_[0]==X_[1] and XW[0][1]==1:
  C0_=round((C0_-1)%N)

if C0_>0:
  X_=X_[N-C0_:]+X_[:N-C0_]

print(*X_, sep='\n')
A,B,N = map(int,input().split())
def floor(x):
  return (x//1)
list = []
for x in range(N+1):
  if x % B != 0:
    list.append(floor((A*x)/B)-(A*floor(x/B)))
print(int(max(list)))

### FIXED CODE ###

A,B,N = map(int,input().split())
def floor(x):
  return int(x//1)
list = []
if N >= B:
    list.append(floor((A*(B-1))/B)-(A*floor((B-1)/B)))
else:
    list.append(floor((A*N)/B)-(A*floor(N/B)))
print(max(list))
A, B = map(int, input().split())

list = [300000,200000,100000,0]

if(A>3):
    A = 4
elif(B>3):
    B = 4

money = list[A-1]+list[B-1]


if(A==1 and B==1):
    money = 1000000

print(money)


### FIXED CODE ###

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

list = [500000,300000,200000,100000,0]

if(A>3):
    A = 4
if(B>3):
    B = 4
elif(A==1 and B==1):
    A=B=0
money = list[A]+list[B]
print(money)
K = input()
print(K*ACL)

### FIXED CODE ###

k = int(input())
print(k*'ACL')
N = int(input())
L = map(int, input().split())

if max(L) < sum(L) - max(L):
    print('Yes')
else:
    print('No')


### FIXED CODE ###

n = int(input())
l = [int(e) for e in input().split()]
if max(l) < sum(l) - max(l):
  print('Yes')
else:
  print('No')
#!/usr/bin/env python3
import sys, math, fractions, itertools, collections, copy, heapq


def solve(H: int, W: int, A: "List[str]"):
    import sys
    import numpy as np
    from scipy.ndimage.morphology import distance_transform_cdt
    INPUT = lambda: sys.stdin.readline().rstrip()
    MAP = lambda: map(int, INPUT().split())
    sys.setrecursionlimit(10 ** 9)

    A = np.array([[(Ai[j] != "#") for j in range(W)] for Ai in A])
    print(distance_transform_cdt(A, metric="taxicab").max())

    return


# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    H = int(next(tokens))  # type: int
    W = int(next(tokens))  # type: int
    A = [ next(tokens) for _ in range(W) ]  # type: "List[str]"
    solve(H, W, A)

if __name__ == '__main__':
    main()


### FIXED CODE ###

#!/usr/bin/env python3
from collections import deque
import copy

def main():
    h, w = map(int, input().split())
    a = [[j == "#" for j in input()] for _ in range(h)]


    # スタート地点をqueueに追加
    que = deque([(i, j) for i in range(h) for j in range(w) if a[i][j]])

    count = 0
    while True:
        count += 1
        nque = deque()
        while que:
            y, x = que.popleft()
            if x > 0 and not a[y][x-1]:
                a[y][x-1] = True
                nque.append((y,x-1))
            if x < w-1 and not a[y][x+1]:
                a[y][x+1] = True
                nque.append((y,x+1))
            if y > 0 and not a[y-1][x]:
                a[y-1][x] = True
                nque.append((y-1,x))
            if y < h-1 and not a[y+1][x]:
                a[y+1][x] = True
                nque.append((y+1,x))

        if nque:
            que = copy.copy(nque)
        else:
            break

    print(count - 1)

if __name__ == '__main__':
    main()
N = int(input())
a = list(map(int, input().split()))
now = 0
ans = 0
for i in range(N):
  if a[i] == now:
    count += 1
  else:
    ans += count//2
    count = 1
    now = a[i]

ans += count//2
print(ans)

### FIXED CODE ###


N = int(input())
a = list(map(int, input().split()))
count = 0
now = 0
ans = 0
for i in range(N):
  if a[i] == now:
    count += 1
  else:
    ans += count//2
    count = 1
    now = a[i]

ans += count//2
print(ans)
# 各々の要素が何番目に何回数えられるかを考える。
import sys

input = sys.stdin.buffer.readline

n = int(input())
C = list(map(int, input().split()))
C.sort(reverse=True)
mod = 10 ** 9 + 7
N = n + 5
bikkuri = [0] * N
bikkuri[0] = 1
gyaku = [0] * N
for i in range(1, N):
    bikkuri[i] = (i * bikkuri[i - 1]) % mod
gyaku[N - 1] = pow(bikkuri[N - 1], mod - 2, mod)
for i in range(N - 1, -1, -1):
    gyaku[i - 1] = (gyaku[i] * i) % mod


def comb(n, r):
    if r < 0 or n - r < 0:
        return 0
    return (bikkuri[n] * gyaku[r] * gyaku[n - r]) % mod


ans = 0
for i in range(n):
    ans += (i + 2) * C[i] * pow(2, n - 2, mod)
    ans %= mod
ans *= pow(2, n, mod)
ans %= mod
print(ans)


### FIXED CODE ###

# 各々の要素が何番目に何回数えられるかを考える。
import sys

input = sys.stdin.buffer.readline

n = int(input())
C = list(map(int, input().split()))
C.sort(reverse=True)
mod = 10 ** 9 + 7
N = n + 5
bikkuri = [0] * N
bikkuri[0] = 1
gyaku = [0] * N
for i in range(1, N):
    bikkuri[i] = (i * bikkuri[i - 1]) % mod
gyaku[N - 1] = pow(bikkuri[N - 1], mod - 2, mod)
for i in range(N - 1, -1, -1):
    gyaku[i - 1] = (gyaku[i] * i) % mod


def comb(n, r):
    if r < 0 or n - r < 0:
        return 0
    return (bikkuri[n] * gyaku[r] * gyaku[n - r]) % mod


ans = 0
for i in range(n):
    ans += (i + 2) * C[i] * pow(2, 2 * n - 2, mod)
    ans %= mod
print(ans)