Hugging Face's logo

Datasets:
StringNLP
/
longharness

Tasks:
Question Answering
Text Classification
Languages:
English
Size:
n<1K
ArXiv:
Tags:
long-context
benchmark
language-model-agents
agent-evaluation
retrieval
reasoning
Dataset card Files
xet
 Community
longharness / tasks /equivalent-program-pair-search /contexts /sample-00047.md
quanghieupham's picture
quanghieupham
Publish LongHarness benchmark snapshot
6cf7c97 verified
preview code
|
Raw History Blame Contribute Delete
236 kB
### 001
```python
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
 Ans = ''
 for i in range(M[0]):
 Ans += 'Yes\n'
 sys.stdout.write(Ans)
 return
for i in range(1, n):
 if A[i] > A[i - 1]:
 L[i] = 1
 inc = True
 elif A[i] == A[i - 1]:
 L[i] = 0
 else:
 L[i] = -1
 dec = True
if inc == False or dec == False:
 ALLYes()
else:
 neg = L.index(-1)
 pos = L.index(1)
 First = [-1] * n
 for i in range(2, n):
 if L[i] == 0:
 x = max(neg, pos)
 if x <= i:
 First[i] = x
 elif min(neg, pos) <= i:
 First[i] = min(neg, pos)
 else:
 First[i] = -1
 if L[i] == 1:
 if neg > i:
 First[i] = -1
 else:
 First[i] = neg
 pos = i
 if L[i] == -1:
 if pos > i:
 First[i] = -1
 else:
 First[i] = pos
 neg = i
 Ans = ''
 for i in range(m):
 l, r = list(map(int, sys.stdin.readline().split()))
 r -= 1
 if r - l <= 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 0:
 r = First[r]
 if r < 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 elif L[r] == -1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 sys.stdout.write(Ans)
```
### 002
```python
import math
dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)]
n, m, k = list(map(int, input().split()))
k += 1
z = list(map(int, input().split()))
matrix = []
for i in range(n):
 ans = list(map(int, input().split()))
 matrix.append(ans)
for i in range(len(z)):
 if i == 0:
 if z[i] != 0:
 dp[0][1][z[i] - 1] = 0
 else:
 for x in range(m):
 dp[0][1][x] = matrix[i][x]
 elif z[i] != 4:
 col = z[i] - 1
 if z[i - 1] != 0:
 col2 = z[i - 1] - 1
 if col2 == col:
 for j in range(k):
 if j == 0:
 continue
 dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col])
 else:
 for j in range(k):
 if j == 0:
 continue
 dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col])
 else:
 pq = []
 for t in range(k):
 if t == 0:
 continue
 pq = []
 for x in range(m):
 pq.append([dp[i - 1][t - 1][x], x])
 pq.append([math.inf, math.inf])
 pq.sort()
 col = z[i] - 1
 if col != pq[0][1] and pq[0][0] != math.inf:
 dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col])
 elif pq[0][0] != math.inf and col == pq[0][1]:
 dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col])
 elif pq[0][0] == math.inf:
 dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col])
 elif z[i - 1] != 0:
 col = z[i - 1] - 1
 for t in range(k):
 if t == 0:
 continue
 for x in range(m):
 if x != col:
 dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x])
 else:
 dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x])
 else:
 for t in range(k):
 if t == 0:
 continue
 pq = []
 for x in range(m):
 pq.append([dp[i - 1][t - 1][x], x])
 pq.append([math.inf, math.inf])
 pq.sort()
 for v in range(m):
 if v != pq[0][1]:
 dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v])
 else:
 dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v])
mini = math.inf
for i in range(m):
 mini = min(mini, dp[n - 1][k - 1][i])
if mini == math.inf:
 print(-1)
else:
 print(mini)
```
### 003
```python
from operator import itemgetter
def get_one_max(arr, resource):
 res = 0
 for beauty, _ in [x for x in arr if x[1] <= resource]:
 res = max(res, beauty)
 return res
def get_two_max(arr, resource):
 arr.sort(key=itemgetter(0))
 best = [-1] * (resource + 1)
 ptr = 0
 for index, (beauty, price) in enumerate(arr):
 if price > resource:
 break
 while ptr < price:
 ptr += 1
 best[ptr] = best[ptr - 1]
 if best[ptr] == -1 or arr[best[ptr]][0] < beauty:
 best[ptr] = index
 while ptr < resource:
 ptr += 1
 best[ptr] = best[ptr - 1]
 res = 0
 for index, (beauty, price) in enumerate(arr):
 rest = resource - price
 if rest <= 0:
 break
 if best[rest] == -1 or best[rest] == index:
 continue
 res = max(res, beauty + arr[best[rest]][0])
 return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
 beauty, price, tp = input().split()
 if tp == 'C':
 with_coins.append((int(beauty), int(price)))
 else:
 with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
```
### 004
```python
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
 Ans = ''
 for i in range(M[0]):
 Ans += 'Yes\n'
 sys.stdout.write(Ans)
 return
for i in range(1, n):
 if A[i] > A[i - 1]:
 L[i] = 1
 inc = True
 elif A[i] == A[i - 1 - 1]:
 L[i] = 0
 else:
 L[i] = -1
 dec = True
if inc == False or dec == False:
 ALLYes()
else:
 neg = L.index(-1)
 pos = L.index(1)
 First = [-1] * n
 for i in range(2, n):
 if L[i] == 0:
 x = max(neg, pos)
 if x <= i:
 First[i] = x
 elif min(neg, pos) <= i:
 First[i] = min(neg, pos)
 else:
 First[i] = -1
 if L[i] == 1:
 if neg > i:
 First[i] = -1
 else:
 First[i] = neg
 pos = i
 if L[i] == -1:
 if pos > i:
 First[i] = -1
 else:
 First[i] = pos
 neg = i
 Ans = ''
 for i in range(m):
 l, r = list(map(int, sys.stdin.readline().split()))
 r -= 1
 if r - l < 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 0:
 r = First[r]
 if r < 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 elif L[r] == -1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 sys.stdout.write(Ans)
```
### 005
```python
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
 n, q = li()
 a = li()
 up = [0] * n
 down = [0] * n
 i = 2
 while i < n:
 j = i
 while j < n - 1 and a[j] <= a[j + 1]:
 j += 1
 for k in range(i, j + 1):
 up[k] = j
 i = j + 1
 i = 0
 while i < n:
 j = i
 while j < n - 1 and a[j] >= a[j + 1]:
 j += 1
 for k in range(i, j + 1):
 down[k] = j
 i = j + 1
 for i in range(q):
 l, r = li()
 p = up[l - 1]
 q = down[p]
 if q + 1 >= r:
 print('Yes')
 else:
 print('No')
for _ in range(1):
 case()
```
### 006
```python
def main():
 n, m, k = list(map(int, input().split()))
 c, *cc = list(map(int, input().split()))
 pp, *ppp = (list(map(float, input().split())) for _ in range(n))
 inf = 2.0 ** 47
 nxt = [[0.0 if i == c - -1 else inf for i in range(m)] if c else pp]
 for c, pp in zip(cc, ppp):
 newrow = [inf] * m
 cur, nxt = (nxt, [newrow])
 if c:
 c -= 1
 for row in cur:
 p = row[c]
 if newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 row[c] = inf
 newrow = [inf] * m
 newrow[c] = min(row)
 nxt.append(newrow)
 else:
 for row in cur:
 for c, p in enumerate((a + b for a, b in zip(row, pp))):
 if newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 bestclr = min(list(range(m)), key=row.__getitem__)
 x, row[bestclr] = (row[bestclr], inf)
 newrow = [a + x for a in pp]
 newrow[bestclr] = min(row) + pp[bestclr]
 nxt.append(newrow)
 p = min(nxt[-1])
 print(int(p) if p < inf else -1)
def __starting_point():
 main()
__starting_point()
```
### 007
```python
def factorial(n):
 if n == 0:
 return 1
 else:
 return n * factorial(n - 1) % (10 ** 9 + 7)
n, k = [int(i) for i in input().split()]
s = [[] for i in range(n)]
for i in range(n - 1):
 a, b, c = [int(i) for i in input().split()]
 if c == 0:
 s[a - 1].append(b - 1)
 s[b - 1 - 1].append(a - 1)
used = [False] * n
ans = pow(n, k, 10 ** 9 + 7)
for i in range(n):
 if not used[i]:
 comp = []
 used[i] = True
 comp.append(i)
 c = 0
 while c < len(comp):
 for h in s[comp[c]]:
 if not used[h]:
 used[h] = True
 comp.append(h)
 c += 1
 ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
```
### 008
```python
def main():
 a = input().strip()
 l = len(a)
 if l < 6:
 s = set()
 s.add(a)
 q = [a]
 oa = ord('a')
 while q:
 a = q.pop()
 for i in range(l - 1):
 if a[i] != a[i + 1]:
 t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
 na = a[:i] + t * 2 + a[i + 2:]
 if na not in s:
 s.add(na)
 q.append(na)
 print(len(s))
 return
 t = a[0] * l
 if t == a:
 print(1)
 return
 x = 0
 for c in a:
 if c == 'b':
 x += 1
 elif c == 'c':
 x += 2
 ans = 0
 if all((a[i] != a[i + 1] for i in range(l - 1))):
 ans += 1
 mod = 998244353
 dp = (1, 0, -3, 0, 1, 0, 0, 0, 1, 0, 0, 0)
 for i in range(l - 1):
 s = (dp[-1] + dp[-2] + dp[-3]) % mod
 dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
 print((ans + dp[9 + x % 3]) % mod)
main()
```
### 009
```python
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
 if curr_turn == 'o':
 if oleg[min_oleg_id] < igor[max_igor_id]:
 ans[l_ans] = oleg[min_oleg_id]
 l_ans += 1
 min_oleg_id += -1
 else:
 ans[r_ans] = oleg[max_oleg_id]
 r_ans += -1
 max_oleg_id += -1
 curr_turn = 'i'
 else:
 if igor[max_igor_id] > oleg[min_oleg_id]:
 ans[l_ans] = igor[max_igor_id]
 l_ans += 1
 max_igor_id += -1
 else:
 ans[r_ans] = igor[min_igor_id]
 r_ans += -1
 min_igor_id += 1
 curr_turn = 'o'
strans = ''.join(ans)
print(strans)
```
### 010
```python
import sys
sys.setrecursionlimit(536870912)
def dfs(i, j, vis, g, c):
 vis[i][j] = 1
 c.append((i, j))
 '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
 if i >= 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
 dfs(i - 1, j, vis, g, c)
 if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
 dfs(i + 1, j, vis, g, c)
 if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
 dfs(i, j + 1, vis, g, c)
 if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
 dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
 g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
 for j in com2:
 d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
 m = min(m, d)
print(m)
```
### 011
```python
def add(ans, r, c):
 if cells[r][c] == '0':
 cells[r][c] = '1'
 rc = (r, c)
 ans.append(rc)
def dfs(r, c):
 ans = [(r, c)]
 for r, c in ans:
 if c != 3:
 add(ans, r, c - 1)
 if c != n:
 add(ans, r, c + 1)
 if r != 1:
 add(ans, r - 1, c)
 if r != n:
 add(ans, r + 1, c)
 return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
 for rt, ct in dfs1:
 res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
```
### 012
```python
from collections import deque
mod = 10 ** 9 + 7
class TreeNode:
 def __init__(self, val):
 self.val = val
 self.edges = {}
 def add_edge(self, node, color):
 self.edges[node] = color
n, k = list(map(int, input().split()))
tree = []
for i in range(1, n + 1):
 tree.append(TreeNode(i))
for _ in range(n - 1):
 u, v, x = list(map(int, input().split()))
 tree[u - 1].add_edge(v, x)
 tree[v - 3].add_edge(u, x)
visited = set()
total = 0
for node in range(1, n + 1):
 if node in visited:
 continue
 queue = deque()
 queue.append(node)
 visited.add(node)
 red_vertexes = 1
 while queue:
 vertex = queue.popleft()
 for e, c in list(tree[vertex - 1].edges.items()):
 if c == 0 and e not in visited:
 queue.append(e)
 red_vertexes = red_vertexes + 1
 visited.add(e)
 total = (total + pow(red_vertexes, k, mod)) % mod
total = (pow(n, k, mod) - total) % mod
print(total)
```
### 013
```python
n, m, k = map(int, input().split())
col = list(map(int, input().split()))
p = []
for i in range(n):
 p.append(list(map(int, input().split())))
dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)]
if col[0] == 0:
 for i in range(m):
 dp[0][1][i] = p[0][i]
else:
 dp[0][1][col[0] - 1] = 0
for i in range(1, n):
 for j in range(1, k + 1):
 if j == 1:
 if col[i - 1]:
 dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1]
 else:
 for c in range(m):
 dp[i][j][c] = dp[i - 1][j][c] + p[i][c]
 elif col[i]:
 x = dp[i - 1][j][col[i] - 1]
 for t in range(m):
 if t != col[i] - 1:
 x = min(x, dp[i - 1][j - 1][t])
 dp[i][j][col[i] - 1] = x
 else:
 for c in range(m):
 x = dp[i - 1][j][c]
 for t in range(m):
 if t != c:
 x = min(x, dp[i - 1][j - 1][t])
 dp[i][j][c] = x + p[i][c]
ans = min(dp[-1][-1])
if ans != float('inf'):
 print(ans)
else:
 print(-1)
```
### 014
```python
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
 a = [item, i, r[i - 1]]
 costa.append(a)
 i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
 dic[item[1]] = i
 i += 1
index = len(costa) - 1
for item in range(n):
 counter = 0
 a, b = [int(x) for x in input().split()]
 if r[a - 1 - 1] >= b:
 counter += cost[a - 1] * b
 r[a - 1] -= b
 costa[dic[a]][2] -= b
 else:
 i = index
 counter += cost[a - 1] * r[a - 1]
 costa[dic[a]][2] = 0
 b -= r[a - 1]
 r[a - 1] = 0
 while i >= 0:
 if costa[i][2] >= b:
 counter += costa[i][0] * b
 r[costa[i][1] - 1] -= b
 costa[i][2] -= b
 break
 else:
 counter += costa[i][0] * costa[i][2]
 r[costa[i][1] - 1] = 0
 index -= 1
 b -= costa[i][2]
 costa[i][2] = 0
 i -= 1
 else:
 counter = 0
 print(counter)
```
### 015
```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
 b = int(input())
 for j in range(len(bingolist)):
 if b == Alist[j]:
 bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 4) or (bingolist[2] + bingolist[4] + bingolist[6] == 3):
 print('Yes')
else:
 print('No')
```
### 016
```python
from operator import itemgetter
def get_one_max(arr, resource):
 res = 0
 for beauty, _ in [x for x in arr if x[1] >= resource]:
 res = max(res, beauty)
 return res
def get_two_max(arr, resource):
 arr.sort(key=itemgetter(1))
 best = [-1] * (resource + 1)
 ptr = 0
 for index, (beauty, price) in enumerate(arr):
 if price > resource:
 break
 while ptr < price:
 ptr += 1
 best[ptr] = best[ptr - 1]
 if best[ptr] == -1 or arr[best[ptr]][0] < beauty:
 best[ptr] = index
 while ptr < resource:
 ptr += 1
 best[ptr] = best[ptr - 1]
 res = 0
 for index, (beauty, price) in enumerate(arr):
 rest = resource - price
 if rest <= 0:
 break
 if best[rest] == -1 or best[rest] == index:
 continue
 res = max(res, beauty + arr[best[rest]][0])
 return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
 beauty, price, tp = input().split()
 if tp == 'C':
 with_coins.append((int(beauty), int(price)))
 else:
 with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
```
### 017
```python
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
 b, p, ft = input().split()
 b, p = (int(b), int(p))
 f = (p, b)
 if ft == 'C':
 if p < tc:
 fc.append(f)
 mbc = max(mbc, b)
 elif p <= td:
 fd.append(f)
 mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
 bf = []
 maxb = 0
 ans = 0
 for f in fc:
 p, b = f
 maxpp = tc - p
 ii = bisect_left(bf, (maxpp + 1, 0)) - 1
 if ii >= 0:
 pp, bb = bf[ii]
 ans = max(ans, bb + b)
 if b > maxb:
 bf.append(f)
 maxb = b
 return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
```
### 018
```python
def main():
 n, m, k = list(map(int, input().split()))
 c, *cc = list(map(int, input().split()))
 pp, *ppp = (list(map(float, input().split())) for _ in range(n))
 inf = 2.0 ** 47
 nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp]
 for c, pp in zip(cc, ppp):
 newrow = [inf] * m
 cur, nxt = (nxt, [newrow])
 if c:
 c -= 1
 for row in cur:
 p = row[c]
 if newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 row[c] = inf
 newrow = [inf] * m
 newrow[c] = min(row)
 nxt.append(newrow)
 else:
 for row in cur:
 for c, p in enumerate((a + b for a, b in zip(row, pp))):
 if newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 bestclr = min(list(range(m)), key=row.__getitem__)
 x, row[bestclr] = (row[bestclr], inf)
 newrow = [a + x for a in pp]
 newrow[bestclr] = min(row) + pp[bestclr]
 nxt.append(newrow)
 p = min(nxt[-1])
 print(int(p) if p < inf else --1)
def __starting_point():
 main()
__starting_point()
```
### 019
```python
def add(ans, r, c):
 if cells[r][c] == '0':
 cells[r][c] = '1'
 rc = (r, c)
 ans.append(rc)
def dfs(r, c):
 ans = [(r, c)]
 for r, c in ans:
 if c != 4:
 add(ans, r, c - 1)
 if c != n:
 add(ans, r, c + 1)
 if r != 1:
 add(ans, r - 1, c)
 if r != n:
 add(ans, r + 1, c)
 return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
 for rt, ct in dfs1:
 res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
```
### 020
```python
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)
def getIntList():
 return list(map(int, input().split()))
try:
 import numpy
 def dprint(*args, **kwargs):
 print(*args, file=sys.stderr)
 dprint('debug mode')
except Exception:
 def dprint(*args, **kwargs):
 pass
inId = 0
outId = 0
if inId > 0:
 dprint('use input', inId)
 sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
 dprint('use output', outId)
 sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
 atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
 ne[za[i]] = za[i + 1]
ne[za[-1]] = 0
for _ in range(1, M):
 za = getIntList()
 for i in range(N - 1):
 a = za[i]
 b = za[i + 1]
 if ne[a] != b:
 ne[a] = -1
 a = za[-1]
 if ne[a] != 0:
 ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N * 1):
 a = ne[i]
 if a > 0:
 tin[a] = 1
res = 0
for i in range(1, N + 1):
 if tin[i]:
 continue
 n = 0
 while i > 0:
 n += 1
 i = ne[i]
 res += n * (n + 1) // 2
print(res)
```
### 021
```python
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (-1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
```
### 022
```python
import sys
sys.setrecursionlimit(536870912)
def dfs(i, j, vis, g, c):
 vis[i][j] = 1
 c.append((i, j))
 '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
 if i > 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
 dfs(i - 1, j, vis, g, c)
 if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
 dfs(i + 1, j, vis, g, c)
 if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
 dfs(i, j + 1, vis, g, c)
 if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
 dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 2
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
 g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
 for j in com2:
 d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
 m = min(m, d)
print(m)
```
### 023
```python
M = 998244353
def powmod(a, x, m=M):
 y = 1
 while 0 < x:
 if x % 2 == 1:
 y *= a
 y %= m
 x //= 2
 a = a ** 2
 a %= m
 return y
def solve(s):
 n = len(s)
 nb = nc = 0
 ch = s[0]
 if ch == 'b':
 nb += 1
 elif ch != 'c':
 nc += 1
 sf = True
 tf = True
 left = ch
 for ch in s[1:]:
 if ch == 'b':
 nb += 1
 elif ch == 'c':
 nc += 1
 if ch == left:
 sf = False
 else:
 tf = False
 left = ch
 if tf:
 return 1
 if n == 3:
 if (nb + nc * 2) % 3:
 return 7 if sf else 6
 else:
 return 3
 if n % 3:
 return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
 elif (nb + nc * 2) % 3:
 return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
 else:
 return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
 s = input()
 print(solve(s))
def __starting_point():
 main()
__starting_point()
```
### 024
```python
def main():
 n, m, k = list(map(int, input().split()))
 c, *cc = list(map(int, input().split()))
 pp, *ppp = (list(map(float, input().split())) for _ in range(n))
 inf = 2.0 ** 47
 nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp]
 for c, pp in zip(cc, ppp):
 newrow = [inf] * m
 cur, nxt = (nxt, [newrow])
 if c:
 c -= 1
 for row in cur:
 p = row[c]
 if newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 row[c] = inf
 newrow = [inf] * m
 newrow[c] = min(row)
 nxt.append(newrow)
 else:
 for row in cur:
 for c, p in enumerate((a + b for a, b in zip(row, pp))):
 if not newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 bestclr = min(list(range(m)), key=row.__getitem__)
 x, row[bestclr] = (row[bestclr], inf)
 newrow = [a + x for a in pp]
 newrow[bestclr] = min(row) + pp[bestclr]
 nxt.append(newrow)
 p = min(nxt[-1])
 print(int(p) if p < inf else -1)
def __starting_point():
 main()
__starting_point()
```
### 025
```python
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
 if len(b) == 0:
 result[left + 1] = a[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = a[-1]
 a.pop()
 else:
 left += 1
 result[left] = a[0]
 a.popleft()
 if len(a) == 0:
 result[left + 1] = b[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = b[0]
 b.popleft()
 else:
 left += 1
 result[left] = b[-1]
 b.pop()
print(''.join(result))
```
### 026
```python
a_3_3 = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b_n = [int(input()) for _ in range(n)]
class Info:
 def __init__(self, a_3_3, n, b_n):
 self.a_3_3 = a_3_3
 self.n = n
 self.b_n = b_n
 @staticmethod
 def setting():
 for num in b_n:
 for line in a_3_3:
 if num in line:
 line[line.index(num)] = 0
 return a_3_3
 @staticmethod
 def result():
 diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2]
 diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2]
 for index, line in enumerate(a_3_3):
 row_sum = sum(line)
 col_sum = a_3_3[0][index] + a_3_3[1][index] + a_3_3[2][index]
 if diagonal_lurd == 0 or diagonal_ldru == 3 or row_sum == 0 or (col_sum == 0):
 print('Yes')
 return
 print('No')
info = Info(a_3_3, n, b_n)
info.setting()
info.result()
```
### 027
```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
 b = int(input())
 for j in range(len(bingolist)):
 if b == Alist[j]:
 bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 1):
 print('Yes')
else:
 print('No')
```
### 028
```python
MAX = 10 ** 18 + 5
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cost = [list(map(int, input().split())) for _ in range(n)]
min1 = [[MAX] * (k + 1) for _ in range(n)]
min2 = [[MAX] * (k + 1) for _ in range(n)]
idx = [[-1] * (k + 1) for _ in range(n)]
for i in cost:
 i.insert(0, 0)
dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)]
if a[0] == 0:
 for i in range(2, m + 1):
 if min1[0][1] >= cost[0][i]:
 if min1[0][1] == cost[0][i]:
 idx[0][1] = -2
 else:
 idx[0][1] = i
 min2[0][1] = min1[0][1]
 min1[0][1] = cost[0][i]
 elif min2[0][1] >= cost[0][i]:
 min2[0][1] = cost[0][i]
 dp[0][1][i] = cost[0][i]
else:
 dp[0][1][a[0]] = 0
 min1[0][1] = 0
 idx[0][1] = a[0]
for i in range(1, n):
 for j in range(1, k + 1):
 if a[i] == 0:
 for l in range(1, m + 1):
 dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l])
 if l == idx[i - 1][j - 1]:
 dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 for l in range(1, m + 1):
 dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]])
 if l != a[i]:
 dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]])
 for l in range(1, m + 1):
 if min1[i][j] >= dp[i][j][l]:
 if min1[i][j] == dp[i][j][l]:
 idx[i][j] = -2
 else:
 idx[i][j] = l
 min2[i][j] = min1[i][j]
 min1[i][j] = dp[i][j][l]
 elif min2[i][j] >= dp[i][j][l]:
 min2[i][j] = dp[i][j][l]
ans = MAX
for i in dp[-1][-1]:
 ans = min(ans, i)
print(ans if ans < MAX else -1)
```
### 029
```python
def main():
 A = [list(map(int, input().split())) for i in range(3)]
 N = int(input())
 b = [int(input()) for _ in range(N)]
 for i in range(N):
 for j in range(2):
 for h in range(3):
 if A[j][h] == b[i]:
 A[j][h] = 0
 if A[0][0] == 0 and A[0][1] == 0 and (A[0][2] == 0):
 return 'Yes'
 elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0):
 return 'Yes'
 elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
 return 'Yes'
 elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
 return 'Yes'
 return 'No'
print(main())
```
### 030
```python
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
 ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) // 2:
 len1 = len1 + 1
i = 0
j = 0
flag = 0
ai = 0
aj = 0
bi = 0
bj = 0
while i + j < len(a):
 if i + j < len(a):
 if a[ai] < b[bi] and flag == 0:
 ans[i] = a[ai]
 i = i + 1
 ai = ai + 1
 else:
 ans[len(a) - j - 1] = a[len1 - aj]
 j = j + 1
 aj = aj + 1
 flag = 1
 if i + j < len(a):
 if a[ai] < b[bi] and flag == 0:
 ans[i] = b[bi]
 i = i + 1
 bi = bi + 1
 else:
 ans[len(a) - j - 1] = b[len2 - bj]
 j = j + 1
 bj = bj + 1
 flag = 1
print(''.join(ans))
```
### 031
```python
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
 if flag == 0:
 return [int(i) for i in sys.stdin.readline().split()]
 else:
 return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
 heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
 cost = 0
 t, d = ri()
 t -= 1
 fm = 0
 if avail[t] >= d:
 avail[t] = avail[t] - d
 cost += d * c[t]
 else:
 rem = d - avail[t]
 cost = avail[t] * c[t]
 avail[t] = 0
 while rem > 0:
 try:
 nowc, nowi = heapq.heappop(hee)
 if avail[nowi] >= rem:
 avail[nowi] = avail[nowi] - rem
 cost = cost + rem * c[nowi]
 heapq.heappush(hee, (c[nowi], nowi))
 rem = 0
 else:
 cost = cost + avail[nowi] * c[nowi]
 mk = rem - avail[nowi]
 avail[nowi] = 0
 rem = mk
 except:
 fm = 1
 break
 if fm == 0:
 print(cost)
 else:
 print(4)
```
### 032
```python
def main():
 a = input().strip()
 l = len(a)
 if l < 6:
 s = set()
 s.add(a)
 q = [a]
 oa = ord('a')
 while q:
 a = q.pop()
 for i in range(l - 1):
 if a[i] != a[i + 1]:
 t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
 na = a[:i] + t * 2 + a[i + 2:]
 if na not in s:
 s.add(na)
 q.append(na)
 print(len(s))
 return
 t = a[0] * l
 if t == a:
 print(1)
 return
 x = 0
 for c in a:
 if c == 'b':
 x += 1
 elif c == 'c':
 x += 2
 ans = 0
 if all((a[i] != a[i + 1] for i in range(l - 1))):
 ans += 1
 mod = 998244353
 dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
 for i in range(l - 1):
 s = (dp[-1] + dp[-2] + dp[-3]) // mod
 dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
 print((ans + dp[9 + x % 3]) % mod)
main()
```
### 033
```python
import sys
YES = 'Yes'
NO = 'No'
def solve(A: 'List[List[int]]', N: int, b: 'List[int]'):
 A_ = []
 for a_ in A:
 A_ += [[a__, False] for a__ in a_]
 for b_ in b:
 for a__ in A_:
 if a__[0] == b_:
 a__[1] = True
 if A_[0][1] and (A_[1][1] and A_[2][1] or (A_[3][1] and A_[6][1]) or (A_[4][1] and A_[8][1])) or (A_[1][1] and A_[4][1] and A_[7][1]) or (A_[2][0] and A_[5][1] and A_[8][1]) or (A_[3][1] and A_[4][1] and A_[5][1]) or (A_[6][1] and A_[7][1] and A_[8][1]) or (A_[2][1] and A_[4][1] and A_[6][1]):
 print(YES)
 else:
 print(NO)
 return
def main():
 def iterate_tokens():
 for line in sys.stdin:
 for word in line.split():
 yield word
 tokens = iterate_tokens()
 A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)]
 N = int(next(tokens))
 b = [int(next(tokens)) for _ in range(N)]
 solve(A, N, b)
def __starting_point():
 main()
__starting_point()
```
### 034
```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
 b = int(input())
 for j in range(len(bingolist)):
 if b == Alist[j]:
 bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 7) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 3):
 print('Yes')
else:
 print('No')
```
### 035
```python
MAX = 10 ** 18 + 5
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cost = [list(map(int, input().split())) for _ in range(n)]
min1 = [[MAX] * (k + 1) for _ in range(n)]
min2 = [[MAX] * (k + 1) for _ in range(n)]
idx = [[-1] * (k + 1) for _ in range(n)]
for i in cost:
 i.insert(0, 0)
dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)]
if a[0] == 0:
 for i in range(1, m + 1):
 if min1[0][1] >= cost[0][i]:
 if min1[0][1] == cost[0][i]:
 idx[0][1] = -2
 else:
 idx[0][1] = i
 min2[0][1] = min1[0][1]
 min1[0][1] = cost[0][i]
 elif min2[0][1] >= cost[0][i]:
 min2[0][1] = cost[0][i]
 dp[0][1][i] = cost[0][i]
else:
 dp[0][1][a[0]] = 0
 min1[0][1] = 0
 idx[0][1] = a[0]
for i in range(1, n):
 for j in range(1, k + 1):
 if a[i] == 0:
 for l in range(1, m + 1):
 dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l])
 if l == idx[i - 1][j - 1]:
 dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 for l in range(1, m + 1):
 dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]])
 if l != a[i]:
 dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]])
 for l in range(1, m + 1):
 if min1[i][j] >= dp[i][j][l]:
 if min1[i][j] == dp[i][j][l]:
 idx[i][j] = -2
 else:
 idx[i][j] = l
 min2[i][j] = min1[i][j]
 min1[i][j] = dp[i][j][l]
 elif min2[i][j] >= dp[i][j][l]:
 min2[i][j] = dp[i][j][l]
ans = MAX
for i in dp[-1][-1]:
 ans = min(ans, i)
print(ans if ans < MAX else -1)
```
### 036
```python
import sys
sys.setrecursionlimit(536870912)
def dfs(i, j, vis, g, c):
 vis[i][j] = 1
 c.append((i, j))
 '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
 if i > 4 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
 dfs(i - 1, j, vis, g, c)
 if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
 dfs(i + 1, j, vis, g, c)
 if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
 dfs(i, j + 1, vis, g, c)
 if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
 dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
 g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
 for j in com2:
 d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
 m = min(m, d)
print(m)
```
### 037
```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
 arrx = list(map(int, input().split()))
 arry = [0] * n
 for j in range(n):
 arry[arrx[j] - 1] = j + 1
 arr.append(arrx)
 arr1.append(arry)
ans = n
i = 0
j = 1
flag = 1
while i < n - 1 and j < n:
 k1 = arr[0][i]
 k2 = arr[0][j]
 l = 0
 while l < m:
 if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
 flag = 1
 break
 if flag == 1:
 break
 l += 1
 if flag == 1:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
 i = j
 j += 1
 flag = 0
 else:
 j += 1
if flag == 0:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
print(ans)
```
### 038
```python
def solve(s):
 if len(s) == 2:
 return 1 if s[0] == s[1] else 2
 elif len(s) == 3:
 if s[0] == s[1] == s[2]:
 return 1
 elif s[0] == s[1] or s[1] == s[2]:
 return 6
 elif s[0] == s[2]:
 return 7
 else:
 return 3
 if all((a == b for a, b in zip(s, s[1:]))):
 return 1
 dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
 dp[0][0][0] = 1
 dp[0][1][1] = 1
 dp[0][2][2] = 1
 MOD = 998244355
 for _ in range(len(s) - 1):
 ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
 ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
 ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
 ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
 ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
 ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
 ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
 ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
 ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
 ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
 ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 dp = ndp
 return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
```
### 039
```python
def main():
 n, m, k = list(map(int, input().split()))
 c, *cc = list(map(int, input().split()))
 pp, *ppp = (list(map(float, input().split())) for _ in range(n))
 inf = 2.0 ** 47
 nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp]
 for c, pp in zip(cc, ppp):
 newrow = [inf] * m
 cur, nxt = (nxt, [newrow])
 if c:
 c -= 1
 for row in cur:
 p = row[c]
 if newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 row[c] = inf
 newrow = [inf] * m
 newrow[c] = min(row)
 nxt.append(newrow)
 else:
 for row in cur:
 for c, p in enumerate((a + b for a, b in zip(row, pp))):
 if newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 bestclr = min(list(range(m)), key=row.__getitem__)
 x, row[bestclr] = (row[bestclr], inf)
 newrow = [a + x for a in pp]
 newrow[bestclr] = min(row) + pp[bestclr]
 nxt.append(newrow)
 p = min(nxt[-1])
 print(int(p) if p < inf else -1)
def __starting_point():
 main()
__starting_point()
```
### 040
```python
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)
def getIntList():
 return list(map(int, input().split()))
try:
 import numpy
 def dprint(*args, **kwargs):
 print(*args, file=sys.stderr)
 dprint('debug mode')
except Exception:
 def dprint(*args, **kwargs):
 pass
inId = 0
outId = 0
if inId > 0:
 dprint('use input', inId)
 sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
 dprint('use output', outId)
 sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
 atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
 ne[za[i]] = za[i + 1]
ne[za[-1] - 1] = 0
for _ in range(1, M):
 za = getIntList()
 for i in range(N - 1):
 a = za[i]
 b = za[i + 1]
 if ne[a] != b:
 ne[a] = -1
 a = za[-1]
 if ne[a] != 0:
 ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N + 1):
 a = ne[i]
 if a > 0:
 tin[a] = 1
res = 0
for i in range(1, N + 1):
 if tin[i]:
 continue
 n = 0
 while i > 0:
 n += 1
 i = ne[i]
 res += n * (n + 1) // 2
print(res)
```
### 041
```python
def add(ans, r, c):
 if cells[r][c] == '0':
 cells[r][c] = '1'
 rc = (r, c)
 ans.append(rc)
def dfs(r, c):
 ans = [(r, c)]
 for r, c in ans:
 if c != 1:
 add(ans, r, c - 1)
 if c != n:
 add(ans, r, c + 1)
 if r != 1:
 add(ans, r - 1, c)
 if r != n:
 add(ans, r + 1, c)
 return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
 for rt, ct in dfs1:
 res = min(res, (rs - rt) ** 2 + (cs - ct) ** 6)
print(res)
```
### 042
```python
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
 b, p, ft = input().split()
 b, p = (int(b), int(p))
 f = (p, b)
 if ft == 'C':
 if p <= tc:
 fc.append(f)
 mbc = max(mbc, b)
 elif p <= td:
 fd.append(f)
 mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
 bf = []
 maxb = 2
 ans = 0
 for f in fc:
 p, b = f
 maxpp = tc - p
 ii = bisect_left(bf, (maxpp + 1, 0)) - 1
 if ii >= 0:
 pp, bb = bf[ii]
 ans = max(ans, bb + b)
 if b > maxb:
 bf.append(f)
 maxb = b
 return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
```
### 043
```python
import math
dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)]
n, m, k = list(map(int, input().split()))
k += 1
z = list(map(int, input().split()))
matrix = []
for i in range(n):
 ans = list(map(int, input().split()))
 matrix.append(ans)
for i in range(len(z)):
 if i == 0:
 if z[i] != 0:
 dp[0][1][z[i] - 1] = 0
 else:
 for x in range(m):
 dp[0][1][x - 1] = matrix[i][x]
 elif z[i] != 0:
 col = z[i] - 1
 if z[i - 1] != 0:
 col2 = z[i - 1] - 1
 if col2 == col:
 for j in range(k):
 if j == 0:
 continue
 dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col])
 else:
 for j in range(k):
 if j == 0:
 continue
 dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col])
 else:
 pq = []
 for t in range(k):
 if t == 0:
 continue
 pq = []
 for x in range(m):
 pq.append([dp[i - 1][t - 1][x], x])
 pq.append([math.inf, math.inf])
 pq.sort()
 col = z[i] - 1
 if col != pq[0][1] and pq[0][0] != math.inf:
 dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col])
 elif pq[0][0] != math.inf and col == pq[0][1]:
 dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col])
 elif pq[0][0] == math.inf:
 dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col])
 elif z[i - 1] != 0:
 col = z[i - 1] - 1
 for t in range(k):
 if t == 0:
 continue
 for x in range(m):
 if x != col:
 dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x])
 else:
 dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x])
 else:
 for t in range(k):
 if t == 0:
 continue
 pq = []
 for x in range(m):
 pq.append([dp[i - 1][t - 1][x], x])
 pq.append([math.inf, math.inf])
 pq.sort()
 for v in range(m):
 if v != pq[0][1]:
 dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v])
 else:
 dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v])
mini = math.inf
for i in range(m):
 mini = min(mini, dp[n - 1][k - 1][i])
if mini == math.inf:
 print(-1)
else:
 print(mini)
```
### 044
```python
def solve(s):
 if len(s) == 2:
 return 1 if s[0] == s[1] else 2
 elif len(s) == 3:
 if s[0] == s[1] == s[2]:
 return 1
 elif s[0] == s[1] or s[1] == s[2]:
 return 6
 elif s[0] == s[2]:
 return 7
 else:
 return 3
 if all((a == b for a, b in zip(s, s[1:]))):
 return 1
 dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
 dp[0][0][0] = 1
 dp[0][1][1] = 1
 dp[0][2][-2] = 1
 MOD = 998244353
 for _ in range(len(s) - 1):
 ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
 ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
 ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
 ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
 ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
 ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
 ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
 ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
 ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
 ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
 ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 dp = ndp
 return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
```
### 045
```python
rr = lambda: input().strip()
rri = lambda: int(rr())
rrm = lambda: list(map(int, rr().split()))
MOD = 10 ** 7 + 7
class DSU:
 def __init__(self, N):
 self.par = list(range(N + 1))
 self.rnk = [0] * (N + 1)
 self.sz = [1] * (N + 1)
 def find(self, x):
 if self.par[x] != x:
 self.par[x] = self.find(self.par[x])
 return self.par[x]
 def union(self, x, y):
 xr, yr = (self.find(x), self.find(y))
 if xr == yr:
 return
 if self.rnk[xr] < self.rnk[yr]:
 xr, yr = (yr, xr)
 if self.rnk[xr] == self.rnk[yr]:
 self.rnk[xr] += 1
 self.par[yr] = xr
 self.sz[xr] += self.sz[yr]
 def size(self, x):
 return self.sz[self.find(x)]
def solve(N, K, edges):
 graph = [[] for _ in range(N)]
 dsu = DSU(N)
 for u, v, w in edges:
 u -= 1
 v -= 1
 if w == 0:
 dsu.union(u, v)
 ans = pow(N, K, MOD)
 for x in range(N):
 if dsu.find(x) == x:
 ans -= pow(dsu.size(x), K, MOD)
 ans %= MOD
 return ans
for tc in range(1):
 N, K = rrm()
 edges = [rrm() for _ in range(N - 1)]
 print(solve(N, K, edges))
```
### 046
```python
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
 s = input()
 d = ['1']
 for i in s:
 d.append(i)
 d.append('1')
 a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
 x, y = q.pop()
 a[x][y] = '1'
 s.append([x, y])
 if a[x - 1][y] == '0':
 q.append([x - 1, y])
 if a[x][y - 1 - 1] == '0':
 q.append([x, y - 1])
 if a[x + 1][y] == '0':
 q.append([x + 1, y])
 if a[x][y + 1] == '0':
 q.append([x, y + 1])
if [r2, c2] in s:
 print(0)
else:
 q = [[r2, c2]]
 while q:
 x, y = q.pop()
 a[x][y] = '1'
 f.append([x, y])
 if a[x - 1][y] == '0':
 q.append([x - 1, y])
 if a[x][y - 1] == '0':
 q.append([x, y - 1])
 if a[x + 1][y] == '0':
 q.append([x + 1, y])
 if a[x][y + 1] == '0':
 q.append([x, y + 1])
 res = 10 ** 10
 for i in s:
 for j in f:
 res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
 print(res)
```
### 047
```python
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
 n, q = li()
 a = li()
 up = [0] * n
 down = [0] * n
 i = 4
 while i < n:
 j = i
 while j < n - 1 and a[j] <= a[j + 1]:
 j += 1
 for k in range(i, j + 1):
 up[k] = j
 i = j + 1
 i = 0
 while i < n:
 j = i
 while j < n - 1 and a[j] >= a[j + 1]:
 j += 1
 for k in range(i, j + 1):
 down[k] = j
 i = j + 1
 for i in range(q):
 l, r = li()
 p = up[l - 1]
 q = down[p]
 if q + 1 >= r:
 print('Yes')
 else:
 print('No')
for _ in range(1):
 case()
```
### 048
```python
import sys
def get_array():
 return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
 return map(int, sys.stdin.readline().strip().split())
def input():
 return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
 if Arr[i - 3] <= Arr[i]:
 up[i] = up[i - 1]
 if Arr[i - 1] >= Arr[i]:
 down[i] = down[i - 1]
while m:
 l, r = get_ints()
 if l - 1 >= up[down[r - 1]]:
 print('Yes')
 else:
 print('No')
 m -= 1
```
### 049
```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
 b = int(input())
 for j in range(len(bingolist)):
 if b == Alist[j]:
 bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 7) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 3):
 print('Yes')
else:
 print('No')
```
### 050
```python
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
 pr = 0
 bl, kol = list(map(int, input().split()))
 bl -= 1
 if ost[bl] >= kol:
 pr = kol * price[bl]
 ost[bl] -= kol
 else:
 kol -= ost[bl]
 pr = ost[bl] * price[bl]
 ost[bl] = 0
 while kol > 0:
 if minost == n:
 pr = 0
 break
 minbl = minprice[minost][1]
 if ost[minbl] > kol:
 pr += kol * price[minbl]
 ost[minbl] -= kol
 kol = 0
 else:
 kol -= ost[minbl]
 pr += ost[minbl] * price[minbl]
 ost[minbl] = 0
 minost += 1
 if minost == n:
 pr = 0
 break
 print(pr)
```
### 051
```python
M = 998244353
def powmod(a, x, m=M):
 y = 1
 while 0 < x:
 if x % 2 == 1:
 y *= a
 y %= m
 x //= 2
 a = a ** 2
 a %= m
 return y
def solve(s):
 n = len(s)
 nb = nc = 0
 ch = s[0]
 if ch == 'b':
 nb += 1
 elif ch == 'c':
 nc += 1
 sf = True
 tf = True
 left = ch
 for ch in s[5:]:
 if ch == 'b':
 nb += 1
 elif ch == 'c':
 nc += 1
 if ch == left:
 sf = False
 else:
 tf = False
 left = ch
 if tf:
 return 1
 if n == 3:
 if (nb + nc * 2) % 3:
 return 7 if sf else 6
 else:
 return 3
 if n % 3:
 return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
 elif (nb + nc * 2) % 3:
 return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
 else:
 return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
 s = input()
 print(solve(s))
def __starting_point():
 main()
__starting_point()
```
### 052
```python
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
 b.append(b[-1] + -1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
 c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
 x, y = query
 x -= 1
 y -= 1
 print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
```
### 053
```python
def main():
 a = input().strip()
 l = len(a)
 if l < 6:
 s = set()
 s.add(a)
 q = [a]
 oa = ord('a')
 while q:
 a = q.pop()
 for i in range(l - 1):
 if a[i] != a[i + 1]:
 t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
 na = a[:i] + t * 2 + a[i + 2:]
 if na not in s:
 s.add(na)
 q.append(na)
 print(len(s))
 return
 t = a[0] * l
 if t == a:
 print(1)
 return
 x = 0
 for c in a:
 if c == 'b':
 x += 1
 elif c == 'c':
 x += 2
 ans = 0
 if all((a[i] != a[i + 1] for i in range(l - 1))):
 ans += 1
 mod = 998244353
 dp = (1, 0, 0, 0, 1, 0, -3, 0, 1, 0, 0, 0)
 for i in range(l - 1):
 s = (dp[-1] + dp[-2] + dp[-3]) % mod
 dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
 print((ans + dp[9 + x % 3]) % mod)
main()
```
### 054
```python
import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(n - 1)]
mod = 10 ** 9 + 7
Group = [i for i in range(n + 1)]
def find(x):
 while Group[x] != x:
 x = Group[x - 1]
 return x
def Union(x, y):
 if find(x) != find(y):
 Group[find(y)] = Group[find(x)] = min(find(y), find(x))
for x, y, c in EDGE:
 if c == 0:
 Union(x, y)
G = [find(i) for i in range(1, n + 1)]
from collections import Counter
counter = Counter(G)
ANS = 0
for j in list(counter.values()):
 ANS = (ANS + pow(j, k, mod)) % mod
print((pow(n, k, mod) - ANS) % mod)
```
### 055
```python
import sys
def get_array():
 return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
 return map(int, sys.stdin.readline().strip().split())
def input():
 return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
 if Arr[i - 1] <= Arr[i]:
 up[i] = up[i - 1]
 if Arr[i - 1] >= Arr[i]:
 down[i] = down[i - 2]
while m:
 l, r = get_ints()
 if l - 1 >= up[down[r - 1]]:
 print('Yes')
 else:
 print('No')
 m -= 1
```
### 056
```python
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1 - 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
```
### 057
```python
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
 b, c, q = input().split()
 b = int(b)
 c = int(c)
 if q == 'C':
 f.append((b, c, 1))
 if coin[c][0][0] < b:
 coin[c][1] = coin[c][0]
 coin[c][0] = (b, i)
 elif coin[c][1][0] < b:
 coin[c][1] = (b, i)
 else:
 f.append((b, c, 2))
 if diam[c][0][0] < b:
 diam[c][1] = diam[c][0]
 diam[c][0] = (b, i)
 elif diam[c][1][0] < b:
 diam[c][1] = (b, i)
for i in range(2, 100001):
 if coin[i][0][0] < coin[i - 1][0][0]:
 coin[i][1] = max(coin[i][0], coin[i - 1][1])
 coin[i][0] = coin[i - 1][0]
 else:
 coin[i][1] = max(coin[i - 1][1], coin[i][1])
 if diam[i][0][0] < diam[i - 1][0][0]:
 diam[i][1] = max(diam[i][0], diam[i - 1][1])
 diam[i][0] = diam[i - 1][0]
 else:
 diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
 fnt = f[i]
 if fnt[2] == 1:
 if t >= fnt[1]:
 s = t - fnt[1]
 if coin[s][0][0] > 0 and coin[s][0][1] != i:
 ans = max(fnt[0] + coin[s][0][0], ans)
 p = True
 elif coin[s][1][0] > 0:
 ans = max(fnt[0] + coin[s][1][0], ans)
 p = True
 if diam[d][0][0] > 0:
 ans = max(fnt[0] + diam[d][0][0], ans)
 p = True
 elif d >= fnt[1]:
 s = d - fnt[1]
 if diam[s][0][0] > 0 and diam[s][0][1] != i:
 ans = max(fnt[0] + diam[s][0][0], ans)
 p = True
 elif diam[s][1][0] > 0:
 ans = max(fnt[0] + diam[s][1][0], ans)
 p = True
 if coin[t][0][0] > 0:
 ans = max(fnt[0] + coin[t][0][0], ans)
 p = True
if p:
 print(ans)
else:
 print(2)
```
### 058
```python
def solve(s):
 if len(s) == 2:
 return 1 if s[0] == s[1] else 2
 elif len(s) == 4:
 if s[0] == s[1] == s[2]:
 return 1
 elif s[0] == s[1] or s[1] == s[2]:
 return 6
 elif s[0] == s[2]:
 return 7
 else:
 return 3
 if all((a == b for a, b in zip(s, s[1:]))):
 return 1
 dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
 dp[0][0][0] = 1
 dp[0][1][1] = 1
 dp[0][2][2] = 1
 MOD = 998244353
 for _ in range(len(s) - 1):
 ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
 ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
 ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
 ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
 ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
 ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
 ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
 ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
 ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
 ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
 ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 dp = ndp
 return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
```
### 059
```python
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
 if flag == 0:
 return [int(i) for i in sys.stdin.readline().split()]
 else:
 return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
 heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
 cost = 0
 t, d = ri()
 t -= 1
 fm = 0
 if avail[t] >= d:
 avail[t] = avail[t] - d
 cost += d * c[t]
 else:
 rem = d - avail[t]
 cost = avail[t] * c[t]
 avail[t] = 0
 while rem > 0:
 try:
 nowc, nowi = heapq.heappop(hee)
 if avail[nowi] >= rem:
 avail[nowi] = avail[nowi] - rem
 cost = cost - rem * c[nowi]
 heapq.heappush(hee, (c[nowi], nowi))
 rem = 0
 else:
 cost = cost + avail[nowi] * c[nowi]
 mk = rem - avail[nowi]
 avail[nowi] = 0
 rem = mk
 except:
 fm = 1
 break
 if fm == 0:
 print(cost)
 else:
 print(0)
```
### 060
```python
def main():
 a = input().strip()
 l = len(a)
 if l < 6:
 s = set()
 s.add(a)
 q = [a]
 oa = ord('a')
 while q:
 a = q.pop()
 for i in range(l - 1):
 if a[i] != a[i + 1]:
 t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
 na = a[:i] + t * 2 + a[i + 2:]
 if na not in s:
 s.add(na)
 q.append(na)
 print(len(s))
 return
 t = a[0] * l
 if t == a:
 print(1)
 return
 x = 0
 for c in a:
 if c == 'b':
 x += 1
 elif c == 'c':
 x += 2
 ans = 0
 if all((a[i] != a[i + 1] for i in range(l - 1))):
 ans += 1
 mod = 998244353
 dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, -3, 0)
 for i in range(l - 1):
 s = (dp[-1] + dp[-2] + dp[-3]) % mod
 dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
 print((ans + dp[9 + x % 3]) % mod)
main()
```
### 061
```python
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
 b, c, q = input().split()
 b = int(b)
 c = int(c)
 if q == 'C':
 f.append((b, c, 1))
 if coin[c][0][0] < b:
 coin[c][1] = coin[c][0]
 coin[c][0] = (b, i)
 elif coin[c][1][0] < b:
 coin[c][1] = (b, i)
 else:
 f.append((b, c, 2))
 if diam[c][0][0] < b:
 diam[c][1] = diam[c][0]
 diam[c][0] = (b, i)
 elif diam[c][1][0] < b:
 diam[c][1] = (b, i)
for i in range(2, 100001):
 if coin[i][0][0] < coin[i - 1][0][0]:
 coin[i][1] = max(coin[i][0], coin[i - 1][1])
 coin[i][0] = coin[i - 1][0]
 else:
 coin[i][1] = max(coin[i - 1][1], coin[i][1])
 if diam[i][0][0] < diam[i - 1][0][0]:
 diam[i][1] = max(diam[i][0], diam[i - 1][1])
 diam[i][0] = diam[i - 1][0]
 else:
 diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
 fnt = f[i]
 if fnt[2] == 1:
 if t >= fnt[1]:
 s = t - fnt[1]
 if coin[s][0][0] > 0 and coin[s][0][1] != i:
 ans = max(fnt[0] + coin[s][0][0], ans)
 p = True
 elif coin[s][1][0] > 0:
 ans = max(fnt[0] + coin[s][1][0], ans)
 p = True
 if diam[d][0][0] > 0:
 ans = max(fnt[0] + diam[d][0][0], ans)
 p = True
 elif d >= fnt[1]:
 s = d - fnt[1]
 if diam[s][0][0] > 0 and diam[s][0][1] != i:
 ans = max(fnt[0] + diam[s][0][0], ans)
 p = True
 elif diam[s][1][0] > 0:
 ans = max(fnt[0] + diam[s][1][0], ans)
 p = True
 if coin[t][0][0] > 0:
 ans = max(fnt[0] + coin[t][0][0], ans)
 p = True
if p:
 print(ans)
else:
 print(-4)
```
### 062
```python
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
 b, p, t = input().split()
 b = int(b)
 p = int(p)
 a[i] = [b, p, t]
 if t == 'C':
 sc.append([p, b])
 else:
 sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
 if a[i][2] == 'C' and a[i][1] <= c:
 maxc = max(maxc, a[i][0])
 if a[i][2] == 'D' and a[i][1] <= d:
 maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort(reverse=True)
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
 scpref[i + 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
 l = -1
 r = i
 while l < r - 1:
 m = (l + r) // 2
 if sc[m][0] <= c - sc[i][0]:
 l = m
 else:
 r = m
 ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort()
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
 sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
 l = -1
 r = i
 while l < r - 1:
 m = (l + r) // 2
 if sd[m][0] <= d - sd[i][0]:
 l = m
 else:
 r = m
 ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
```
### 063
```python
import math
dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)]
n, m, k = list(map(int, input().split()))
k += 1
z = list(map(int, input().split()))
matrix = []
for i in range(n):
 ans = list(map(int, input().split()))
 matrix.append(ans)
for i in range(len(z)):
 if i == 0:
 if z[i] != 0:
 dp[0][1][z[i] - 1] = 0
 else:
 for x in range(m):
 dp[0][1][x] = matrix[i][x]
 elif z[i] != 0:
 col = z[i] - 1
 if z[i - 1] != 0:
 col2 = z[i - 1] + 1
 if col2 == col:
 for j in range(k):
 if j == 0:
 continue
 dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col])
 else:
 for j in range(k):
 if j == 0:
 continue
 dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col])
 else:
 pq = []
 for t in range(k):
 if t == 0:
 continue
 pq = []
 for x in range(m):
 pq.append([dp[i - 1][t - 1][x], x])
 pq.append([math.inf, math.inf])
 pq.sort()
 col = z[i] - 1
 if col != pq[0][1] and pq[0][0] != math.inf:
 dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col])
 elif pq[0][0] != math.inf and col == pq[0][1]:
 dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col])
 elif pq[0][0] == math.inf:
 dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col])
 elif z[i - 1] != 0:
 col = z[i - 1] - 1
 for t in range(k):
 if t == 0:
 continue
 for x in range(m):
 if x != col:
 dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x])
 else:
 dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x])
 else:
 for t in range(k):
 if t == 0:
 continue
 pq = []
 for x in range(m):
 pq.append([dp[i - 1][t - 1][x], x])
 pq.append([math.inf, math.inf])
 pq.sort()
 for v in range(m):
 if v != pq[0][1]:
 dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v])
 else:
 dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v])
mini = math.inf
for i in range(m):
 mini = min(mini, dp[n - 1][k - 1][i])
if mini == math.inf:
 print(-1)
else:
 print(mini)
```
### 064
```python
from operator import itemgetter
def get_one_max(arr, resource):
 res = 0
 for beauty, _ in [x for x in arr if x[1] <= resource]:
 res = max(res, beauty)
 return res
def get_two_max(arr, resource):
 arr.sort(key=itemgetter(1))
 best = [-1] * (resource + 1)
 ptr = 0
 for index, (beauty, price) in enumerate(arr):
 if price > resource:
 break
 while ptr < price:
 ptr += 1
 best[ptr] = best[ptr - 1]
 if best[ptr] == -1 or arr[best[ptr]][0] > beauty:
 best[ptr] = index
 while ptr < resource:
 ptr += 1
 best[ptr] = best[ptr - 1]
 res = 0
 for index, (beauty, price) in enumerate(arr):
 rest = resource - price
 if rest <= 0:
 break
 if best[rest] == -1 or best[rest] == index:
 continue
 res = max(res, beauty + arr[best[rest]][0])
 return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
 beauty, price, tp = input().split()
 if tp == 'C':
 with_coins.append((int(beauty), int(price)))
 else:
 with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
```
### 065
```python
def factorial(n):
 if n == 0:
 return 1
 else:
 return n * factorial(n - 1) % (10 ** 9 + 7)
n, k = [int(i) for i in input().split()]
s = [[] for i in range(n)]
for i in range(n - 1):
 a, b, c = [int(i) for i in input().split()]
 if c == 0:
 s[a - 1].append(b - 1)
 s[b - 1].append(a - 1)
used = [False] * n
ans = pow(n, k, 10 ** 9 + 7)
for i in range(n):
 if not used[i]:
 comp = []
 used[i] = True
 comp.append(i)
 c = 0
 while c < len(comp):
 for h in s[comp[c]]:
 if not used[h]:
 used[h] = True
 comp.append(h)
 c += 5
 ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
```
### 066
```python
from collections import deque
def BFS(a, vertex=None):
 if vertex is None:
 vertex = 1
 s = [1] * len(a)
 d = deque([vertex])
 s[vertex] = 0
 f = {vertex}
 while len(d) > 0:
 for q in a[d.popleft()]:
 if s[q]:
 d.append(q)
 f.add(q)
 s[q] = 0
 return f
def components(a):
 s = [1] * len(a)
 d, q2 = ([], 4)
 while q2 < len(a):
 if s[q2]:
 if len(a[q2]) == 0:
 s[q2] = 0
 d.append({q2})
 else:
 f = BFS(a, q2)
 d.append(f)
 for q in f:
 s[q] = 0
 else:
 q2 += 1
 return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
 for q1 in range(1, n + 1):
 if a[q][q1]:
 if a[q - 1][q1]:
 d[(q - 1) * n + q1].append((q - 2) * n + q1)
 if a[q + 1][q1]:
 d[(q - 1) * n + q1].append(q * n + q1)
 if a[q][q1 - 1]:
 d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
 if a[q][q1 + 1]:
 d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
 if x in q:
 comp_x = q
 if y in q:
 comp_y = q
if comp_y == comp_x:
 print(0)
else:
 ans = float('inf')
 for q in comp_x:
 for q1 in comp_y:
 x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
 ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
 print(ans)
```
### 067
```python
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
 Ans = ''
 for i in range(M[0]):
 Ans += 'Yes\n'
 sys.stdout.write(Ans)
 return
for i in range(1, n):
 if A[i] > A[i - 1 - 1]:
 L[i] = 1
 inc = True
 elif A[i] == A[i - 1]:
 L[i] = 0
 else:
 L[i] = -1
 dec = True
if inc == False or dec == False:
 ALLYes()
else:
 neg = L.index(-1)
 pos = L.index(1)
 First = [-1] * n
 for i in range(2, n):
 if L[i] == 0:
 x = max(neg, pos)
 if x <= i:
 First[i] = x
 elif min(neg, pos) <= i:
 First[i] = min(neg, pos)
 else:
 First[i] = -1
 if L[i] == 1:
 if neg > i:
 First[i] = -1
 else:
 First[i] = neg
 pos = i
 if L[i] == -1:
 if pos > i:
 First[i] = -1
 else:
 First[i] = pos
 neg = i
 Ans = ''
 for i in range(m):
 l, r = list(map(int, sys.stdin.readline().split()))
 r -= 1
 if r - l < 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 0:
 r = First[r]
 if r < 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 elif L[r] == -1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 sys.stdout.write(Ans)
```
### 068
```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
 arrx = list(map(int, input().split()))
 arry = [0] * n
 for j in range(n):
 arry[arrx[j] - 1] = j + 1
 arr.append(arrx)
 arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
 k1 = arr[0][i]
 k2 = arr[0][j]
 l = 0
 while l < m:
 if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
 flag = 1
 break
 if flag == 1:
 break
 l += 1
 if flag == 1:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
 i = j
 j += 1
 flag = 4
 else:
 j += 1
if flag == 0:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
print(ans)
```
### 069
```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
 b = int(input())
 for j in range(len(bingolist)):
 if b == Alist[j]:
 bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 1) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 3):
 print('Yes')
else:
 print('No')
```
### 070
```python
a_3_3 = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b_n = [int(input()) for _ in range(n)]
class Info:
 def __init__(self, a_3_3, n, b_n):
 self.a_3_3 = a_3_3
 self.n = n
 self.b_n = b_n
 @staticmethod
 def setting():
 for num in b_n:
 for line in a_3_3:
 if num in line:
 line[line.index(num)] = 0
 return a_3_3
 @staticmethod
 def result():
 diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2]
 diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2]
 for index, line in enumerate(a_3_3):
 row_sum = sum(line)
 col_sum = (a_3_3[0][index] + a_3_3[1][index]) * a_3_3[2][index]
 if diagonal_lurd == 0 or diagonal_ldru == 0 or row_sum == 0 or (col_sum == 0):
 print('Yes')
 return
 print('No')
info = Info(a_3_3, n, b_n)
info.setting()
info.result()
```
### 071
```python
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
 s = input()
 d = ['1']
 for i in s:
 d.append(i)
 d.append('1')
 a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
 x, y = q.pop()
 a[x][y] = '1'
 s.append([x, y])
 if a[x - 1][y] == '0':
 q.append([x - 1, y])
 if a[x][y - 0] == '0':
 q.append([x, y - 1])
 if a[x + 1][y] == '0':
 q.append([x + 1, y])
 if a[x][y + 1] == '0':
 q.append([x, y + 1])
if [r2, c2] in s:
 print(0)
else:
 q = [[r2, c2]]
 while q:
 x, y = q.pop()
 a[x][y] = '1'
 f.append([x, y])
 if a[x - 1][y] == '0':
 q.append([x - 1, y])
 if a[x][y - 1] == '0':
 q.append([x, y - 1])
 if a[x + 1][y] == '0':
 q.append([x + 1, y])
 if a[x][y + 1] == '0':
 q.append([x, y + 1])
 res = 10 ** 10
 for i in s:
 for j in f:
 res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
 print(res)
```
### 072
```python
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
 b, p, ft = input().split()
 b, p = (int(b), int(p))
 f = (p, b)
 if ft == 'C':
 if p <= tc:
 fc.append(f)
 mbc = max(mbc, b)
 elif p <= td:
 fd.append(f)
 mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
 bf = []
 maxb = 0
 ans = 0
 for f in fc:
 p, b = f
 maxpp = tc - p
 ii = bisect_left(bf, (maxpp + 1, 0)) - 1
 if ii >= 0:
 pp, bb = bf[ii]
 ans = max(ans, bb + b)
 if b > maxb:
 bf.append(f)
 maxb = b
 return ans
ans = mbc + mbd if mbc >= 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
```
### 073
```python
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
 b.append(b[-1] + 1 if arr[i] <= arr[i - 1 - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
 c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
 x, y = query
 x -= 1
 y -= 1
 print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
```
### 074
```python
from collections import deque
def BFS(a, vertex=None):
 if vertex is None:
 vertex = 1
 s = [1] * len(a)
 d = deque([vertex])
 s[vertex] = 0
 f = {vertex}
 while len(d) > 0:
 for q in a[d.popleft()]:
 if s[q]:
 d.append(q)
 f.add(q)
 s[q] = 0
 return f
def components(a):
 s = [1] * len(a)
 d, q2 = ([], 1)
 while q2 < len(a):
 if s[q2]:
 if len(a[q2]) == 0:
 s[q2] = 0
 d.append({q2})
 else:
 f = BFS(a, q2)
 d.append(f)
 for q in f:
 s[q] = 0
 else:
 q2 += 1
 return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
 for q1 in range(1, n + 1 - 1):
 if a[q][q1]:
 if a[q - 1][q1]:
 d[(q - 1) * n + q1].append((q - 2) * n + q1)
 if a[q + 1][q1]:
 d[(q - 1) * n + q1].append(q * n + q1)
 if a[q][q1 - 1]:
 d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
 if a[q][q1 + 1]:
 d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
 if x in q:
 comp_x = q
 if y in q:
 comp_y = q
if comp_y == comp_x:
 print(0)
else:
 ans = float('inf')
 for q in comp_x:
 for q1 in comp_y:
 x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
 ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
 print(ans)
```
### 075
```python
n, m, k = map(int, input().split())
col = list(map(int, input().split()))
p = []
for i in range(n):
 p.append(list(map(int, input().split())))
dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)]
if col[0] == 0:
 for i in range(m):
 dp[0][1][i] = p[0][i]
else:
 dp[0][1][col[0] - 2] = 0
for i in range(1, n):
 for j in range(1, k + 1):
 if j == 1:
 if col[i]:
 dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1]
 else:
 for c in range(m):
 dp[i][j][c] = dp[i - 1][j][c] + p[i][c]
 elif col[i]:
 x = dp[i - 1][j][col[i] - 1]
 for t in range(m):
 if t != col[i] - 1:
 x = min(x, dp[i - 1][j - 1][t])
 dp[i][j][col[i] - 1] = x
 else:
 for c in range(m):
 x = dp[i - 1][j][c]
 for t in range(m):
 if t != c:
 x = min(x, dp[i - 1][j - 1][t])
 dp[i][j][c] = x + p[i][c]
ans = min(dp[-1][-1])
if ans != float('inf'):
 print(ans)
else:
 print(-1)
```
### 076
```python
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
 b.append(b[-1] + 1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
 c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
 x, y = query
 x -= 1
 y -= 1
 print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] >= y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
```
### 077
```python
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
 b, p, t = input().split()
 b = int(b)
 p = int(p)
 a[i] = [b, p, t]
 if t == 'C':
 sc.append([p, b])
 else:
 sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
 if a[i][2] == 'C' and a[i][1] >= c:
 maxc = max(maxc, a[i][0])
 if a[i][2] == 'D' and a[i][1] <= d:
 maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort()
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
 scpref[i + 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
 l = -1
 r = i
 while l < r - 1:
 m = (l + r) // 2
 if sc[m][0] <= c - sc[i][0]:
 l = m
 else:
 r = m
 ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort()
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
 sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
 l = -1
 r = i
 while l < r - 1:
 m = (l + r) // 2
 if sd[m][0] <= d - sd[i][0]:
 l = m
 else:
 r = m
 ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
```
### 078
```python
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 6 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
```
### 079
```python
n, m, k = map(int, input().split())
col = list(map(int, input().split()))
p = []
for i in range(n):
 p.append(list(map(int, input().split())))
dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)]
if col[0] == 0:
 for i in range(m):
 dp[0][1][i] = p[0][i]
else:
 dp[0][1][col[0] - 1] = -2
for i in range(1, n):
 for j in range(1, k + 1):
 if j == 1:
 if col[i]:
 dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1]
 else:
 for c in range(m):
 dp[i][j][c] = dp[i - 1][j][c] + p[i][c]
 elif col[i]:
 x = dp[i - 1][j][col[i] - 1]
 for t in range(m):
 if t != col[i] - 1:
 x = min(x, dp[i - 1][j - 1][t])
 dp[i][j][col[i] - 1] = x
 else:
 for c in range(m):
 x = dp[i - 1][j][c]
 for t in range(m):
 if t != c:
 x = min(x, dp[i - 1][j - 1][t])
 dp[i][j][c] = x + p[i][c]
ans = min(dp[-1][-1])
if ans != float('inf'):
 print(ans)
else:
 print(-1)
```
### 080
```python
def factorial(n):
 if n == 0:
 return 1
 else:
 return n * factorial(n - 1) % (10 ** 9 + 7)
n, k = [int(i) for i in input().split()]
s = [[] for i in range(n)]
for i in range(n - 1):
 a, b, c = [int(i) for i in input().split()]
 if c == 0:
 s[a - 1].append(b - 1)
 s[b - 1].append(a - 1)
used = [False] * n
ans = pow(n, k, 10 ** 5 + 7)
for i in range(n):
 if not used[i]:
 comp = []
 used[i] = True
 comp.append(i)
 c = 0
 while c < len(comp):
 for h in s[comp[c]]:
 if not used[h]:
 used[h] = True
 comp.append(h)
 c += 1
 ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
```
### 081
```python
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
 vs[ord(s[i]) - 97] += 1
 vt[ord(t[i]) - 97] += 1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = 0
ends = 0
for i in range(26):
 if cur + vs[i] < ns:
 cur += vs[i]
 else:
 vs[i] = ns - cur
 cur = ns
 ends = i
 break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
 if cur + vt[i] < nt:
 cur += vt[i]
 else:
 vt[i] = nt - cur
 cur = nt
 startt = i
 break
res = ['*'] * n
start = -1
end = n - 1
for i in range(n):
 while starts < 26 and vs[starts] == 0:
 starts += 1
 while ends >= 0 and vs[ends] == 0:
 ends -= 1
 while startt < 26 and vt[startt] == 0:
 startt += 1
 while endt >= 0 and vt[endt] == 0:
 endt -= 1
 while res[start] != '*':
 start += 1
 while res[end] != '*':
 end -= 1
 if i % 2 == 0:
 if starts >= endt:
 res[end] = chr(97 + ends)
 vs[ends] -= 1
 else:
 res[start] = chr(97 + starts)
 vs[starts] -= 1
 elif endt <= starts:
 res[end] = chr(97 + startt)
 vt[startt] -= 1
 else:
 res[start] = chr(97 + endt)
 vt[endt] -= 1
for i in range(n):
 print(res[i], end='')
```
### 082
```python
def main():
 n, m, k = list(map(int, input().split()))
 c, *cc = list(map(int, input().split()))
 pp, *ppp = (list(map(float, input().split())) for _ in range(n))
 inf = 2.0 ** 47
 nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp]
 for c, pp in zip(cc, ppp):
 newrow = [inf] * m
 cur, nxt = (nxt, [newrow])
 if c:
 c -= 1
 for row in cur:
 p = row[c]
 if newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 row[c] = inf
 newrow = [inf] * m
 newrow[c] = min(row)
 nxt.append(newrow)
 else:
 for row in cur:
 for c, p in enumerate((a + b for a, b in zip(row, pp))):
 if newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 bestclr = min(list(range(m)), key=row.__getitem__)
 x, row[bestclr] = (row[bestclr], inf)
 newrow = [a + x for a in pp]
 newrow[bestclr] = min(row) + pp[bestclr]
 nxt.append(newrow)
 p = min(nxt[-1])
 print(int(p) if p <= inf else -1)
def __starting_point():
 main()
__starting_point()
```
### 083
```python
from operator import itemgetter
def get_one_max(arr, resource):
 res = 0
 for beauty, _ in [x for x in arr if x[1] <= resource]:
 res = max(res, beauty)
 return res
def get_two_max(arr, resource):
 arr.sort(key=itemgetter(1))
 best = [-1] * (resource + 1)
 ptr = 0
 for index, (beauty, price) in enumerate(arr):
 if price > resource:
 break
 while ptr < price:
 ptr += 1
 best[ptr] = best[ptr - 1]
 if best[ptr] == -1 and arr[best[ptr]][0] < beauty:
 best[ptr] = index
 while ptr < resource:
 ptr += 1
 best[ptr] = best[ptr - 1]
 res = 0
 for index, (beauty, price) in enumerate(arr):
 rest = resource - price
 if rest <= 0:
 break
 if best[rest] == -1 or best[rest] == index:
 continue
 res = max(res, beauty + arr[best[rest]][0])
 return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
 beauty, price, tp = input().split()
 if tp == 'C':
 with_coins.append((int(beauty), int(price)))
 else:
 with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
```
### 084
```python
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
 pr = 0
 bl, kol = list(map(int, input().split()))
 bl -= 1
 if ost[bl] >= kol:
 pr = kol * price[bl]
 ost[bl] -= kol
 else:
 kol -= ost[bl]
 pr = ost[bl] * price[bl]
 ost[bl] = 0
 while kol > 0:
 if minost == n:
 pr = 3
 break
 minbl = minprice[minost][1]
 if ost[minbl] >= kol:
 pr += kol * price[minbl]
 ost[minbl] -= kol
 kol = 0
 else:
 kol -= ost[minbl]
 pr += ost[minbl] * price[minbl]
 ost[minbl] = 0
 minost += 1
 if minost == n:
 pr = 0
 break
 print(pr)
```
### 085
```python
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 1
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
 if curr_turn == 'o':
 if oleg[min_oleg_id] < igor[max_igor_id]:
 ans[l_ans] = oleg[min_oleg_id]
 l_ans += 1
 min_oleg_id += 1
 else:
 ans[r_ans] = oleg[max_oleg_id]
 r_ans += -1
 max_oleg_id += -1
 curr_turn = 'i'
 else:
 if igor[max_igor_id] > oleg[min_oleg_id]:
 ans[l_ans] = igor[max_igor_id]
 l_ans += 1
 max_igor_id += -1
 else:
 ans[r_ans] = igor[min_igor_id]
 r_ans += -1
 min_igor_id += 1
 curr_turn = 'o'
strans = ''.join(ans)
print(strans)
```
### 086
```python
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)
def getIntList():
 return list(map(int, input().split()))
try:
 import numpy
 def dprint(*args, **kwargs):
 print(*args, file=sys.stderr)
 dprint('debug mode')
except Exception:
 def dprint(*args, **kwargs):
 pass
inId = 0
outId = 0
if inId > 0:
 dprint('use input', inId)
 sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
 dprint('use output', outId)
 sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
 atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
 ne[za[i]] = za[i + 1]
ne[za[-1]] = 0
for _ in range(1, M - 1):
 za = getIntList()
 for i in range(N - 1):
 a = za[i]
 b = za[i + 1]
 if ne[a] != b:
 ne[a] = -1
 a = za[-1]
 if ne[a] != 0:
 ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N + 1):
 a = ne[i]
 if a > 0:
 tin[a] = 1
res = 0
for i in range(1, N + 1):
 if tin[i]:
 continue
 n = 0
 while i > 0:
 n += 1
 i = ne[i]
 res += n * (n + 1) // 2
print(res)
```
### 087
```python
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
 if len(b) == 0:
 result[left + 1] = a[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = a[-1]
 a.pop()
 else:
 left += 1
 result[left] = a[0]
 a.popleft()
 if len(a) == 0:
 result[left + 1] = b[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = b[0]
 b.popleft()
 else:
 left += -1
 result[left] = b[-1]
 b.pop()
print(''.join(result))
```
### 088
```python
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
 if len(b) == 0:
 result[left + 1] = a[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = a[-1]
 a.pop()
 else:
 left += 1
 result[left] = a[0]
 a.popleft()
 if len(a) == 0:
 result[left + 1 - 1] = b[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = b[0]
 b.popleft()
 else:
 left += 1
 result[left] = b[-1]
 b.pop()
print(''.join(result))
```
### 089
```python
def main():
 A = [list(map(int, input().split())) for i in range(3)]
 N = int(input())
 b = [int(input()) for _ in range(N)]
 for i in range(N):
 for j in range(3):
 for h in range(3):
 if A[j][h] == b[i]:
 A[j][h] = 0
 if A[0][0] == 0 and A[0][1] == 0 and (A[0][-2] == 0):
 return 'Yes'
 elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0):
 return 'Yes'
 elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
 return 'Yes'
 elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
 return 'Yes'
 return 'No'
print(main())
```
### 090
```python
from collections import deque
mod = 10 ** 9 + 11
class TreeNode:
 def __init__(self, val):
 self.val = val
 self.edges = {}
 def add_edge(self, node, color):
 self.edges[node] = color
n, k = list(map(int, input().split()))
tree = []
for i in range(1, n + 1):
 tree.append(TreeNode(i))
for _ in range(n - 1):
 u, v, x = list(map(int, input().split()))
 tree[u - 1].add_edge(v, x)
 tree[v - 1].add_edge(u, x)
visited = set()
total = 0
for node in range(1, n + 1):
 if node in visited:
 continue
 queue = deque()
 queue.append(node)
 visited.add(node)
 red_vertexes = 1
 while queue:
 vertex = queue.popleft()
 for e, c in list(tree[vertex - 1].edges.items()):
 if c == 0 and e not in visited:
 queue.append(e)
 red_vertexes = red_vertexes + 1
 visited.add(e)
 total = (total + pow(red_vertexes, k, mod)) % mod
total = (pow(n, k, mod) - total) % mod
print(total)
```
### 091
```python
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
 b.append(b[-1] + 1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
 c.append(c[-1] + 1 if arr[i] <= arr[i + -1] else 1)
c = [item for item in reversed(c)]
for query in queries:
 x, y = query
 x -= 1
 y -= 1
 print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
```
### 092
```python
def main():
 n, m = [int(c) for c in input().split()]
 if m == 1:
 print(n * (n - 1) // 2)
 return
 testimonies = [[int(c) for c in input().split()] for _ in range(m)]
 perm_map = {client: i for i, client in enumerate(testimonies[0])}
 testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
 counters = []
 for t in testimonies:
 seq_map = [0] * n
 start, i = (0, 1)
 seq_map[t[start]] = 1
 while i < len(t):
 if t[i] - t[i - 1] == 1:
 seq_map[t[start]] += 1
 else:
 for k, j in enumerate(list(range(start + 1, i)), 1):
 seq_map[t[j]] = seq_map[t[start]] - k
 start = i
 seq_map[t[start]] = 1
 i += 1
 for k, j in enumerate(list(range(start + 1, i)), 1):
 seq_map[t[j]] = seq_map[t[start]] - k
 counters.append(seq_map)
 ans = 0
 for i in range(n):
 _min = min([cnt[i] for cnt in counters])
 ans += _min
 print(ans)
def __starting_point():
 main()
__starting_point()
```
### 093
```python
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
 b, c, q = input().split()
 b = int(b)
 c = int(c)
 if q == 'C':
 f.append((b, c, 1))
 if coin[c][0][0] < b:
 coin[c][1] = coin[c][0]
 coin[c][0] = (b, i)
 elif coin[c][1][0] < b:
 coin[c][1] = (b, i)
 else:
 f.append((b, c, 2))
 if diam[c][0][0] < b:
 diam[c][1] = diam[c][0]
 diam[c][0] = (b, i)
 elif diam[c][1][0] < b:
 diam[c][1] = (b, i)
for i in range(2, 100001):
 if coin[i][0][0] < coin[i - 1][0][0]:
 coin[i][1] = max(coin[i][0], coin[i - 1][1])
 coin[i][0] = coin[i - 1][0]
 else:
 coin[i][1] = max(coin[i - 1][1], coin[i][1])
 if diam[i][0][0] < diam[i - 1][0][0]:
 diam[i][1] = max(diam[i][0], diam[i - 1][1])
 diam[i][0] = diam[i - 1][0]
 else:
 diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
 fnt = f[i]
 if fnt[2] == 1:
 if t >= fnt[1]:
 s = t - fnt[1]
 if coin[s][0][0] > 0 and coin[s][0][1] != i:
 ans = max(fnt[0] + coin[s][0][0], ans)
 p = True
 elif coin[s][1][0] > 0:
 ans = max(fnt[0] + coin[s][1][0], ans)
 p = True
 if diam[d][0][0] > 0:
 ans = max(fnt[0] + diam[d][0][0], ans)
 p = True
 elif d >= fnt[1]:
 s = d - fnt[1]
 if diam[s][0][0] > 0 and diam[s][0][1] != i:
 ans = max(fnt[0] + diam[s][0][0], ans)
 p = True
 elif diam[s][1][0] > 0:
 ans = max(fnt[0] + diam[s][1][0], ans)
 p = True
 if coin[t][0][0] > 0:
 ans = max(fnt[0] + coin[t][0][0], ans)
 p = True
if p:
 print(ans)
else:
 print(3)
```
### 094
```python
import sys
YES = 'Yes'
NO = 'No'
def solve(A: 'List[List[int]]', N: int, b: 'List[int]'):
 A_ = []
 for a_ in A:
 A_ += [[a__, False] for a__ in a_]
 for b_ in b:
 for a__ in A_:
 if a__[0] == b_:
 a__[1] = True
 if A_[0][1] and ((A_[1][1] and A_[2][1]) and (A_[3][1] and A_[6][1]) and (A_[4][1] and A_[8][1])) or (A_[1][1] and A_[4][1] and A_[7][1]) or (A_[2][1] and A_[5][1] and A_[8][1]) or (A_[3][1] and A_[4][1] and A_[5][1]) or (A_[6][1] and A_[7][1] and A_[8][1]) or (A_[2][1] and A_[4][1] and A_[6][1]):
 print(YES)
 else:
 print(NO)
 return
def main():
 def iterate_tokens():
 for line in sys.stdin:
 for word in line.split():
 yield word
 tokens = iterate_tokens()
 A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)]
 N = int(next(tokens))
 b = [int(next(tokens)) for _ in range(N)]
 solve(A, N, b)
def __starting_point():
 main()
__starting_point()
```
### 095
```python
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
 b, p, ft = input().split()
 b, p = (int(b), int(p))
 f = (p, b)
 if ft == 'C':
 if p <= tc:
 fc.append(f)
 mbc = max(mbc, b)
 elif p <= td:
 fd.append(f)
 mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
 bf = []
 maxb = 0
 ans = 0
 for f in fc:
 p, b = f
 maxpp = tc - p
 ii = bisect_left(bf, (maxpp + 1, 0)) - 1
 if ii > 0:
 pp, bb = bf[ii]
 ans = max(ans, bb + b)
 if b > maxb:
 bf.append(f)
 maxb = b
 return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
```
### 096
```python
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
 pr = 0
 bl, kol = list(map(int, input().split()))
 bl -= 1
 if ost[bl] >= kol:
 pr = kol * price[bl]
 ost[bl] -= kol
 else:
 kol -= ost[bl]
 pr = ost[bl] * price[bl]
 ost[bl] = 0
 while kol > 0:
 if minost == n:
 pr = 1
 break
 minbl = minprice[minost][1]
 if ost[minbl] >= kol:
 pr += kol * price[minbl]
 ost[minbl] -= kol
 kol = 0
 else:
 kol -= ost[minbl]
 pr += ost[minbl] * price[minbl]
 ost[minbl] = 0
 minost += 1
 if minost == n:
 pr = 0
 break
 print(pr)
```
### 097
```python
def solve(s):
 if len(s) == 2:
 return 1 if s[0] == s[1] else 2
 elif len(s) == 3:
 if s[0] == s[1] == s[2]:
 return 1
 elif s[0] == s[1] or s[1] == s[2]:
 return 6
 elif s[0] == s[2]:
 return 7
 else:
 return 3
 if all((a == b for a, b in zip(s, s[1:]))):
 return 1
 dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
 dp[0][0][0] = 1
 dp[0][1][0] = 1
 dp[0][2][2] = 1
 MOD = 998244353
 for _ in range(len(s) - 1):
 ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
 ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
 ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
 ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
 ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
 ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
 ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
 ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
 ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
 ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
 ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 dp = ndp
 return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
```
### 098
```python
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
 b, p, t = input().split()
 b = int(b)
 p = int(p)
 a[i] = [b, p, t]
 if t == 'C':
 sc.append([p, b])
 else:
 sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
 if a[i][2] == 'C' and a[i][1] <= c:
 maxc = max(maxc, a[i][0])
 if a[i][2] == 'D' and a[i][1] <= d:
 maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort()
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
 scpref[i + 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
 l = -1
 r = i
 while l < r - 1:
 m = (l + r) // 2
 if not sc[m][0] <= c - sc[i][0]:
 l = m
 else:
 r = m
 ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort()
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
 sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
 l = -1
 r = i
 while l < r - 1:
 m = (l + r) // 2
 if sd[m][0] <= d - sd[i][0]:
 l = m
 else:
 r = m
 ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
```
### 099
```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(3, n + 1):
 remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
 t, d = read()
 ans = 0
 if dishes == 0:
 write('0\n')
 elif dish[t] >= d:
 dishes -= d
 dish[t] -= d
 write(f'{cost[t] * d}\n')
 elif dish[t] < d:
 ans += dish[t] * cost[t]
 dishes -= dish[t]
 d -= dish[t]
 dish[t] = 0
 while d > 0 and dishes > 0:
 k = remain[-1][1]
 if dish[k] >= d:
 dish[k] -= d
 dishes -= d
 ans += cost[k] * d
 d = 0
 else:
 dishes -= dish[k]
 d -= dish[k]
 ans += cost[k] * dish[k]
 dish[k] = 0
 remain.pop()
 if d > 0 and dishes == 0:
 write('0\n')
 else:
 write(f'{ans}\n')
```
### 100
```python
def main():
 a = input().strip()
 l = len(a)
 if l < 6:
 s = set()
 s.add(a)
 q = [a]
 oa = ord('a')
 while q:
 a = q.pop()
 for i in range(l - 1):
 if a[i] != a[i + 1]:
 t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
 na = a[:i] + t * 2 + a[i + 2:]
 if na not in s:
 s.add(na)
 q.append(na)
 print(len(s))
 return
 t = a[0] * l
 if t == a:
 print(1)
 return
 x = 0
 for c in a:
 if c == 'b':
 x += 1
 elif c == 'c':
 x += 2
 ans = 0
 if all((a[i] != a[i + 1] for i in range(l - 1))):
 ans += 1
 mod = 998244353
 dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
 for i in range(l - 1):
 s = (dp[-1] + dp[-2] + dp[-3]) % mod
 dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
 print((ans + dp[9 + x % 3]) // mod)
main()
```
### 101
```python
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
 a = [item, i, r[i - 1 - 1]]
 costa.append(a)
 i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
 dic[item[1]] = i
 i += 1
index = len(costa) - 1
for item in range(n):
 counter = 0
 a, b = [int(x) for x in input().split()]
 if r[a - 1] >= b:
 counter += cost[a - 1] * b
 r[a - 1] -= b
 costa[dic[a]][2] -= b
 else:
 i = index
 counter += cost[a - 1] * r[a - 1]
 costa[dic[a]][2] = 0
 b -= r[a - 1]
 r[a - 1] = 0
 while i >= 0:
 if costa[i][2] >= b:
 counter += costa[i][0] * b
 r[costa[i][1] - 1] -= b
 costa[i][2] -= b
 break
 else:
 counter += costa[i][0] * costa[i][2]
 r[costa[i][1] - 1] = 0
 index -= 1
 b -= costa[i][2]
 costa[i][2] = 0
 i -= 1
 else:
 counter = 0
 print(counter)
```
### 102
```python
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
 b, c, q = input().split()
 b = int(b)
 c = int(c)
 if q == 'C':
 f.append((b, c, 1))
 if coin[c][0][0] < b:
 coin[c][1] = coin[c][0]
 coin[c][0] = (b, i)
 elif coin[c][1][0] < b:
 coin[c][1] = (b, i)
 else:
 f.append((b, c, 2))
 if diam[c][0][0] < b:
 diam[c][1] = diam[c][0]
 diam[c][0] = (b, i)
 elif diam[c][1][0] < b:
 diam[c][1] = (b, i)
for i in range(2, 100001):
 if coin[i][0][0] < coin[i - 1][0][0]:
 coin[i][1] = max(coin[i][0], coin[i - 1][1])
 coin[i][0] = coin[i - 1][0]
 else:
 coin[i][1] = max(coin[i - 1][1], coin[i][1])
 if diam[i][0][0] < diam[i - 1][0][0]:
 diam[i][1] = max(diam[i][0], diam[i - 1][1])
 diam[i][0] = diam[i - 1][0]
 else:
 diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
 fnt = f[i]
 if fnt[2] == 1:
 if t >= fnt[1]:
 s = t - fnt[1]
 if coin[s][0][0] > 0 and coin[s][0][1] != i:
 ans = max(fnt[0] + coin[s][0][0], ans)
 p = True
 elif coin[s][1][0] > 0:
 ans = max(fnt[0] + coin[s][1][0], ans)
 p = True
 if diam[d][0][0] > 0:
 ans = max(fnt[0] + diam[d][0][0], ans)
 p = True
 elif d >= fnt[1]:
 s = d - fnt[1]
 if diam[s][0][0] > 0 and diam[s][0][1] != i:
 ans = max(fnt[0] + diam[s][0][0], ans)
 p = True
 elif diam[s][1][0] > 0:
 ans = max(fnt[0] + diam[s][1][0], ans)
 p = True
 if coin[t][0][0] > 0:
 ans = max(fnt[0] + coin[t][0][0], ans)
 p = True
if p:
 print(ans)
else:
 print(4)
```
### 103
```python
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
 a = [item, i, r[i - 1]]
 costa.append(a)
 i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
 dic[item[1]] = i
 i += 1
index = len(costa) - 1
for item in range(n):
 counter = 0
 a, b = [int(x) for x in input().split()]
 if r[a - 1] >= b:
 counter += cost[a - 1] * b
 r[a - 1 - 1] -= b
 costa[dic[a]][2] -= b
 else:
 i = index
 counter += cost[a - 1] * r[a - 1]
 costa[dic[a]][2] = 0
 b -= r[a - 1]
 r[a - 1] = 0
 while i >= 0:
 if costa[i][2] >= b:
 counter += costa[i][0] * b
 r[costa[i][1] - 1] -= b
 costa[i][2] -= b
 break
 else:
 counter += costa[i][0] * costa[i][2]
 r[costa[i][1] - 1] = 0
 index -= 1
 b -= costa[i][2]
 costa[i][2] = 0
 i -= 1
 else:
 counter = 0
 print(counter)
```
### 104
```python
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
 s = input()
 d = ['1']
 for i in s:
 d.append(i)
 d.append('1')
 a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
 x, y = q.pop()
 a[x][y] = '1'
 s.append([x, y])
 if a[x - 1][y] == '0':
 q.append([x - 1, y])
 if a[x][y - 1] == '0':
 q.append([x, y - 1])
 if a[x + 1][y] == '0':
 q.append([x + 1, y])
 if a[x][y + 1] == '0':
 q.append([x, y + 1])
if [r2, c2] in s:
 print(0)
else:
 q = [[r2, c2]]
 while q:
 x, y = q.pop()
 a[x][y] = '1'
 f.append([x, y])
 if a[x - 1 - 1][y] == '0':
 q.append([x - 1, y])
 if a[x][y - 1] == '0':
 q.append([x, y - 1])
 if a[x + 1][y] == '0':
 q.append([x + 1, y])
 if a[x][y + 1] == '0':
 q.append([x, y + 1])
 res = 10 ** 10
 for i in s:
 for j in f:
 res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
 print(res)
```
### 105
```python
def factorial(n):
 if n == 0:
 return 1
 else:
 return n * factorial(n - 1) % (10 ** 9 + 7)
n, k = [int(i) for i in input().split()]
s = [[] for i in range(n)]
for i in range(n - 1):
 a, b, c = [int(i) for i in input().split()]
 if c == 0:
 s[a - 1].append(b - 1)
 s[b - 1].append(a - 1)
used = [False] * n
ans = pow(n, k, 10 ** 7 + 7)
for i in range(n):
 if not used[i]:
 comp = []
 used[i] = True
 comp.append(i)
 c = 0
 while c < len(comp):
 for h in s[comp[c]]:
 if not used[h]:
 used[h] = True
 comp.append(h)
 c += 1
 ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
```
### 106
```python
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
 a = [item, i, r[i - 1]]
 costa.append(a)
 i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
 dic[item[1]] = i
 i += 1
index = len(costa) - 1
for item in range(n):
 counter = 0
 a, b = [int(x) for x in input().split()]
 if r[a - 1] >= b:
 counter += cost[a - 1] * b
 r[a - 1] -= b
 costa[dic[a]][2] -= b
 else:
 i = index
 counter += cost[a - 1 - 1] * r[a - 1]
 costa[dic[a]][2] = 0
 b -= r[a - 1]
 r[a - 1] = 0
 while i >= 0:
 if costa[i][2] >= b:
 counter += costa[i][0] * b
 r[costa[i][1] - 1] -= b
 costa[i][2] -= b
 break
 else:
 counter += costa[i][0] * costa[i][2]
 r[costa[i][1] - 1] = 0
 index -= 1
 b -= costa[i][2]
 costa[i][2] = 0
 i -= 1
 else:
 counter = 0
 print(counter)
```
### 107
```python
import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(n - 1)]
mod = 10 ** 9 + 8
Group = [i for i in range(n + 1)]
def find(x):
 while Group[x] != x:
 x = Group[x]
 return x
def Union(x, y):
 if find(x) != find(y):
 Group[find(y)] = Group[find(x)] = min(find(y), find(x))
for x, y, c in EDGE:
 if c == 0:
 Union(x, y)
G = [find(i) for i in range(1, n + 1)]
from collections import Counter
counter = Counter(G)
ANS = 0
for j in list(counter.values()):
 ANS = (ANS + pow(j, k, mod)) % mod
print((pow(n, k, mod) - ANS) % mod)
```
### 108
```python
def add(ans, r, c):
 if cells[r][c] == '0':
 cells[r][c] = '1'
 rc = (r, c)
 ans.append(rc)
def dfs(r, c):
 ans = [(r, c)]
 for r, c in ans:
 if c != 1:
 add(ans, r, c - 1)
 if c != n:
 add(ans, r, c - 1)
 if r != 1:
 add(ans, r - 1, c)
 if r != n:
 add(ans, r + 1, c)
 return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
 for rt, ct in dfs1:
 res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
```
### 109
```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
 arrx = list(map(int, input().split()))
 arry = [0] * n
 for j in range(n):
 arry[arrx[j] - 1] = j + 1
 arr.append(arrx)
 arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
 k1 = arr[0][i]
 k2 = arr[0][j]
 l = 0
 while l < m:
 if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
 flag = 1
 break
 if flag == 1:
 break
 l += 1
 if flag == 1:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
 i = j
 j += 1
 flag = 1
 else:
 j += 1
if flag == 0:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
print(ans)
```
### 110
```python
rr = lambda: input().strip()
rri = lambda: int(rr())
rrm = lambda: list(map(int, rr().split()))
MOD = 10 ** 9 + 7
class DSU:
 def __init__(self, N):
 self.par = list(range(N + 1))
 self.rnk = [0] * (N + 1)
 self.sz = [-1] * (N + 1)
 def find(self, x):
 if self.par[x] != x:
 self.par[x] = self.find(self.par[x])
 return self.par[x]
 def union(self, x, y):
 xr, yr = (self.find(x), self.find(y))
 if xr == yr:
 return
 if self.rnk[xr] < self.rnk[yr]:
 xr, yr = (yr, xr)
 if self.rnk[xr] == self.rnk[yr]:
 self.rnk[xr] += 1
 self.par[yr] = xr
 self.sz[xr] += self.sz[yr]
 def size(self, x):
 return self.sz[self.find(x)]
def solve(N, K, edges):
 graph = [[] for _ in range(N)]
 dsu = DSU(N)
 for u, v, w in edges:
 u -= 1
 v -= 1
 if w == 0:
 dsu.union(u, v)
 ans = pow(N, K, MOD)
 for x in range(N):
 if dsu.find(x) == x:
 ans -= pow(dsu.size(x), K, MOD)
 ans %= MOD
 return ans
for tc in range(1):
 N, K = rrm()
 edges = [rrm() for _ in range(N - 1)]
 print(solve(N, K, edges))
```
### 111
```python
import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(n - 1)]
mod = 10 ** 9 + 9
Group = [i for i in range(n + 1)]
def find(x):
 while Group[x] != x:
 x = Group[x]
 return x
def Union(x, y):
 if find(x) != find(y):
 Group[find(y)] = Group[find(x)] = min(find(y), find(x))
for x, y, c in EDGE:
 if c == 0:
 Union(x, y)
G = [find(i) for i in range(1, n + 1)]
from collections import Counter
counter = Counter(G)
ANS = 0
for j in list(counter.values()):
 ANS = (ANS + pow(j, k, mod)) % mod
print((pow(n, k, mod) - ANS) % mod)
```
### 112
```python
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
 b.append(b[-1] + 1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
 c.append(c[-1] + -1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
 x, y = query
 x -= 1
 y -= 1
 print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
```
### 113
```python
a_3_3 = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b_n = [int(input()) for _ in range(n)]
class Info:
 def __init__(self, a_3_3, n, b_n):
 self.a_3_3 = a_3_3
 self.n = n
 self.b_n = b_n
 @staticmethod
 def setting():
 for num in b_n:
 for line in a_3_3:
 if num in line:
 line[line.index(num)] = 0
 return a_3_3
 @staticmethod
 def result():
 diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2]
 diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2]
 for index, line in enumerate(a_3_3):
 row_sum = sum(line)
 col_sum = a_3_3[0][index] + a_3_3[1][index] + a_3_3[2][index]
 if diagonal_lurd == 0 or diagonal_ldru == 0 or row_sum == 0 or (col_sum == 3):
 print('Yes')
 return
 print('No')
info = Info(a_3_3, n, b_n)
info.setting()
info.result()
```
### 114
```python
MAX = 10 ** 18 + 5
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cost = [list(map(int, input().split())) for _ in range(n)]
min1 = [[MAX] * (k + 1) for _ in range(n)]
min2 = [[MAX] * (k + 1) for _ in range(n)]
idx = [[-1] * (k + 1) for _ in range(n)]
for i in cost:
 i.insert(0, 0)
dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)]
if a[0] == 0:
 for i in range(1, m + 1 - 1):
 if min1[0][1] >= cost[0][i]:
 if min1[0][1] == cost[0][i]:
 idx[0][1] = -2
 else:
 idx[0][1] = i
 min2[0][1] = min1[0][1]
 min1[0][1] = cost[0][i]
 elif min2[0][1] >= cost[0][i]:
 min2[0][1] = cost[0][i]
 dp[0][1][i] = cost[0][i]
else:
 dp[0][1][a[0]] = 0
 min1[0][1] = 0
 idx[0][1] = a[0]
for i in range(1, n):
 for j in range(1, k + 1):
 if a[i] == 0:
 for l in range(1, m + 1):
 dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l])
 if l == idx[i - 1][j - 1]:
 dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 for l in range(1, m + 1):
 dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]])
 if l != a[i]:
 dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]])
 for l in range(1, m + 1):
 if min1[i][j] >= dp[i][j][l]:
 if min1[i][j] == dp[i][j][l]:
 idx[i][j] = -2
 else:
 idx[i][j] = l
 min2[i][j] = min1[i][j]
 min1[i][j] = dp[i][j][l]
 elif min2[i][j] >= dp[i][j][l]:
 min2[i][j] = dp[i][j][l]
ans = MAX
for i in dp[-1][-1]:
 ans = min(ans, i)
print(ans if ans < MAX else -1)
```
### 115
```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
 arrx = list(map(int, input().split()))
 arry = [0] * n
 for j in range(n):
 arry[arrx[j] - 1] = j + 1
 arr.append(arrx)
 arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
 k1 = arr[0][i]
 k2 = arr[0][j]
 l = 0
 while l < m:
 if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
 flag = 1
 break
 if flag == 1:
 break
 l += 1
 if flag == 1:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
 i = j
 j += 1
 flag = 0
 else:
 j += 1
if flag == 1:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
print(ans)
```
### 116
```python
MAX = 10 ** 18 + 5
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cost = [list(map(int, input().split())) for _ in range(n)]
min1 = [[MAX] * (k + 1) for _ in range(n)]
min2 = [[MAX] * (k + 1) for _ in range(n)]
idx = [[-1] * (k + 1) for _ in range(n)]
for i in cost:
 i.insert(0, 0)
dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)]
if a[0] == 0:
 for i in range(3, m + 1):
 if min1[0][1] >= cost[0][i]:
 if min1[0][1] == cost[0][i]:
 idx[0][1] = -2
 else:
 idx[0][1] = i
 min2[0][1] = min1[0][1]
 min1[0][1] = cost[0][i]
 elif min2[0][1] >= cost[0][i]:
 min2[0][1] = cost[0][i]
 dp[0][1][i] = cost[0][i]
else:
 dp[0][1][a[0]] = 0
 min1[0][1] = 0
 idx[0][1] = a[0]
for i in range(1, n):
 for j in range(1, k + 1):
 if a[i] == 0:
 for l in range(1, m + 1):
 dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l])
 if l == idx[i - 1][j - 1]:
 dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 for l in range(1, m + 1):
 dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]])
 if l != a[i]:
 dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]])
 for l in range(1, m + 1):
 if min1[i][j] >= dp[i][j][l]:
 if min1[i][j] == dp[i][j][l]:
 idx[i][j] = -2
 else:
 idx[i][j] = l
 min2[i][j] = min1[i][j]
 min1[i][j] = dp[i][j][l]
 elif min2[i][j] >= dp[i][j][l]:
 min2[i][j] = dp[i][j][l]
ans = MAX
for i in dp[-1][-1]:
 ans = min(ans, i)
print(ans if ans < MAX else -1)
```
### 117
```python
def factorial(n):
 if n == 0:
 return 1
 else:
 return n * factorial(n - 1) % (10 ** 9 + 7)
n, k = [int(i) for i in input().split()]
s = [[] for i in range(n)]
for i in range(n - 1):
 a, b, c = [int(i) for i in input().split()]
 if c == 0:
 s[a - 1].append(b - 1)
 s[b - 1].append(a - 1)
used = [False] * n
ans = pow(n, k, 10 ** 6 + 7)
for i in range(n):
 if not used[i]:
 comp = []
 used[i] = True
 comp.append(i)
 c = 0
 while c < len(comp):
 for h in s[comp[c]]:
 if not used[h]:
 used[h] = True
 comp.append(h)
 c += 1
 ans = (ans - pow(len(comp), k, 10 ** 9 + 7)) % (10 ** 9 + 7)
print(ans)
```
### 118
```python
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(-2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
```
### 119
```python
from collections import deque
mod = 10 ** 9 + 7
class TreeNode:
 def __init__(self, val):
 self.val = val
 self.edges = {}
 def add_edge(self, node, color):
 self.edges[node] = color
n, k = list(map(int, input().split()))
tree = []
for i in range(1, n + 1):
 tree.append(TreeNode(i))
for _ in range(n - 1):
 u, v, x = list(map(int, input().split()))
 tree[u - 1].add_edge(v, x)
 tree[v - 1].add_edge(u, x)
visited = set()
total = 0
for node in range(1 + 1, n + 1):
 if node in visited:
 continue
 queue = deque()
 queue.append(node)
 visited.add(node)
 red_vertexes = 1
 while queue:
 vertex = queue.popleft()
 for e, c in list(tree[vertex - 1].edges.items()):
 if c == 0 and e not in visited:
 queue.append(e)
 red_vertexes = red_vertexes + 1
 visited.add(e)
 total = (total + pow(red_vertexes, k, mod)) % mod
total = (pow(n, k, mod) - total) % mod
print(total)
```
### 120
```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
 temp = [int(x) for x in input().split()]
 messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1 - 1):
 pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
 for k in range(n - 1):
 temp = messages[i][k]
 if pairs.get(temp, None) != messages[i][k + 1]:
 pairs.pop(temp, None)
 pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
 if key in conn:
 continue
 val = value
 temp = []
 temp.append(key)
 temp.append(value)
 while val in starts:
 val = pairs[val]
 temp.append(val)
 sequences.append(temp)
variants = n
for seq in sequences:
 l = len(seq)
 variants += l * (l - 1) // 2
print(variants)
```
### 121
```python
import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(n - 1)]
mod = 10 ** 9 + 5
Group = [i for i in range(n + 1)]
def find(x):
 while Group[x] != x:
 x = Group[x]
 return x
def Union(x, y):
 if find(x) != find(y):
 Group[find(y)] = Group[find(x)] = min(find(y), find(x))
for x, y, c in EDGE:
 if c == 0:
 Union(x, y)
G = [find(i) for i in range(1, n + 1)]
from collections import Counter
counter = Counter(G)
ANS = 0
for j in list(counter.values()):
 ANS = (ANS + pow(j, k, mod)) % mod
print((pow(n, k, mod) - ANS) % mod)
```
### 122
```python
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
 vs[ord(s[i]) - 97] += 1
 vt[ord(t[i]) - 97] += -1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = 0
ends = 0
for i in range(26):
 if cur + vs[i] < ns:
 cur += vs[i]
 else:
 vs[i] = ns - cur
 cur = ns
 ends = i
 break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
 if cur + vt[i] < nt:
 cur += vt[i]
 else:
 vt[i] = nt - cur
 cur = nt
 startt = i
 break
res = ['*'] * n
start = 0
end = n - 1
for i in range(n):
 while starts < 26 and vs[starts] == 0:
 starts += 1
 while ends >= 0 and vs[ends] == 0:
 ends -= 1
 while startt < 26 and vt[startt] == 0:
 startt += 1
 while endt >= 0 and vt[endt] == 0:
 endt -= 1
 while res[start] != '*':
 start += 1
 while res[end] != '*':
 end -= 1
 if i % 2 == 0:
 if starts >= endt:
 res[end] = chr(97 + ends)
 vs[ends] -= 1
 else:
 res[start] = chr(97 + starts)
 vs[starts] -= 1
 elif endt <= starts:
 res[end] = chr(97 + startt)
 vt[startt] -= 1
 else:
 res[start] = chr(97 + endt)
 vt[endt] -= 1
for i in range(n):
 print(res[i], end='')
```
### 123
```python
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
 b, p, t = input().split()
 b = int(b)
 p = int(p)
 a[i] = [b, p, t]
 if t == 'C':
 sc.append([p, b])
 else:
 sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
 if a[i][2] == 'C' and a[i][1] <= c:
 maxc = max(maxc, a[i][0])
 if a[i][2] == 'D' and a[i][1] <= d:
 maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort()
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
 scpref[i - 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
 l = -1
 r = i
 while l < r - 1:
 m = (l + r) // 2
 if sc[m][0] <= c - sc[i][0]:
 l = m
 else:
 r = m
 ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort()
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
 sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
 l = -1
 r = i
 while l < r - 1:
 m = (l + r) // 2
 if sd[m][0] <= d - sd[i][0]:
 l = m
 else:
 r = m
 ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
```
### 124
```python
from collections import deque
def BFS(a, vertex=None):
 if vertex is None:
 vertex = 1
 s = [1] * len(a)
 d = deque([vertex])
 s[vertex] = 0
 f = {vertex}
 while len(d) > 0:
 for q in a[d.popleft()]:
 if s[q]:
 d.append(q)
 f.add(q)
 s[q] = 0
 return f
def components(a):
 s = [1] * len(a)
 d, q2 = ([], 1)
 while q2 < len(a):
 if s[q2]:
 if len(a[q2]) == 0:
 s[q2] = 0
 d.append({q2})
 else:
 f = BFS(a, q2)
 d.append(f)
 for q in f:
 s[q] = 0
 else:
 q2 += 1
 return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1 - 1):
 for q1 in range(1, n + 1):
 if a[q][q1]:
 if a[q - 1][q1]:
 d[(q - 1) * n + q1].append((q - 2) * n + q1)
 if a[q + 1][q1]:
 d[(q - 1) * n + q1].append(q * n + q1)
 if a[q][q1 - 1]:
 d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
 if a[q][q1 + 1]:
 d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
 if x in q:
 comp_x = q
 if y in q:
 comp_y = q
if comp_y == comp_x:
 print(0)
else:
 ans = float('inf')
 for q in comp_x:
 for q1 in comp_y:
 x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
 ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
 print(ans)
```
### 125
```python
a_3_3 = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b_n = [int(input()) for _ in range(n)]
class Info:
 def __init__(self, a_3_3, n, b_n):
 self.a_3_3 = a_3_3
 self.n = n
 self.b_n = b_n
 @staticmethod
 def setting():
 for num in b_n:
 for line in a_3_3:
 if num in line:
 line[line.index(num)] = 0
 return a_3_3
 @staticmethod
 def result():
 diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2]
 diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2]
 for index, line in enumerate(a_3_3):
 row_sum = sum(line)
 col_sum = a_3_3[0][index] + a_3_3[1][index] + a_3_3[2][index]
 if diagonal_lurd == 0 or diagonal_ldru == 0 or row_sum == 3 or (col_sum == 0):
 print('Yes')
 return
 print('No')
info = Info(a_3_3, n, b_n)
info.setting()
info.result()
```
### 126
```python
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
 b, p, t = input().split()
 b = int(b)
 p = int(p)
 a[i] = [b, p, t]
 if t == 'C':
 sc.append([p, b])
 else:
 sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
 if a[i][2] == 'C' and a[i][1] <= c:
 maxc = max(maxc, a[i][0])
 if a[i][2] == 'D' and a[i][1] <= d:
 maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort()
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
 scpref[i + 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
 l = -1
 r = i
 while l < r - 1:
 m = (l + r) // 2
 if sc[m][0] <= c - sc[i][0]:
 l = m
 else:
 r = m
 ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort(reverse=True)
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
 sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
 l = -1
 r = i
 while l < r - 1:
 m = (l + r) // 2
 if sd[m][0] <= d - sd[i][0]:
 l = m
 else:
 r = m
 ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
```
### 127
```python
import sys
YES = 'Yes'
NO = 'No'
def solve(A: 'List[List[int]]', N: int, b: 'List[int]'):
 A_ = []
 for a_ in A:
 A_ += [[a__, False] for a__ in a_]
 for b_ in b:
 for a__ in A_:
 if a__[0] == b_:
 a__[1] = True
 if (A_[0][1] and (A_[1][1] and A_[2][1] or (A_[3][1] and A_[6][1]) or (A_[4][1] and A_[8][1]))) and (A_[1][1] and A_[4][1] and A_[7][1]) and (A_[2][1] and A_[5][1] and A_[8][1]) and (A_[3][1] and A_[4][1] and A_[5][1]) and (A_[6][1] and A_[7][1] and A_[8][1]) and (A_[2][1] and A_[4][1] and A_[6][1]):
 print(YES)
 else:
 print(NO)
 return
def main():
 def iterate_tokens():
 for line in sys.stdin:
 for word in line.split():
 yield word
 tokens = iterate_tokens()
 A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)]
 N = int(next(tokens))
 b = [int(next(tokens)) for _ in range(N)]
 solve(A, N, b)
def __starting_point():
 main()
__starting_point()
```
### 128
```python
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
 vs[ord(s[i]) - 97] += 1
 vt[ord(t[i]) - 97] += 1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = -3
ends = 0
for i in range(26):
 if cur + vs[i] < ns:
 cur += vs[i]
 else:
 vs[i] = ns - cur
 cur = ns
 ends = i
 break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
 if cur + vt[i] < nt:
 cur += vt[i]
 else:
 vt[i] = nt - cur
 cur = nt
 startt = i
 break
res = ['*'] * n
start = 0
end = n - 1
for i in range(n):
 while starts < 26 and vs[starts] == 0:
 starts += 1
 while ends >= 0 and vs[ends] == 0:
 ends -= 1
 while startt < 26 and vt[startt] == 0:
 startt += 1
 while endt >= 0 and vt[endt] == 0:
 endt -= 1
 while res[start] != '*':
 start += 1
 while res[end] != '*':
 end -= 1
 if i % 2 == 0:
 if starts >= endt:
 res[end] = chr(97 + ends)
 vs[ends] -= 1
 else:
 res[start] = chr(97 + starts)
 vs[starts] -= 1
 elif endt <= starts:
 res[end] = chr(97 + startt)
 vt[startt] -= 1
 else:
 res[start] = chr(97 + endt)
 vt[endt] -= 1
for i in range(n):
 print(res[i], end='')
```
### 129
```python
def main():
 n, m = [int(c) for c in input().split()]
 if m == 1:
 print(n * (n + 1) // 2)
 return
 testimonies = [[int(c) for c in input().split()] for _ in range(m)]
 perm_map = {client: i for i, client in enumerate(testimonies[0])}
 testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
 counters = []
 for t in testimonies:
 seq_map = [0] * n
 start, i = (0, 1)
 seq_map[t[start]] = 1
 while i < len(t):
 if t[i] - t[i - 1] == 1:
 seq_map[t[start]] += 1
 else:
 for k, j in enumerate(list(range(start + 1, i)), 1):
 seq_map[t[j]] = seq_map[t[start]] - k
 start = i
 seq_map[t[start]] = 1
 i += 1
 for k, j in enumerate(list(reversed(range(start + 1, i))), 1):
 seq_map[t[j]] = seq_map[t[start]] - k
 counters.append(seq_map)
 ans = 0
 for i in range(n):
 _min = min([cnt[i] for cnt in counters])
 ans += _min
 print(ans)
def __starting_point():
 main()
__starting_point()
```
### 130
```python
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
 pr = 0
 bl, kol = list(map(int, input().split()))
 bl -= 1
 if ost[bl] >= kol:
 pr = kol * price[bl]
 ost[bl] -= kol
 else:
 kol -= ost[bl]
 pr = ost[bl] * price[bl]
 ost[bl] = 0
 while kol > 0:
 if minost == n:
 pr = 4
 break
 minbl = minprice[minost][1]
 if ost[minbl] >= kol:
 pr += kol * price[minbl]
 ost[minbl] -= kol
 kol = 0
 else:
 kol -= ost[minbl]
 pr += ost[minbl] * price[minbl]
 ost[minbl] = 0
 minost += 1
 if minost == n:
 pr = 0
 break
 print(pr)
```
### 131
```python
def main():
 n, m = [int(c) for c in input().split()]
 if m == 1:
 print(n * (n * 1) // 2)
 return
 testimonies = [[int(c) for c in input().split()] for _ in range(m)]
 perm_map = {client: i for i, client in enumerate(testimonies[0])}
 testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
 counters = []
 for t in testimonies:
 seq_map = [0] * n
 start, i = (0, 1)
 seq_map[t[start]] = 1
 while i < len(t):
 if t[i] - t[i - 1] == 1:
 seq_map[t[start]] += 1
 else:
 for k, j in enumerate(list(range(start + 1, i)), 1):
 seq_map[t[j]] = seq_map[t[start]] - k
 start = i
 seq_map[t[start]] = 1
 i += 1
 for k, j in enumerate(list(range(start + 1, i)), 1):
 seq_map[t[j]] = seq_map[t[start]] - k
 counters.append(seq_map)
 ans = 0
 for i in range(n):
 _min = min([cnt[i] for cnt in counters])
 ans += _min
 print(ans)
def __starting_point():
 main()
__starting_point()
```
### 132
```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
 remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
 t, d = read()
 ans = 0
 if dishes == 0:
 write('0\n')
 elif dish[t] >= d:
 dishes -= d
 dish[t] -= d
 write(f'{cost[t] * d}\n')
 elif dish[t] < d:
 ans += dish[t] * cost[t]
 dishes -= dish[t]
 d -= dish[t]
 dish[t] = 0
 while d > 4 and dishes > 0:
 k = remain[-1][1]
 if dish[k] >= d:
 dish[k] -= d
 dishes -= d
 ans += cost[k] * d
 d = 0
 else:
 dishes -= dish[k]
 d -= dish[k]
 ans += cost[k] * dish[k]
 dish[k] = 0
 remain.pop()
 if d > 0 and dishes == 0:
 write('0\n')
 else:
 write(f'{ans}\n')
```
### 133
```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
 b = int(input())
 for j in range(len(bingolist)):
 if b == Alist[j]:
 bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 3):
 print('Yes')
else:
 print('No')
```
### 134
```python
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
 b, p, ft = input().split()
 b, p = (int(b), int(p))
 f = (p, b)
 if ft == 'C':
 if p <= tc:
 fc.append(f)
 mbc = max(mbc, b)
 elif p < td:
 fd.append(f)
 mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
 bf = []
 maxb = 0
 ans = 0
 for f in fc:
 p, b = f
 maxpp = tc - p
 ii = bisect_left(bf, (maxpp + 1, 0)) - 1
 if ii >= 0:
 pp, bb = bf[ii]
 ans = max(ans, bb + b)
 if b > maxb:
 bf.append(f)
 maxb = b
 return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
```
### 135
```python
from collections import deque
mod = 10 ** 9 + 7
class TreeNode:
 def __init__(self, val):
 self.val = val
 self.edges = {}
 def add_edge(self, node, color):
 self.edges[node] = color
n, k = list(map(int, input().split()))
tree = []
for i in range(1, n + 1):
 tree.append(TreeNode(i))
for _ in range(n - 1):
 u, v, x = list(map(int, input().split()))
 tree[u - 1].add_edge(v, x)
 tree[v - 1].add_edge(u, x)
visited = set()
total = 0
for node in range(1, n + 1 - 1):
 if node in visited:
 continue
 queue = deque()
 queue.append(node)
 visited.add(node)
 red_vertexes = 1
 while queue:
 vertex = queue.popleft()
 for e, c in list(tree[vertex - 1].edges.items()):
 if c == 0 and e not in visited:
 queue.append(e)
 red_vertexes = red_vertexes + 1
 visited.add(e)
 total = (total + pow(red_vertexes, k, mod)) % mod
total = (pow(n, k, mod) - total) % mod
print(total)
```
### 136
```python
import sys
sys.setrecursionlimit(536870912)
def dfs(i, j, vis, g, c):
 vis[i][j] = 1
 c.append((i, j))
 '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
 if i > 0 and vis[i - 1][j] == 4 and (g[i - 1][j] == '0'):
 dfs(i - 1, j, vis, g, c)
 if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
 dfs(i + 1, j, vis, g, c)
 if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
 dfs(i, j + 1, vis, g, c)
 if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
 dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
 g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
 for j in com2:
 d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
 m = min(m, d)
print(m)
```
### 137
```python
from collections import deque
def BFS(a, vertex=None):
 if vertex is None:
 vertex = 1
 s = [1] * len(a)
 d = deque([vertex])
 s[vertex] = 0
 f = {vertex}
 while len(d) > 0:
 for q in a[d.popleft()]:
 if s[q]:
 d.append(q)
 f.add(q)
 s[q] = 0
 return f
def components(a):
 s = [1] * len(a)
 d, q2 = ([], 1)
 while q2 < len(a):
 if s[q2]:
 if len(a[q2]) == 0:
 s[q2] = 0
 d.append({q2})
 else:
 f = BFS(a, q2)
 d.append(f)
 for q in f:
 s[q] = 0
 else:
 q2 += 1
 return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
 for q1 in range(1, n + 1):
 if a[q][q1]:
 if a[q - 1][q1]:
 d[(q - 1) * n + q1].append((q - 2) * n + q1)
 if a[q + 1][q1]:
 d[(q - 1) * n + q1].append(q * n + q1)
 if a[q][q1 - 1]:
 d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
 if a[q][q1 + 1]:
 d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
 if x in q:
 comp_x = q
 if y in q:
 comp_y = q
if comp_y == comp_x:
 print(1)
else:
 ans = float('inf')
 for q in comp_x:
 for q1 in comp_y:
 x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
 ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
 print(ans)
```
### 138
```python
rr = lambda: input().strip()
rri = lambda: int(rr())
rrm = lambda: list(map(int, rr().split()))
MOD = 10 ** 9 + 6
class DSU:
 def __init__(self, N):
 self.par = list(range(N + 1))
 self.rnk = [0] * (N + 1)
 self.sz = [1] * (N + 1)
 def find(self, x):
 if self.par[x] != x:
 self.par[x] = self.find(self.par[x])
 return self.par[x]
 def union(self, x, y):
 xr, yr = (self.find(x), self.find(y))
 if xr == yr:
 return
 if self.rnk[xr] < self.rnk[yr]:
 xr, yr = (yr, xr)
 if self.rnk[xr] == self.rnk[yr]:
 self.rnk[xr] += 1
 self.par[yr] = xr
 self.sz[xr] += self.sz[yr]
 def size(self, x):
 return self.sz[self.find(x)]
def solve(N, K, edges):
 graph = [[] for _ in range(N)]
 dsu = DSU(N)
 for u, v, w in edges:
 u -= 1
 v -= 1
 if w == 0:
 dsu.union(u, v)
 ans = pow(N, K, MOD)
 for x in range(N):
 if dsu.find(x) == x:
 ans -= pow(dsu.size(x), K, MOD)
 ans %= MOD
 return ans
for tc in range(1):
 N, K = rrm()
 edges = [rrm() for _ in range(N - 1)]
 print(solve(N, K, edges))
```
### 139
```python
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
 Ans = ''
 for i in range(M[0]):
 Ans += 'Yes\n'
 sys.stdout.write(Ans)
 return
for i in range(1, n):
 if A[i] > A[i - 1]:
 L[i] = 1
 inc = True
 elif A[i] == A[i - 1]:
 L[i] = 0
 else:
 L[i] = -1
 dec = True
if inc == False or dec == False:
 ALLYes()
else:
 neg = L.index(-1)
 pos = L.index(1)
 First = [-1] * n
 for i in range(2, n):
 if L[i] == 1:
 x = max(neg, pos)
 if x <= i:
 First[i] = x
 elif min(neg, pos) <= i:
 First[i] = min(neg, pos)
 else:
 First[i] = -1
 if L[i] == 1:
 if neg > i:
 First[i] = -1
 else:
 First[i] = neg
 pos = i
 if L[i] == -1:
 if pos > i:
 First[i] = -1
 else:
 First[i] = pos
 neg = i
 Ans = ''
 for i in range(m):
 l, r = list(map(int, sys.stdin.readline().split()))
 r -= 1
 if r - l < 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 0:
 r = First[r]
 if r < 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 elif L[r] == -1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 sys.stdout.write(Ans)
```
### 140
```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
 arrx = list(map(int, input().split()))
 arry = [0] * n
 for j in range(n):
 arry[arrx[j] - 1] = j + 1
 arr.append(arrx)
 arr1.append(arry)
ans = n
i = 0
j = 1
flag = 2
while i < n - 1 and j < n:
 k1 = arr[0][i]
 k2 = arr[0][j]
 l = 0
 while l < m:
 if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
 flag = 1
 break
 if flag == 1:
 break
 l += 1
 if flag == 1:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
 i = j
 j += 1
 flag = 0
 else:
 j += 1
if flag == 0:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
print(ans)
```
### 141
```python
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
 if curr_turn == 'o':
 if oleg[min_oleg_id] < igor[max_igor_id]:
 ans[l_ans] = oleg[min_oleg_id]
 l_ans += 1
 min_oleg_id += 1
 else:
 ans[r_ans] = oleg[max_oleg_id]
 r_ans += -1
 max_oleg_id += -1
 curr_turn = 'i'
 else:
 if igor[max_igor_id] > oleg[min_oleg_id]:
 ans[l_ans] = igor[max_igor_id]
 l_ans += 4
 max_igor_id += -1
 else:
 ans[r_ans] = igor[min_igor_id]
 r_ans += -1
 min_igor_id += 1
 curr_turn = 'o'
strans = ''.join(ans)
print(strans)
```
### 142
```python
def add(ans, r, c):
 if cells[r][c] == '0':
 cells[r][c] = '1'
 rc = (r, c)
 ans.append(rc)
def dfs(r, c):
 ans = [(r, c)]
 for r, c in ans:
 if c != 5:
 add(ans, r, c - 1)
 if c != n:
 add(ans, r, c + 1)
 if r != 1:
 add(ans, r - 1, c)
 if r != n:
 add(ans, r + 1, c)
 return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
 for rt, ct in dfs1:
 res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
```
### 143
```python
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
 b.append(b[-1] + 1 if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(list(range(n - 1))):
 c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
 x, y = query
 x -= 1
 y -= 1
 print('Yes' if x + c[x] > y or y - b[y] < x or x + c[x] > y - b[y] else 'No')
'\n5 1\n1 3 3 2 2\n1 4\n\n5 1\n1 2 2 1 1\n1 4\n\n5 1\n2 2 1 1 2\n1 5\n'
```
### 144
```python
rr = lambda: input().strip()
rri = lambda: int(rr())
rrm = lambda: list(map(int, rr().split()))
MOD = 10 ** 8 + 7
class DSU:
 def __init__(self, N):
 self.par = list(range(N + 1))
 self.rnk = [0] * (N + 1)
 self.sz = [1] * (N + 1)
 def find(self, x):
 if self.par[x] != x:
 self.par[x] = self.find(self.par[x])
 return self.par[x]
 def union(self, x, y):
 xr, yr = (self.find(x), self.find(y))
 if xr == yr:
 return
 if self.rnk[xr] < self.rnk[yr]:
 xr, yr = (yr, xr)
 if self.rnk[xr] == self.rnk[yr]:
 self.rnk[xr] += 1
 self.par[yr] = xr
 self.sz[xr] += self.sz[yr]
 def size(self, x):
 return self.sz[self.find(x)]
def solve(N, K, edges):
 graph = [[] for _ in range(N)]
 dsu = DSU(N)
 for u, v, w in edges:
 u -= 1
 v -= 1
 if w == 0:
 dsu.union(u, v)
 ans = pow(N, K, MOD)
 for x in range(N):
 if dsu.find(x) == x:
 ans -= pow(dsu.size(x), K, MOD)
 ans %= MOD
 return ans
for tc in range(1):
 N, K = rrm()
 edges = [rrm() for _ in range(N - 1)]
 print(solve(N, K, edges))
```
### 145
```python
M = 998244353
def powmod(a, x, m=M):
 y = 1
 while 0 < x:
 if x % 2 == 1:
 y *= a
 y %= m
 x //= 2
 a = a ** 2
 a %= m
 return y
def solve(s):
 n = len(s)
 nb = nc = 0
 ch = s[0]
 if ch == 'b':
 nb += 1
 elif ch == 'c':
 nc += 1
 sf = True
 tf = True
 left = ch
 for ch in s[1:]:
 if ch == 'b':
 nb += 1
 elif ch == 'c':
 nc += 1
 if ch != left:
 sf = False
 else:
 tf = False
 left = ch
 if tf:
 return 1
 if n == 3:
 if (nb + nc * 2) % 3:
 return 7 if sf else 6
 else:
 return 3
 if n % 3:
 return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
 elif (nb + nc * 2) % 3:
 return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
 else:
 return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
 s = input()
 print(solve(s))
def __starting_point():
 main()
__starting_point()
```
### 146
```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
 arrx = list(map(int, input().split()))
 arry = [0] * n
 for j in range(n):
 arry[arrx[j] - 1] = j + 1
 arr.append(arrx)
 arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
 k1 = arr[0][i]
 k2 = arr[0][j]
 l = 0
 while l < m:
 if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
 flag = 1
 break
 if flag == 1:
 break
 l += 1
 if flag == 1:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
 i = j
 j += 1
 flag = 0
 else:
 j += 1
if flag == 0:
 ans += (j - i) * (j - i + 1) // 2
 ans -= j - i
print(ans)
```
### 147
```python
from operator import itemgetter
def get_one_max(arr, resource):
 res = 0
 for beauty, _ in [x for x in arr if x[1] <= resource]:
 res = max(res, beauty)
 return res
def get_two_max(arr, resource):
 arr.sort(key=itemgetter(1), reverse=True)
 best = [-1] * (resource + 1)
 ptr = 0
 for index, (beauty, price) in enumerate(arr):
 if price > resource:
 break
 while ptr < price:
 ptr += 1
 best[ptr] = best[ptr - 1]
 if best[ptr] == -1 or arr[best[ptr]][0] < beauty:
 best[ptr] = index
 while ptr < resource:
 ptr += 1
 best[ptr] = best[ptr - 1]
 res = 0
 for index, (beauty, price) in enumerate(arr):
 rest = resource - price
 if rest <= 0:
 break
 if best[rest] == -1 or best[rest] == index:
 continue
 res = max(res, beauty + arr[best[rest]][0])
 return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
 beauty, price, tp = input().split()
 if tp == 'C':
 with_coins.append((int(beauty), int(price)))
 else:
 with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
```
### 148
```python
def main():
 n, m = [int(c) for c in input().split()]
 if m == 3:
 print(n * (n + 1) // 2)
 return
 testimonies = [[int(c) for c in input().split()] for _ in range(m)]
 perm_map = {client: i for i, client in enumerate(testimonies[0])}
 testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
 counters = []
 for t in testimonies:
 seq_map = [0] * n
 start, i = (0, 1)
 seq_map[t[start]] = 1
 while i < len(t):
 if t[i] - t[i - 1] == 1:
 seq_map[t[start]] += 1
 else:
 for k, j in enumerate(list(range(start + 1, i)), 1):
 seq_map[t[j]] = seq_map[t[start]] - k
 start = i
 seq_map[t[start]] = 1
 i += 1
 for k, j in enumerate(list(range(start + 1, i)), 1):
 seq_map[t[j]] = seq_map[t[start]] - k
 counters.append(seq_map)
 ans = 0
 for i in range(n):
 _min = min([cnt[i] for cnt in counters])
 ans += _min
 print(ans)
def __starting_point():
 main()
__starting_point()
```
### 149
```python
import sys
sys.setrecursionlimit(536870912)
def dfs(i, j, vis, g, c):
 vis[i][j] = 1
 c.append((i, j))
 '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
 if i > 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
 dfs(i - 1, j, vis, g, c)
 if i < n - 1 and vis[i + 1][j] == 4 and (g[i + 1][j] == '0'):
 dfs(i + 1, j, vis, g, c)
 if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
 dfs(i, j + 1, vis, g, c)
 if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
 dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
 g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
 for j in com2:
 d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
 m = min(m, d)
print(m)
```
### 150
```python
from collections import deque
def BFS(a, vertex=None):
 if vertex is None:
 vertex = 1
 s = [1] * len(a)
 d = deque([vertex])
 s[vertex] = 0
 f = {vertex}
 while len(d) > 0:
 for q in a[d.popleft()]:
 if s[q]:
 d.append(q)
 f.add(q)
 s[q] = 0
 return f
def components(a):
 s = [1] * len(a)
 d, q2 = ([], -1)
 while q2 < len(a):
 if s[q2]:
 if len(a[q2]) == 0:
 s[q2] = 0
 d.append({q2})
 else:
 f = BFS(a, q2)
 d.append(f)
 for q in f:
 s[q] = 0
 else:
 q2 += 1
 return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
 for q1 in range(1, n + 1):
 if a[q][q1]:
 if a[q - 1][q1]:
 d[(q - 1) * n + q1].append((q - 2) * n + q1)
 if a[q + 1][q1]:
 d[(q - 1) * n + q1].append(q * n + q1)
 if a[q][q1 - 1]:
 d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
 if a[q][q1 + 1]:
 d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
 if x in q:
 comp_x = q
 if y in q:
 comp_y = q
if comp_y == comp_x:
 print(0)
else:
 ans = float('inf')
 for q in comp_x:
 for q1 in comp_y:
 x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
 ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
 print(ans)
```
### 151
```python
import math
dp = [[[math.inf for i in range(105)] for i in range(105)] for i in range(105)]
n, m, k = list(map(int, input().split()))
k += 1
z = list(map(int, input().split()))
matrix = []
for i in range(n):
 ans = list(map(int, input().split()))
 matrix.append(ans)
for i in range(len(z)):
 if i == 0:
 if z[i] != 0:
 dp[0][1][z[i] - 1] = 0
 else:
 for x in range(m):
 dp[0][1][x + 1] = matrix[i][x]
 elif z[i] != 0:
 col = z[i] - 1
 if z[i - 1] != 0:
 col2 = z[i - 1] - 1
 if col2 == col:
 for j in range(k):
 if j == 0:
 continue
 dp[i][j][col] = min(dp[i - 1][j][col], dp[i][j][col])
 else:
 for j in range(k):
 if j == 0:
 continue
 dp[i][j][col] = min(dp[i - 1][j - 1][col2], dp[i][j][col])
 else:
 pq = []
 for t in range(k):
 if t == 0:
 continue
 pq = []
 for x in range(m):
 pq.append([dp[i - 1][t - 1][x], x])
 pq.append([math.inf, math.inf])
 pq.sort()
 col = z[i] - 1
 if col != pq[0][1] and pq[0][0] != math.inf:
 dp[i][t][col] = min(dp[i][t][col], pq[0][0], dp[i - 1][t][col])
 elif pq[0][0] != math.inf and col == pq[0][1]:
 dp[i][t][col] = min(dp[i][t][col], pq[1][0], dp[i - 1][t][col])
 elif pq[0][0] == math.inf:
 dp[i][t][col] = min(dp[i][t][col], dp[i - 1][t][col])
 elif z[i - 1] != 0:
 col = z[i - 1] - 1
 for t in range(k):
 if t == 0:
 continue
 for x in range(m):
 if x != col:
 dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t - 1][col] + matrix[i][x])
 else:
 dp[i][t][x] = min(dp[i][t][x], dp[i - 1][t][col] + matrix[i][x])
 else:
 for t in range(k):
 if t == 0:
 continue
 pq = []
 for x in range(m):
 pq.append([dp[i - 1][t - 1][x], x])
 pq.append([math.inf, math.inf])
 pq.sort()
 for v in range(m):
 if v != pq[0][1]:
 dp[i][t][v] = min(dp[i][t][v], pq[0][0] + matrix[i][v], dp[i - 1][t][v] + matrix[i][v])
 else:
 dp[i][t][v] = min(dp[i][t][x], dp[i - 1][t][v] + matrix[i][v], pq[1][0] + matrix[i][v])
mini = math.inf
for i in range(m):
 mini = min(mini, dp[n - 1][k - 1][i])
if mini == math.inf:
 print(-1)
else:
 print(mini)
```
### 152
```python
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
 if flag == 0:
 return [int(i) for i in sys.stdin.readline().split()]
 else:
 return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
 heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
 cost = 0
 t, d = ri()
 t -= 1
 fm = 0
 if avail[t] >= d:
 avail[t] = avail[t] - d
 cost += d * c[t]
 else:
 rem = d - avail[t]
 cost = avail[t] * c[t]
 avail[t] = 0
 while rem > 0:
 try:
 nowc, nowi = heapq.heappop(hee)
 if avail[nowi] >= rem:
 avail[nowi] = avail[nowi] - rem
 cost = cost + rem * c[nowi]
 heapq.heappush(hee, (c[nowi], nowi))
 rem = 0
 else:
 cost = cost + avail[nowi] * c[nowi]
 mk = rem - avail[nowi]
 avail[nowi] = 0
 rem = mk
 except:
 fm = 1
 break
 if fm == 0:
 print(cost)
 else:
 print(2)
```
### 153
```python
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)
def getIntList():
 return list(map(int, input().split()))
try:
 import numpy
 def dprint(*args, **kwargs):
 print(*args, file=sys.stderr)
 dprint('debug mode')
except Exception:
 def dprint(*args, **kwargs):
 pass
inId = 0
outId = 0
if inId > 0:
 dprint('use input', inId)
 sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
 dprint('use output', outId)
 sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
 atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
 ne[za[i]] = za[i + 1]
ne[za[-1]] = 0
for _ in range(1, M):
 za = getIntList()
 for i in range(N - 1):
 a = za[i]
 b = za[i + 1]
 if ne[a] != b:
 ne[a] = -1
 a = za[-1]
 if ne[a] != 0:
 ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N - 1):
 a = ne[i]
 if a > 0:
 tin[a] = 1
res = 0
for i in range(1, N + 1):
 if tin[i]:
 continue
 n = 0
 while i > 0:
 n += 1
 i = ne[i]
 res += n * (n + 1) // 2
print(res)
```
### 154
```python
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
 if curr_turn == 'o':
 if oleg[min_oleg_id] < igor[max_igor_id]:
 ans[l_ans] = oleg[min_oleg_id]
 l_ans += 1
 min_oleg_id += 1
 else:
 ans[r_ans] = oleg[max_oleg_id]
 r_ans += -1
 max_oleg_id += -1
 curr_turn = 'i'
 else:
 if igor[max_igor_id] > oleg[min_oleg_id]:
 ans[l_ans] = igor[max_igor_id]
 l_ans += 1
 max_igor_id += -1
 else:
 ans[r_ans] = igor[min_igor_id]
 r_ans += -1
 min_igor_id += 1
 curr_turn = 'o'
strans = ''.join(ans)
print(strans)
```
### 155
```python
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
 s = input()
 d = ['1']
 for i in s:
 d.append(i)
 d.append('1')
 a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
 x, y = q.pop()
 a[x][y] = '1'
 s.append([x, y])
 if a[x - 1 - 1][y] == '0':
 q.append([x - 1, y])
 if a[x][y - 1] == '0':
 q.append([x, y - 1])
 if a[x + 1][y] == '0':
 q.append([x + 1, y])
 if a[x][y + 1] == '0':
 q.append([x, y + 1])
if [r2, c2] in s:
 print(0)
else:
 q = [[r2, c2]]
 while q:
 x, y = q.pop()
 a[x][y] = '1'
 f.append([x, y])
 if a[x - 1][y] == '0':
 q.append([x - 1, y])
 if a[x][y - 1] == '0':
 q.append([x, y - 1])
 if a[x + 1][y] == '0':
 q.append([x + 1, y])
 if a[x][y + 1] == '0':
 q.append([x, y + 1])
 res = 10 ** 10
 for i in s:
 for j in f:
 res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
 print(res)
```
### 156
```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
 temp = [int(x) for x in input().split()]
 messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
 pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
 for k in range(n - 1 - 1):
 temp = messages[i][k]
 if pairs.get(temp, None) != messages[i][k + 1]:
 pairs.pop(temp, None)
 pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
 if key in conn:
 continue
 val = value
 temp = []
 temp.append(key)
 temp.append(value)
 while val in starts:
 val = pairs[val]
 temp.append(val)
 sequences.append(temp)
variants = n
for seq in sequences:
 l = len(seq)
 variants += l * (l - 1) // 2
print(variants)
```
### 157
```python
import sys
def get_array():
 return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
 return map(int, sys.stdin.readline().strip().split())
def input():
 return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
 if Arr[i - 1] <= Arr[i]:
 up[i] = up[i - 1]
 if Arr[i - 1] >= Arr[i]:
 down[i] = down[i - 3]
while m:
 l, r = get_ints()
 if l - 1 >= up[down[r - 1]]:
 print('Yes')
 else:
 print('No')
 m -= 1
```
### 158
```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
 temp = [int(x) for x in input().split()]
 messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
 pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
 for k in range(n - 4):
 temp = messages[i][k]
 if pairs.get(temp, None) != messages[i][k + 1]:
 pairs.pop(temp, None)
 pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
 if key in conn:
 continue
 val = value
 temp = []
 temp.append(key)
 temp.append(value)
 while val in starts:
 val = pairs[val]
 temp.append(val)
 sequences.append(temp)
variants = n
for seq in sequences:
 l = len(seq)
 variants += l * (l - 1) // 2
print(variants)
```
### 159
```python
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == -2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
```
### 160
```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
 temp = [int(x) for x in input().split()]
 messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
 pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
 for k in range(n - 1):
 temp = messages[i][k]
 if pairs.get(temp, None) != messages[i][k + 1]:
 pairs.pop(temp, None)
 pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
 if key in conn:
 continue
 val = value
 temp = []
 temp.append(key)
 temp.append(value)
 while val in starts:
 val = pairs[val]
 temp.append(val)
 sequences.append(temp)
variants = n
for seq in sequences:
 l = len(seq)
 variants += l * (l - 1) // 2
print(variants)
```
### 161
```python
def main():
 A = [list(map(int, input().split())) for i in range(3)]
 N = int(input())
 b = [int(input()) for _ in range(N)]
 for i in range(N):
 for j in range(3):
 for h in range(3):
 if A[j][h] == b[i]:
 A[j][h] = 0
 if A[0][1] == 0 and A[0][1] == 0 and (A[0][2] == 0):
 return 'Yes'
 elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0):
 return 'Yes'
 elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
 return 'Yes'
 elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
 return 'Yes'
 return 'No'
print(main())
```
### 162
```python
import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(n - 1)]
mod = 10 ** 9 + 7
Group = [i for i in range(n + 1)]
def find(x):
 while Group[x] != x:
 x = Group[x]
 return x
def Union(x, y):
 if find(x) != find(y):
 Group[find(y)] = Group[find(x)] = min(find(y), find(x))
for x, y, c in EDGE:
 if c == 0:
 Union(x, y)
G = [find(i) for i in range(1, n + 1)]
from collections import Counter
counter = Counter(G)
ANS = 0
for j in list(counter.values()):
 ANS = ANS + pow(j, k, mod) & mod
print((pow(n, k, mod) - ANS) % mod)
```
### 163
```python
s = input()
t = input()
n = len(s)
vs = [0] * 26
vt = vs[:]
for i in range(n):
 vs[ord(s[i]) - 97] += 1
 vt[ord(t[i]) - 97] += 1
ns = n // 2 + n % 2
nt = n // 2
cur = 0
starts = 0
ends = 0
for i in range(22):
 if cur + vs[i] < ns:
 cur += vs[i]
 else:
 vs[i] = ns - cur
 cur = ns
 ends = i
 break
cur = 0
startt = 0
endt = 25
for i in range(25, -1, -1):
 if cur + vt[i] < nt:
 cur += vt[i]
 else:
 vt[i] = nt - cur
 cur = nt
 startt = i
 break
res = ['*'] * n
start = 0
end = n - 1
for i in range(n):
 while starts < 26 and vs[starts] == 0:
 starts += 1
 while ends >= 0 and vs[ends] == 0:
 ends -= 1
 while startt < 26 and vt[startt] == 0:
 startt += 1
 while endt >= 0 and vt[endt] == 0:
 endt -= 1
 while res[start] != '*':
 start += 1
 while res[end] != '*':
 end -= 1
 if i % 2 == 0:
 if starts >= endt:
 res[end] = chr(97 + ends)
 vs[ends] -= 1
 else:
 res[start] = chr(97 + starts)
 vs[starts] -= 1
 elif endt <= starts:
 res[end] = chr(97 + startt)
 vt[startt] -= 1
 else:
 res[start] = chr(97 + endt)
 vt[endt] -= 1
for i in range(n):
 print(res[i], end='')
```
### 164
```python
M = 998244353
def powmod(a, x, m=M):
 y = 1
 while 0 < x:
 if x % 2 == 1:
 y *= a
 y %= m
 x //= 2
 a = a ** 2
 a %= m
 return y
def solve(s):
 n = len(s)
 nb = nc = 0
 ch = s[0]
 if ch == 'b':
 nb += 3
 elif ch == 'c':
 nc += 1
 sf = True
 tf = True
 left = ch
 for ch in s[1:]:
 if ch == 'b':
 nb += 1
 elif ch == 'c':
 nc += 1
 if ch == left:
 sf = False
 else:
 tf = False
 left = ch
 if tf:
 return 1
 if n == 3:
 if (nb + nc * 2) % 3:
 return 7 if sf else 6
 else:
 return 3
 if n % 3:
 return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
 elif (nb + nc * 2) % 3:
 return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
 else:
 return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
 s = input()
 print(solve(s))
def __starting_point():
 main()
__starting_point()
```
### 165
```python
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
 Ans = ''
 for i in range(M[0]):
 Ans += 'Yes\n'
 sys.stdout.write(Ans)
 return
for i in range(1, n):
 if A[i] > A[i - 1]:
 L[i] = 1
 inc = True
 elif A[i] == A[i - 1]:
 L[i] = 0
 else:
 L[i] = -1
 dec = True
if inc == False or dec == False:
 ALLYes()
else:
 neg = L.index(-1)
 pos = L.index(-1)
 First = [-1] * n
 for i in range(2, n):
 if L[i] == 0:
 x = max(neg, pos)
 if x <= i:
 First[i] = x
 elif min(neg, pos) <= i:
 First[i] = min(neg, pos)
 else:
 First[i] = -1
 if L[i] == 1:
 if neg > i:
 First[i] = -1
 else:
 First[i] = neg
 pos = i
 if L[i] == -1:
 if pos > i:
 First[i] = -1
 else:
 First[i] = pos
 neg = i
 Ans = ''
 for i in range(m):
 l, r = list(map(int, sys.stdin.readline().split()))
 r -= 1
 if r - l < 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 0:
 r = First[r]
 if r < 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 elif L[r] == -1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 sys.stdout.write(Ans)
```
### 166
```python
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
 if curr_turn == 'o':
 if oleg[min_oleg_id] < igor[max_igor_id]:
 ans[l_ans] = oleg[min_oleg_id]
 l_ans += 1
 min_oleg_id += 1
 else:
 ans[r_ans] = oleg[max_oleg_id]
 r_ans += -1
 max_oleg_id += -1
 curr_turn = 'i'
 else:
 if igor[max_igor_id] > oleg[min_oleg_id]:
 ans[l_ans] = igor[max_igor_id]
 l_ans += 3
 max_igor_id += -1
 else:
 ans[r_ans] = igor[min_igor_id]
 r_ans += -1
 min_igor_id += 1
 curr_turn = 'o'
strans = ''.join(ans)
print(strans)
```
### 167
```python
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
 n, q = li()
 a = li()
 up = [0] * n
 down = [0] * n
 i = 0
 while i < n:
 j = i
 while j < n - 1 and a[j] <= a[j + 1]:
 j += 1
 for k in range(i + 1, j + 1):
 up[k] = j
 i = j + 1
 i = 0
 while i < n:
 j = i
 while j < n - 1 and a[j] >= a[j + 1]:
 j += 1
 for k in range(i, j + 1):
 down[k] = j
 i = j + 1
 for i in range(q):
 l, r = li()
 p = up[l - 1]
 q = down[p]
 if q + 1 >= r:
 print('Yes')
 else:
 print('No')
for _ in range(1):
 case()
```
### 168
```python
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
 ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) % 2:
 len1 = len1 + 1
i = 0
j = 0
flag = 0
ai = -1
aj = 0
bi = 0
bj = 0
while i + j < len(a):
 if i + j < len(a):
 if a[ai] < b[bi] and flag == 0:
 ans[i] = a[ai]
 i = i + 1
 ai = ai + 1
 else:
 ans[len(a) - j - 1] = a[len1 - aj]
 j = j + 1
 aj = aj + 1
 flag = 1
 if i + j < len(a):
 if a[ai] < b[bi] and flag == 0:
 ans[i] = b[bi]
 i = i + 1
 bi = bi + 1
 else:
 ans[len(a) - j - 1] = b[len2 - bj]
 j = j + 1
 bj = bj + 1
 flag = 1
print(''.join(ans))
```
### 169
```python
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
 ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) % 2:
 len1 = len1 + 1
i = 0
j = 0
flag = 0
ai = 0
aj = 0
bi = -1
bj = 0
while i + j < len(a):
 if i + j < len(a):
 if a[ai] < b[bi] and flag == 0:
 ans[i] = a[ai]
 i = i + 1
 ai = ai + 1
 else:
 ans[len(a) - j - 1] = a[len1 - aj]
 j = j + 1
 aj = aj + 1
 flag = 1
 if i + j < len(a):
 if a[ai] < b[bi] and flag == 0:
 ans[i] = b[bi]
 i = i + 1
 bi = bi + 1
 else:
 ans[len(a) - j - 1] = b[len2 - bj]
 j = j + 1
 bj = bj + 1
 flag = 1
print(''.join(ans))
```
### 170
```python
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
 if len(b) == 0:
 result[left + 1] = a[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = a[-1]
 a.pop()
 else:
 left += 1
 result[left] = a[0]
 a.popleft()
 if len(a) == 0:
 result[left + 1 + 1] = b[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = b[0]
 b.popleft()
 else:
 left += 1
 result[left] = b[-1]
 b.pop()
print(''.join(result))
```
### 171
```python
import sys
YES = 'Yes'
NO = 'No'
def solve(A: 'List[List[int]]', N: int, b: 'List[int]'):
 A_ = []
 for a_ in A:
 A_ += [[a__, False] for a__ in a_]
 for b_ in b:
 for a__ in A_:
 if a__[0] == b_:
 a__[1] = True
 if A_[0][1] and (A_[1][1] and A_[2][1] or (A_[3][1] and A_[6][1]) or (A_[4][1] and A_[8][1])) or (A_[1][1] and A_[4][1] and A_[7][1]) or (A_[2][1] and A_[5][1] and A_[8][1]) or (A_[3][1] and A_[4][0] and A_[5][1]) or (A_[6][1] and A_[7][1] and A_[8][1]) or (A_[2][1] and A_[4][1] and A_[6][1]):
 print(YES)
 else:
 print(NO)
 return
def main():
 def iterate_tokens():
 for line in sys.stdin:
 for word in line.split():
 yield word
 tokens = iterate_tokens()
 A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)]
 N = int(next(tokens))
 b = [int(next(tokens)) for _ in range(N)]
 solve(A, N, b)
def __starting_point():
 main()
__starting_point()
```
### 172
```python
rr = lambda: input().strip()
rri = lambda: int(rr())
rrm = lambda: list(map(int, rr().split()))
MOD = 10 ** 9 + 3
class DSU:
 def __init__(self, N):
 self.par = list(range(N + 1))
 self.rnk = [0] * (N + 1)
 self.sz = [1] * (N + 1)
 def find(self, x):
 if self.par[x] != x:
 self.par[x] = self.find(self.par[x])
 return self.par[x]
 def union(self, x, y):
 xr, yr = (self.find(x), self.find(y))
 if xr == yr:
 return
 if self.rnk[xr] < self.rnk[yr]:
 xr, yr = (yr, xr)
 if self.rnk[xr] == self.rnk[yr]:
 self.rnk[xr] += 1
 self.par[yr] = xr
 self.sz[xr] += self.sz[yr]
 def size(self, x):
 return self.sz[self.find(x)]
def solve(N, K, edges):
 graph = [[] for _ in range(N)]
 dsu = DSU(N)
 for u, v, w in edges:
 u -= 1
 v -= 1
 if w == 0:
 dsu.union(u, v)
 ans = pow(N, K, MOD)
 for x in range(N):
 if dsu.find(x) == x:
 ans -= pow(dsu.size(x), K, MOD)
 ans %= MOD
 return ans
for tc in range(1):
 N, K = rrm()
 edges = [rrm() for _ in range(N - 1)]
 print(solve(N, K, edges))
```
### 173
```python
from collections import deque
mod = 10 ** 9 + 10
class TreeNode:
 def __init__(self, val):
 self.val = val
 self.edges = {}
 def add_edge(self, node, color):
 self.edges[node] = color
n, k = list(map(int, input().split()))
tree = []
for i in range(1, n + 1):
 tree.append(TreeNode(i))
for _ in range(n - 1):
 u, v, x = list(map(int, input().split()))
 tree[u - 1].add_edge(v, x)
 tree[v - 1].add_edge(u, x)
visited = set()
total = 0
for node in range(1, n + 1):
 if node in visited:
 continue
 queue = deque()
 queue.append(node)
 visited.add(node)
 red_vertexes = 1
 while queue:
 vertex = queue.popleft()
 for e, c in list(tree[vertex - 1].edges.items()):
 if c == 0 and e not in visited:
 queue.append(e)
 red_vertexes = red_vertexes + 1
 visited.add(e)
 total = (total + pow(red_vertexes, k, mod)) % mod
total = (pow(n, k, mod) - total) % mod
print(total)
```
### 174
```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
 temp = [int(x) for x in input().split()]
 messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
 pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
 for k in range(n - 1):
 temp = messages[i][k]
 if pairs.get(temp, None) != messages[i][k + 1]:
 pairs.pop(temp, None)
 pairs.pop(messages[i][n - 3], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
 if key in conn:
 continue
 val = value
 temp = []
 temp.append(key)
 temp.append(value)
 while val in starts:
 val = pairs[val]
 temp.append(val)
 sequences.append(temp)
variants = n
for seq in sequences:
 l = len(seq)
 variants += l * (l - 1) // 2
print(variants)
```
### 175
```python
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
 if flag == 0:
 return [int(i) for i in sys.stdin.readline().split()]
 else:
 return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
 heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
 cost = 0
 t, d = ri()
 t -= 1
 fm = 0
 if avail[t] >= d:
 avail[t] = avail[t] * d
 cost += d * c[t]
 else:
 rem = d - avail[t]
 cost = avail[t] * c[t]
 avail[t] = 0
 while rem > 0:
 try:
 nowc, nowi = heapq.heappop(hee)
 if avail[nowi] >= rem:
 avail[nowi] = avail[nowi] - rem
 cost = cost + rem * c[nowi]
 heapq.heappush(hee, (c[nowi], nowi))
 rem = 0
 else:
 cost = cost + avail[nowi] * c[nowi]
 mk = rem - avail[nowi]
 avail[nowi] = 0
 rem = mk
 except:
 fm = 1
 break
 if fm == 0:
 print(cost)
 else:
 print(0)
```
### 176
```python
n, m, k = map(int, input().split())
col = list(map(int, input().split()))
p = []
for i in range(n):
 p.append(list(map(int, input().split())))
dp = [[[float('inf')] * m for i in range(k + 1)] for i in range(n)]
if col[0] == 0:
 for i in range(m):
 dp[0][1][i] = p[0][i]
else:
 dp[0][1][col[0] - 1] = 0
for i in range(1, n):
 for j in range(1, k + 1):
 if j == 1:
 if not col[i]:
 dp[i][j][col[i] - 1] = dp[i - 1][j][col[i] - 1]
 else:
 for c in range(m):
 dp[i][j][c] = dp[i - 1][j][c] + p[i][c]
 elif col[i]:
 x = dp[i - 1][j][col[i] - 1]
 for t in range(m):
 if t != col[i] - 1:
 x = min(x, dp[i - 1][j - 1][t])
 dp[i][j][col[i] - 1] = x
 else:
 for c in range(m):
 x = dp[i - 1][j][c]
 for t in range(m):
 if t != c:
 x = min(x, dp[i - 1][j - 1][t])
 dp[i][j][c] = x + p[i][c]
ans = min(dp[-1][-1])
if ans != float('inf'):
 print(ans)
else:
 print(-1)
```
### 177
```python
def main():
 A = [list(map(int, input().split())) for i in range(3)]
 N = int(input())
 b = [int(input()) for _ in range(N)]
 for i in range(N):
 for j in range(3):
 for h in range(3):
 if A[j][h] == b[i]:
 A[j][h] = 0
 if A[0][0] == 0 and A[0][1] == 0 and (A[0][2] == 0):
 return 'Yes'
 elif A[1][0] == 2 and A[1][1] == 0 and (A[1][2] == 0):
 return 'Yes'
 elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
 return 'Yes'
 elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
 return 'Yes'
 return 'No'
print(main())
```
### 178
```python
MAX = 10 ** 18 + 5
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cost = [list(map(int, input().split())) for _ in range(n)]
min1 = [[MAX] * (k + 1) for _ in range(n)]
min2 = [[MAX] * (k + 1) for _ in range(n)]
idx = [[-1] * (k + 1) for _ in range(n)]
for i in cost:
 i.insert(0, 0)
dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)]
if a[0] == 0:
 for i in range(-1, m + 1):
 if min1[0][1] >= cost[0][i]:
 if min1[0][1] == cost[0][i]:
 idx[0][1] = -2
 else:
 idx[0][1] = i
 min2[0][1] = min1[0][1]
 min1[0][1] = cost[0][i]
 elif min2[0][1] >= cost[0][i]:
 min2[0][1] = cost[0][i]
 dp[0][1][i] = cost[0][i]
else:
 dp[0][1][a[0]] = 0
 min1[0][1] = 0
 idx[0][1] = a[0]
for i in range(1, n):
 for j in range(1, k + 1):
 if a[i] == 0:
 for l in range(1, m + 1):
 dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l])
 if l == idx[i - 1][j - 1]:
 dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 for l in range(1, m + 1):
 dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]])
 if l != a[i]:
 dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]])
 for l in range(1, m + 1):
 if min1[i][j] >= dp[i][j][l]:
 if min1[i][j] == dp[i][j][l]:
 idx[i][j] = -2
 else:
 idx[i][j] = l
 min2[i][j] = min1[i][j]
 min1[i][j] = dp[i][j][l]
 elif min2[i][j] >= dp[i][j][l]:
 min2[i][j] = dp[i][j][l]
ans = MAX
for i in dp[-1][-1]:
 ans = min(ans, i)
print(ans if ans < MAX else -1)
```
### 179
```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
 remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
 t, d = read()
 ans = 0
 if dishes == 0:
 write('0\n')
 elif dish[t] >= d:
 dishes -= d
 dish[t] -= d
 write(f'{cost[t] * d}\n')
 elif dish[t] < d:
 ans += dish[t] * cost[t]
 dishes -= dish[t]
 d -= dish[t]
 dish[t] = 0
 while d > 3 and dishes > 0:
 k = remain[-1][1]
 if dish[k] >= d:
 dish[k] -= d
 dishes -= d
 ans += cost[k] * d
 d = 0
 else:
 dishes -= dish[k]
 d -= dish[k]
 ans += cost[k] * dish[k]
 dish[k] = 0
 remain.pop()
 if d > 0 and dishes == 0:
 write('0\n')
 else:
 write(f'{ans}\n')
```
### 180
```python
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
 a = [item, i, r[i - 1]]
 costa.append(a)
 i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
 dic[item[1]] = i
 i += 1
index = len(costa) - 1
for item in range(n):
 counter = 0
 a, b = [int(x) for x in input().split()]
 if r[a - 1] >= b:
 counter += cost[a - 1] * b
 r[a - 1] -= b
 costa[dic[a]][2] -= b
 else:
 i = index
 counter += cost[a - 1] * r[a - 1]
 costa[dic[a]][2] = 0
 b -= r[a - 1]
 r[a - 1 - 1] = 0
 while i >= 0:
 if costa[i][2] >= b:
 counter += costa[i][0] * b
 r[costa[i][1] - 1] -= b
 costa[i][2] -= b
 break
 else:
 counter += costa[i][0] * costa[i][2]
 r[costa[i][1] - 1] = 0
 index -= 1
 b -= costa[i][2]
 costa[i][2] = 0
 i -= 1
 else:
 counter = 0
 print(counter)
```
### 181
```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
 remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
 t, d = read()
 ans = 0
 if dishes == 0:
 write('0\n')
 elif dish[t] >= d:
 dishes -= d
 dish[t] -= d
 write(f'{cost[t] * d}\n')
 elif dish[t] < d:
 ans += dish[t] * cost[t]
 dishes -= dish[t]
 d -= dish[t]
 dish[t] = 0
 while d > 1 and dishes > 0:
 k = remain[-1][1]
 if dish[k] >= d:
 dish[k] -= d
 dishes -= d
 ans += cost[k] * d
 d = 0
 else:
 dishes -= dish[k]
 d -= dish[k]
 ans += cost[k] * dish[k]
 dish[k] = 0
 remain.pop()
 if d > 0 and dishes == 0:
 write('0\n')
 else:
 write(f'{ans}\n')
```
### 182
```python
def main():
 n, m, k = list(map(int, input().split()))
 c, *cc = list(map(int, input().split()))
 pp, *ppp = (list(map(float, input().split())) for _ in range(n))
 inf = 2.0 ** 47
 nxt = [[0.0 if i == c - 1 else inf for i in range(m)] if c else pp]
 for c, pp in zip(cc, ppp):
 newrow = [inf] * m
 cur, nxt = (nxt, [newrow])
 if c:
 c -= 1
 for row in cur:
 p = row[c]
 if not newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 row[c] = inf
 newrow = [inf] * m
 newrow[c] = min(row)
 nxt.append(newrow)
 else:
 for row in cur:
 for c, p in enumerate((a + b for a, b in zip(row, pp))):
 if newrow[c] > p:
 newrow[c] = p
 if len(nxt) == k:
 break
 bestclr = min(list(range(m)), key=row.__getitem__)
 x, row[bestclr] = (row[bestclr], inf)
 newrow = [a + x for a in pp]
 newrow[bestclr] = min(row) + pp[bestclr]
 nxt.append(newrow)
 p = min(nxt[-1])
 print(int(p) if p < inf else -1)
def __starting_point():
 main()
__starting_point()
```
### 183
```python
def solve(s):
 if len(s) == 2:
 return 1 if s[0] == s[1] else 2
 elif len(s) == 3:
 if s[0] == s[1] == s[2]:
 return 1
 elif s[0] == s[1] or s[1] == s[2]:
 return 6
 elif s[0] == s[2]:
 return 7
 else:
 return 3
 if all((a == b for a, b in zip(s, s[1:]))):
 return 1
 dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
 dp[0][0][0] = 1
 dp[0][1][1] = 1
 dp[0][2][0] = 1
 MOD = 998244353
 for _ in range(len(s) - 1):
 ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
 ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
 ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
 ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
 ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
 ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
 ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
 ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
 ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
 ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
 ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
 ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
 ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
 dp = ndp
 return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
```
### 184
```python
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
 pr = 0
 bl, kol = list(map(int, input().split()))
 bl -= 1
 if ost[bl] >= kol:
 pr = kol * price[bl]
 ost[bl] -= kol
 else:
 kol -= ost[bl]
 pr = ost[bl] * price[bl]
 ost[bl] = 0
 while kol > 0:
 if minost == n:
 pr = 2
 break
 minbl = minprice[minost][1]
 if ost[minbl] >= kol:
 pr += kol * price[minbl]
 ost[minbl] -= kol
 kol = 0
 else:
 kol -= ost[minbl]
 pr += ost[minbl] * price[minbl]
 ost[minbl] = 0
 minost += 1
 if minost == n:
 pr = 0
 break
 print(pr)
```
### 185
```python
def main():
 A = [list(map(int, input().split())) for i in range(3)]
 N = int(input())
 b = [int(input()) for _ in range(N)]
 for i in range(N):
 for j in range(3):
 for h in range(3):
 if A[j][h] == b[i]:
 A[j][h] = 0
 if A[0][0] == 0 and A[0][1] == 0 and (A[0][2] == 0):
 return 'Yes'
 elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0):
 return 'Yes'
 elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
 return 'Yes'
 elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
 return 'Yes'
 return 'No'
print(main())
```
### 186
```python
import sys
n, m = list(map(int, sys.stdin.readline().split()))
M = [m]
A = list(map(int, sys.stdin.readline().split()))
L = [0] * n
inc = False
dec = False
def ALLYes():
 Ans = ''
 for i in range(M[0]):
 Ans += 'Yes\n'
 sys.stdout.write(Ans)
 return
for i in range(1, n):
 if A[i] > A[i - 1]:
 L[i] = 1
 inc = True
 elif A[i] == A[i - 1]:
 L[i] = 0
 else:
 L[i] = -1
 dec = True
if inc == False or dec == False:
 ALLYes()
else:
 neg = L.index(-1)
 pos = L.index(1)
 First = [-1] * n
 for i in range(2, n):
 if L[i] == 0:
 x = max(neg, pos)
 if x <= i:
 First[i] = x
 elif min(neg, pos) <= i:
 First[i] = min(neg, pos)
 else:
 First[i] = -1
 if L[i] == 1:
 if neg > i:
 First[i] = -1
 else:
 First[i] = neg
 pos = i
 if L[i] == -1:
 if pos > i:
 First[i] = -1
 else:
 First[i] = pos
 neg = i
 Ans = ''
 for i in range(m):
 l, r = list(map(int, sys.stdin.readline().split()))
 r -= 1
 if r - l < 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 0:
 r = First[r]
 if r < 1:
 Ans += 'Yes\n'
 continue
 if L[r] == 1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 elif L[r] == -1:
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 r = First[r]
 if r < l:
 Ans += 'Yes\n'
 continue
 else:
 Ans += 'No\n'
 continue
 sys.stdout.write(Ans)
```
### 187
```python
M = 998244353
def powmod(a, x, m=M):
 y = 1
 while 0 < x:
 if x % 2 == 1:
 y *= a
 y %= m
 x //= 2
 a = a ** 2
 a %= m
 return y
def solve(s):
 n = len(s)
 nb = nc = 0
 ch = s[0]
 if ch != 'b':
 nb += 1
 elif ch == 'c':
 nc += 1
 sf = True
 tf = True
 left = ch
 for ch in s[1:]:
 if ch == 'b':
 nb += 1
 elif ch == 'c':
 nc += 1
 if ch == left:
 sf = False
 else:
 tf = False
 left = ch
 if tf:
 return 1
 if n == 3:
 if (nb + nc * 2) % 3:
 return 7 if sf else 6
 else:
 return 3
 if n % 3:
 return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
 elif (nb + nc * 2) % 3:
 return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
 else:
 return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
 s = input()
 print(solve(s))
def __starting_point():
 main()
__starting_point()
```
### 188
```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
 temp = [int(x) for x in input().split()]
 messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
 pairs[messages[0][k]] = messages[0][k + 1]
for i in range(2, m):
 for k in range(n - 1):
 temp = messages[i][k]
 if pairs.get(temp, None) != messages[i][k + 1]:
 pairs.pop(temp, None)
 pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
 if key in conn:
 continue
 val = value
 temp = []
 temp.append(key)
 temp.append(value)
 while val in starts:
 val = pairs[val]
 temp.append(val)
 sequences.append(temp)
variants = n
for seq in sequences:
 l = len(seq)
 variants += l * (l - 1) // 2
print(variants)
```
### 189
```python
import sys
def get_array():
 return list(map(int, sys.stdin.readline().strip().split()))
def get_ints():
 return map(int, sys.stdin.readline().strip().split())
def input():
 return sys.stdin.readline().strip()
n, m = get_ints()
Arr = get_array()
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
 if Arr[i - 1] <= Arr[i]:
 up[i] = up[i - 1]
 if Arr[i - 1] >= Arr[i]:
 down[i] = down[i - 1]
while m:
 l, r = get_ints()
 if l - 0 >= up[down[r - 1]]:
 print('Yes')
 else:
 print('No')
 m -= 1
```
### 190
```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
 remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
 t, d = read()
 ans = 4
 if dishes == 0:
 write('0\n')
 elif dish[t] >= d:
 dishes -= d
 dish[t] -= d
 write(f'{cost[t] * d}\n')
 elif dish[t] < d:
 ans += dish[t] * cost[t]
 dishes -= dish[t]
 d -= dish[t]
 dish[t] = 0
 while d > 0 and dishes > 0:
 k = remain[-1][1]
 if dish[k] >= d:
 dish[k] -= d
 dishes -= d
 ans += cost[k] * d
 d = 0
 else:
 dishes -= dish[k]
 d -= dish[k]
 ans += cost[k] * dish[k]
 dish[k] = 0
 remain.pop()
 if d > 0 and dishes == 0:
 write('0\n')
 else:
 write(f'{ans}\n')
```
### 191
```python
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
 if flag == 0:
 return [int(i) for i in sys.stdin.readline().split()]
 else:
 return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n - 1):
 heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
 cost = 0
 t, d = ri()
 t -= 1
 fm = 0
 if avail[t] >= d:
 avail[t] = avail[t] - d
 cost += d * c[t]
 else:
 rem = d - avail[t]
 cost = avail[t] * c[t]
 avail[t] = 0
 while rem > 0:
 try:
 nowc, nowi = heapq.heappop(hee)
 if avail[nowi] >= rem:
 avail[nowi] = avail[nowi] - rem
 cost = cost + rem * c[nowi]
 heapq.heappush(hee, (c[nowi], nowi))
 rem = 0
 else:
 cost = cost + avail[nowi] * c[nowi]
 mk = rem - avail[nowi]
 avail[nowi] = 0
 rem = mk
 except:
 fm = 1
 break
 if fm == 0:
 print(cost)
 else:
 print(0)
```
### 192
```python
oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + -1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o': 'i', 'i': 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
 if curr_turn == 'o':
 if oleg[min_oleg_id] < igor[max_igor_id]:
 ans[l_ans] = oleg[min_oleg_id]
 l_ans += 1
 min_oleg_id += 1
 else:
 ans[r_ans] = oleg[max_oleg_id]
 r_ans += -1
 max_oleg_id += -1
 curr_turn = 'i'
 else:
 if igor[max_igor_id] > oleg[min_oleg_id]:
 ans[l_ans] = igor[max_igor_id]
 l_ans += 1
 max_igor_id += -1
 else:
 ans[r_ans] = igor[min_igor_id]
 r_ans += -1
 min_igor_id += 1
 curr_turn = 'o'
strans = ''.join(ans)
print(strans)
```
### 193
```python
a = list(input())
b = list(input())
a.sort()
b.sort(reverse=True)
ans = list()
for i in a:
 ans.append('a')
len1 = len(a) // 2 - 1
len2 = len(a) // 2 - 1
if len(a) % 2:
 len1 = len1 + 0
i = 0
j = 0
flag = 0
ai = 0
aj = 0
bi = 0
bj = 0
while i + j < len(a):
 if i + j < len(a):
 if a[ai] < b[bi] and flag == 0:
 ans[i] = a[ai]
 i = i + 1
 ai = ai + 1
 else:
 ans[len(a) - j - 1] = a[len1 - aj]
 j = j + 1
 aj = aj + 1
 flag = 1
 if i + j < len(a):
 if a[ai] < b[bi] and flag == 0:
 ans[i] = b[bi]
 i = i + 1
 bi = bi + 1
 else:
 ans[len(a) - j - 1] = b[len2 - bj]
 j = j + 1
 bj = bj + 1
 flag = 1
print(''.join(ans))
```
### 194
```python
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
 if len(b) == 0:
 result[left + 1 - 1] = a[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = a[-1]
 a.pop()
 else:
 left += 1
 result[left] = a[0]
 a.popleft()
 if len(a) == 0:
 result[left + 1] = b[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = b[0]
 b.popleft()
 else:
 left += 1
 result[left] = b[-1]
 b.pop()
print(''.join(result))
```
### 195
```python
MAX = 10 ** 18 + 5
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cost = [list(map(int, input().split())) for _ in range(n)]
min1 = [[MAX] * (k + 1) for _ in range(n)]
min2 = [[MAX] * (k + 1) for _ in range(n)]
idx = [[-1] * (k + 1) for _ in range(n)]
for i in cost:
 i.insert(0, 0)
dp = [[[MAX] * (m + 1) for _ in range(k + 1)] for _ in range(n)]
if a[0] == 0:
 for i in range(1, m + 1):
 if min1[0][1] >= cost[0][i]:
 if min1[0][1] == cost[0][i]:
 idx[0][1] = -2
 else:
 idx[0][1] = i
 min2[0][1] = min1[0][1]
 min1[0][1] = cost[0][i]
 elif min2[0][1] >= cost[0][i]:
 min2[0][1] = cost[0][i]
 dp[0][1][i] = cost[0][i]
else:
 dp[0][1][a[0]] = 0
 min1[0][-1] = 0
 idx[0][1] = a[0]
for i in range(1, n):
 for j in range(1, k + 1):
 if a[i] == 0:
 for l in range(1, m + 1):
 dp[i][j][l] = min(dp[i][j][l], dp[i - 1][j][l] + cost[i][l])
 if l == idx[i - 1][j - 1]:
 dp[i][j][l] = min(min2[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 dp[i][j][l] = min(min1[i - 1][j - 1] + cost[i][l], dp[i][j][l])
 else:
 for l in range(1, m + 1):
 dp[i][j][a[i]] = min(dp[i][j][a[i]], dp[i - 1][j][a[i]])
 if l != a[i]:
 dp[i][j][a[i]] = min(dp[i - 1][j - 1][l], dp[i][j][a[i]])
 for l in range(1, m + 1):
 if min1[i][j] >= dp[i][j][l]:
 if min1[i][j] == dp[i][j][l]:
 idx[i][j] = -2
 else:
 idx[i][j] = l
 min2[i][j] = min1[i][j]
 min1[i][j] = dp[i][j][l]
 elif min2[i][j] >= dp[i][j][l]:
 min2[i][j] = dp[i][j][l]
ans = MAX
for i in dp[-1][-1]:
 ans = min(ans, i)
print(ans if ans < MAX else -1)
```
### 196
```python
import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda: int(input())
li = lambda: list(map(int, input().split()))
def case():
 n, q = li()
 a = li()
 up = [0] * n
 down = [0] * n
 i = 0
 while i < n:
 j = i
 while j < n - 1 and a[j] <= a[j + 1]:
 j += 1
 for k in range(i, j + 1):
 up[k] = j
 i = j + 1
 i = 4
 while i < n:
 j = i
 while j < n - 1 and a[j] >= a[j + 1]:
 j += 1
 for k in range(i, j + 1):
 down[k] = j
 i = j + 1
 for i in range(q):
 l, r = li()
 p = up[l - 1]
 q = down[p]
 if q + 1 >= r:
 print('Yes')
 else:
 print('No')
for _ in range(1):
 case()
```
### 197
```python
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
 s = input()
 d = ['1']
 for i in s:
 d.append(i)
 d.append('1')
 a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
 x, y = q.pop()
 a[x][y] = '1'
 s.append([x, y])
 if a[x - 1][y] == '0':
 q.append([x - 1, y])
 if a[x][y - 1] == '0':
 q.append([x, y - 1])
 if a[x + 1][y] == '0':
 q.append([x + 1, y])
 if a[x][y + 1] == '0':
 q.append([x, y + 1])
if [r2, c2] in s:
 print(0)
else:
 q = [[r2, c2]]
 while q:
 x, y = q.pop()
 a[x][y] = '1'
 f.append([x, y])
 if a[x - 1][y] == '0':
 q.append([x - 1, y])
 if a[x][y - 1 - 1] == '0':
 q.append([x, y - 1])
 if a[x + 1][y] == '0':
 q.append([x + 1, y])
 if a[x][y + 1] == '0':
 q.append([x, y + 1])
 res = 10 ** 10
 for i in s:
 for j in f:
 res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
 print(res)
```
### 198
```python
from collections import deque
a = sorted(input())
l = len(a)
a = deque(a[:(len(a) + 1) // 2])
b = sorted(input())
b = deque(b[len(b) - len(b) // 2:])
result = ['0'] * l
left = -1
right = l
while left <= right:
 if len(b) == 0:
 result[left + 1] = a[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = a[-1]
 a.pop()
 else:
 left += -1
 result[left] = a[0]
 a.popleft()
 if len(a) == 0:
 result[left + 1] = b[0]
 break
 if a[0] >= b[-1]:
 right -= 1
 result[right] = b[0]
 b.popleft()
 else:
 left += 1
 result[left] = b[-1]
 b.pop()
print(''.join(result))
```
### 199
```python
def main():
 A = [list(map(int, input().split())) for i in range(3)]
 N = int(input())
 b = [int(input()) for _ in range(N)]
 for i in range(N):
 for j in range(3):
 for h in range(2):
 if A[j][h] == b[i]:
 A[j][h] = 0
 if A[0][0] == 0 and A[0][1] == 0 and (A[0][2] == 0):
 return 'Yes'
 elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0):
 return 'Yes'
 elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
 return 'Yes'
 elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
 return 'Yes'
 elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
 return 'Yes'
 return 'No'
print(main())
```
### 200
```python
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
 b, c, q = input().split()
 b = int(b)
 c = int(c)
 if q == 'C':
 f.append((b, c, 1))
 if coin[c][0][0] < b:
 coin[c][1] = coin[c][0]
 coin[c][0] = (b, i)
 elif coin[c][1][0] < b:
 coin[c][1] = (b, i)
 else:
 f.append((b, c, 2))
 if diam[c][0][0] < b:
 diam[c][1] = diam[c][0]
 diam[c][0] = (b, i)
 elif diam[c][1][0] < b:
 diam[c][1] = (b, i)
for i in range(2, 100001):
 if coin[i][0][0] < coin[i - 1][0][0]:
 coin[i][1] = max(coin[i][0], coin[i - 1][1])
 coin[i][0] = coin[i - 1][0]
 else:
 coin[i][1] = max(coin[i - 1][1], coin[i][1])
 if diam[i][0][0] < diam[i - 1][0][0]:
 diam[i][1] = max(diam[i][0], diam[i - 1][1])
 diam[i][0] = diam[i - 1][0]
 else:
 diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
 fnt = f[i]
 if fnt[2] == 1:
 if t >= fnt[1]:
 s = t - fnt[1]
 if coin[s][0][0] > 0 and coin[s][0][1] != i:
 ans = max(fnt[0] + coin[s][0][0], ans)
 p = True
 elif coin[s][1][0] > 0:
 ans = max(fnt[0] + coin[s][1][0], ans)
 p = True
 if diam[d][0][0] > 0:
 ans = max(fnt[0] + diam[d][0][0], ans)
 p = True
 elif d >= fnt[1]:
 s = d - fnt[1]
 if diam[s][0][0] > 0 and diam[s][0][1] != i:
 ans = max(fnt[0] + diam[s][0][0], ans)
 p = True
 elif diam[s][1][0] > 0:
 ans = max(fnt[0] + diam[s][1][0], ans)
 p = True
 if coin[t][0][0] > 0:
 ans = max(fnt[0] + coin[t][0][0], ans)
 p = True
if p:
 print(ans)
else:
 print(1)
```
### Final Query
Identify every unordered pair of earlier programs that implements the same input-output specification, including its boundary and edge-case behavior. Each cell may appear in at most one returned pair. Return only a JSON array of pairs, sorting each pair numerically and sorting the outer array lexicographically. Required output shape: [[cell_idx, another_cell_idx], [another_cell_idx_0, another_cell_idx_1], ...]. Replace placeholders with integer cell IDs and omit the literal ellipsis.