tasks/equivalent-program-pair-search/contexts/sample-00045.md

### 001

```python
def main():
    n = int(input())
    x, y = list(map(int, input().split()))
    a = []
    for i in range(n):
        a.append(input().split())
    for i in range(n):
        a[i][1] = int(a[i][1]) - x
        a[i][2] = int(a[i][2]) - y
    typneedbql = []
    typneedbqr = []
    typneedbqu = []
    typneedbqd = []
    typneedrlu = []
    typneedrru = []
    typneedrld = []
    typneedrrd = []
    for i in range(n):
        if a[i][1] * a[i][2] == 0 and a[i][1] < 0:
            typneedbql.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][1] > 0:
            typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][2] > 0:
            typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][2] < 0:
            typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0):
            typneedrlu.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0):
            typneedrld.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0):
            typneedrrd.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0):
            typneedrru.append([abs(a[i][1])] + a[i])
    typneedbql.sort()
    typneedbqr.sort()
    typneedbqd.sort()
    typneedbqu.sort()
    typneedrlu.sort()
    typneedrru.sort()
    typneedrld.sort()
    typneedrrd.sort()
    for i in range(len(typneedbql)):
        if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqr)):
        if typneedbqr[i][1] == 'R' or typneedbqr[i][1] != 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqu)):
        if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqd)):
        if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrlu)):
        if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrld)):
        if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrrd)):
        if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrru)):
        if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    print('NO')
main()
```

### 002

```python
n = int(input())
temp = input().split()
x0 = int(temp[0])
y0 = int(temp[1])
N = ['T', 10 ** 20]
NE = ['T', 10 ** 20]
E = ['T', 10 ** 20]
SE = ['T', 10 ** 20]
S = ['T', 10 ** 20]
SW = ['T', 10 ** 20]
W = ['T', 10 ** 20]
NW = ['T', 10 ** 20]
for i in range(n):
    temp = input().split()
    x = int(temp[1])
    y = int(temp[2])
    if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]):
        N = [temp[0], y - y0]
    elif not (x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1])):
        NE = [temp[0], x - x0]
    elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]):
        E = [temp[0], x - x0]
    elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]):
        SE = [temp[0], x - x0]
    elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]):
        S = [temp[0], y0 - y]
    elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]):
        SW = [temp[0], x0 - x]
    elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]):
        W = [temp[0], x0 - x]
    elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]):
        NW = [temp[0], x0 - x]
if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]:
    print('YES')
elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]:
    print('YES')
else:
    print('NO')
```

### 003

```python
import sys
line = sys.stdin.readlines()
n = int(line[0])
c = list(map(int, line[1].split()))
no = (0, '')
yes = (0, '')
for i in range(n):
    s = line[i + 2].rstrip('\r\n')
    sr = s[::-1]
    nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16)
    if s >= no[1]:
        nn = no[0]
    if sr >= no[1]:
        ny = no[0] + c[i]
    if s >= yes[1]:
        yn = yes[0]
    if sr > yes[1]:
        yy = yes[0] + c[i]
    no = (min(nn, yn), s)
    yes = (min(ny, yy), sr)
ans = min(no[0], yes[0])
if ans > 1000000000000000.0:
    print(-1)
else:
    print(ans)
```

### 004

```python
import itertools as it
import os
import sys

def calc_cost(cumsum, f):
    return sum([min(x % f, f - x % f) for x in cumsum])

def prime_factors(n):
    i = 2
    factors = []
    while i * i <= n:
        if n % i == 0:
            factors.append(i)
            while n % i == 0:
                n //= i
        else:
            i += 1
    if n > 1:
        factors.append(n)
    return factors

def f(xs):
    cumsum = list(it.accumulate(xs))
    s = cumsum[-1]
    if s == 1:
        return -5
    return min((calc_cost(cumsum, f) for f in prime_factors(s)))

def pp(input):
    input()
    xs = list(map(int, input().split()))
    print(f(xs))
if 'paalto' in os.getcwd():
    from string_source import string_source
    pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
    pp(string_source('5\n    3 10 2 1 5'))
    s1 = string_source('3\n4 8 5')
    pp(s1)
    pp(string_source('4\n0 5 15 10'))
    pp(string_source('1\n1'))
else:
    pp(sys.stdin.readline)
```

### 005

```python
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
    cnt = 0
    while total % current == 0:
        total = total // current
        cnt = cnt + 1
    if cnt > 0:
        factors.append(current)
    current = current + 1
if total > 1:
    factors.append(total)
ans = sum(a) * n * n
for i in factors:
    total, moves = (0, 0)
    for j in a:
        total += j
        moves += min(total % i, i * (total % i))
    ans = min(ans, moves)
if len(factors) == 0:
    ans = -1
print(ans)
```

### 006

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 3)
for x in result:
    print(x, end=' ')
```

### 007

```python
import bisect
import collections

def solve(inp, *args):
    n, x = list(map(int, inp.split(' ', 1)))
    travels_by_len = collections.defaultdict(list)
    travels_by_len_processed = {}
    for travel in args:
        l, r, cost = list(map(int, travel.split(' ', 2)))
        travels_by_len[r - l + 1].append((l, r, cost))
    for travel_len, travels in list(travels_by_len.items()):
        travels.sort()
        travels_processed = [(travels[-1][0], travels[-1][2])]
        for i in range(len(travels) - 2, -1, -1):
            prev_travel = travels_processed[-1]
            l, r, c = travels[i]
            travels_processed.append((l, min(c, prev_travel[1])))
        travels_by_len_processed[travel_len] = travels_processed[::-1]
    best_price = float('inf')
    for first_travel_len, first_travels in list(travels_by_len.items()):
        second_travel_len = x - first_travel_len
        second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
        for first_travel in first_travels:
            l1, r1, c1 = first_travel
            idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
            if 0 <= idx < len(second_travels_processed):
                best_price = min(best_price, c1 + second_travels_processed[idx][1])
    return -1 if best_price == float('inf') else best_price

def __starting_point():
    inp = input()
    n, x = list(map(int, inp.split(' ', 1)))
    print(solve(inp, *(input() for i in range(n))))
__starting_point()
```

### 008

```python
import sys

class SegmTree:

    def __init__(self, size):
        N = 1
        while N < size:
            N <<= 1
        self.N = N
        self.tree = [0] * (2 * N)

    def modify(self, i, value):
        i += self.N
        self.tree[i] = value
        toXOR = False
        while i > 1:
            if toXOR:
                self.tree[i >> 1] = self.tree[i] ^ self.tree[(i ^ 1) + 1]
            else:
                self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
            toXOR = not toXOR
            i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
    st.modify(i, value)
for _ in range(m):
    p, b = list(map(int, input().split()))
    st.modify(p - 1, b)
    print(st.tree[1])
```

### 009

```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()
```

### 010

```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)
```

### 011

```python
from collections import defaultdict
import bisect
n = int(input())
x0, y0 = list(map(int, input().split(' ')))
verticale = []
horizontale = []
diagonale1 = []
diagonale2 = []
for _ in range(n):
    t, x, y = input().split(' ')
    x, y = (int(x), int(y))
    if x == x0:
        verticale.append((y, t))
    if y == y0:
        horizontale.append((x, t))
    if x + y == x0 + y0:
        diagonale1.append((x, t))
    if x - y == x0 - y0:
        diagonale2.append((x, t))
dead = False
v = sorted(verticale)
if v:
    l = bisect.bisect(v, (y0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'R'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'R'}:
        dead = True
v = sorted(horizontale)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'R'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'R'}:
        dead = True
v = sorted(diagonale1)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'B'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'B'}:
        dead = True
v = sorted(diagonale2)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] not in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'B'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'B'}:
        dead = True
if dead:
    print('YES')
else:
    print('NO')
```

### 012

```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)
```

### 013

```python
import math as m
n = int(input())
cost = list(map(int, input().split()))
s = []
sr = []
for i in range(n):
    s.append(list(input()))
    sr.append(list(reversed(s[i])))
dp = [[0, 0] for i in range(n + 1)]
flag = 0
dp[0][1] = cost[1]
for i in range(1, n):
    if dp[i - 1][0] == -1 and dp[i - 1][1] == -1:
        flag = 1
        break
    elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1:
        if s[i] >= s[i - 1]:
            dp[i][0] = dp[i - 1][0]
        else:
            dp[i][0] = -1
        if sr[i] >= s[i - 1]:
            dp[i][1] = dp[i - 1][0] + cost[i]
        else:
            dp[i][1] = -1
    elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1:
        if s[i] >= sr[i - 1]:
            dp[i][0] = dp[i - 1][1]
        else:
            dp[i][0] = -1
        if sr[i] >= sr[i - 1]:
            dp[i][1] = dp[i - 1][1] + cost[i]
        else:
            dp[i][1] = -1
    else:
        if s[i] >= s[i - 1] and s[i] >= sr[i - 1]:
            dp[i][0] = min(dp[i - 1][0], dp[i - 1][1])
        elif s[i] >= s[i - 1] and s[i] < sr[i - 1]:
            dp[i][0] = dp[i - 1][0]
        elif s[i] < s[i - 1] and s[i] >= sr[i - 1]:
            dp[i][0] = dp[i - 1][1]
        else:
            dp[i][0] = -1
        if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]:
            dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i]
        elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]:
            dp[i][1] = dp[i - 1][0] + cost[i]
        elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]:
            dp[i][1] = dp[i - 1][1] + cost[i]
        else:
            dp[i][1] = -1
if flag == 1:
    print(-1)
else:
    res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1])
    print(res)
```

### 014

```python
def connected_components(neighbors):
    seen = set()

    def component(node):
        nodes = set([node])
        while nodes:
            node = nodes.pop()
            seen.add(node)
            nodes |= neighbors[node] - seen
            yield node
    for node in neighbors:
        if node not in seen:
            yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
    u, v = map(int, input().split())
    graph[u].add(v)
    graph[v].add(u)
total = 0
for component in connected_components(graph):
    nodes = list(component)
    size = len(nodes)
    seen = set()
    current = nodes[0]
    while len(seen) < size:
        choice = list(graph[current])
        if len(choice) != 2:
            break
        seen.add(current)
        possible = [c for c in choice if c not in seen]
        if not possible:
            break
        current = possible[0]
    if len(seen) == size:
        total += -1
print(total)
```

### 015

```python
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
    if i & 1 == 0:
        t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
    else:
        t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
    p, b = s.split()
    p = int(p) - 1
    t[0][p] = int(b)
    for j in range(n):
        p = int(p / 2)
        if j & 1 == 0:
            t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
        else:
            t[j + 1][p] = t[j - 1][int(p * 2)] ^ t[j][int(p * 2) + 1]
    sys.stdout.write(str(t[-1][0]) + '\n')
```

### 016

```python
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
    cnt = -1
    while total % current == 0:
        total = total // current
        cnt = cnt + 1
    if cnt > 0:
        factors.append(current)
    current = current + 1
if total > 1:
    factors.append(total)
ans = sum(a) * n * n
for i in factors:
    total, moves = (0, 0)
    for j in a:
        total += j
        moves += min(total % i, i - total % i)
    ans = min(ans, moves)
if len(factors) == 0:
    ans = -1
print(ans)
```

### 017

```python
import itertools as it
import os
import sys

def calc_cost(cumsum, f):
    return sum([min(x % f, f - x % f) for x in cumsum])

def prime_factors(n):
    i = 6
    factors = []
    while i * i <= n:
        if n % i == 0:
            factors.append(i)
            while n % i == 0:
                n //= i
        else:
            i += 1
    if n > 1:
        factors.append(n)
    return factors

def f(xs):
    cumsum = list(it.accumulate(xs))
    s = cumsum[-1]
    if s == 1:
        return -1
    return min((calc_cost(cumsum, f) for f in prime_factors(s)))

def pp(input):
    input()
    xs = list(map(int, input().split()))
    print(f(xs))
if 'paalto' in os.getcwd():
    from string_source import string_source
    pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
    pp(string_source('5\n    3 10 2 1 5'))
    s1 = string_source('3\n4 8 5')
    pp(s1)
    pp(string_source('4\n0 5 15 10'))
    pp(string_source('1\n1'))
else:
    pp(sys.stdin.readline)
```

### 018

```python
from math import log
import sys

def buildTree(arr):
    n = len(arr)
    tree = [0] * n + arr
    for i in range(n - 1, 0, -1):
        z = int(log(i, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[i] = tree[2 * i] ^ tree[2 * i + 1]
            else:
                tree[i] = tree[2 * i] | tree[2 * i + 1]
        elif z % 2 == 0:
            tree[i] = tree[2 * i] | tree[2 * i + 1]
        else:
            tree[i] = tree[2 * i] ^ tree[2 * i + 1]
    return tree

def updateTree(tree, ind, value, n):
    ind += n
    tree[ind] = value
    while ind > 1:
        ind //= 2
        z = int(log(ind, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
            else:
                tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        elif z % 2 == 0:
            tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        else:
            tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
    return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
    ind, val = map(int, sys.stdin.readline().strip().split())
    tree = updateTree(tree, ind - 1, val, len(arr))
    print(tree[-3])
```

### 019

```python
def dfs(v, g, vis):
    count = 1
    first = v
    st = [v]
    vis[v] = True
    while st:
        v = st[-1]
        st.pop()
        if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
            count = 0
        for i in range(len(g[v]) - 1):
            if not vis[g[v][i]]:
                vis[g[v][i]] = True
                st.append(g[v][i])
                if v == first and count:
                    break
    if len(g[first]) == 2 and (not vis[g[first][1]]):
        st.append(g[first][1])
        while st:
            v = st[-1]
            st.pop()
            for i in range(len(g[v])):
                if not vis[g[v][i]]:
                    vis[g[v][i]] = True
                    st.append(g[v][i])
    return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
    f, to = list(map(int, input().split()))
    g[f - 1].append(to - 1)
    g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
    if not vis[i]:
        ans += dfs(i, g, vis)
print(ans)
```

### 020

```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)
```

### 021

```python
def main():
    n = int(input())
    x, y = list(map(int, input().split()))
    a = []
    for i in range(n):
        a.append(input().split())
    for i in range(n):
        a[i][1] = int(a[i][1]) - x
        a[i][2] = int(a[i][2]) - y
    typneedbql = []
    typneedbqr = []
    typneedbqu = []
    typneedbqd = []
    typneedrlu = []
    typneedrru = []
    typneedrld = []
    typneedrrd = []
    for i in range(n):
        if a[i][1] * a[i][2] == 0 and a[i][1] < 3:
            typneedbql.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][1] > 0:
            typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][2] > 0:
            typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][2] < 0:
            typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0):
            typneedrlu.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0):
            typneedrld.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0):
            typneedrrd.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0):
            typneedrru.append([abs(a[i][1])] + a[i])
    typneedbql.sort()
    typneedbqr.sort()
    typneedbqd.sort()
    typneedbqu.sort()
    typneedrlu.sort()
    typneedrru.sort()
    typneedrld.sort()
    typneedrrd.sort()
    for i in range(len(typneedbql)):
        if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqr)):
        if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqu)):
        if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqd)):
        if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrlu)):
        if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrld)):
        if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrrd)):
        if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrru)):
        if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    print('NO')
main()
```

### 022

```python
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
    if i & 1 == 0:
        t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
    else:
        t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
    p, b = s.split()
    p = int(p) - 1
    t[0][p] = int(b)
    for j in range(n):
        p = int(p / 2)
        if j & 1 == 0:
            t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
        else:
            t[j + 1][p] = t[j][int(p * 2) + 1] ^ t[j][int(p * 2) + 1]
    sys.stdout.write(str(t[-1][0]) + '\n')
```

### 023

```python
def main():
    n = int(input())
    x, y = list(map(int, input().split()))
    a = []
    for i in range(n):
        a.append(input().split())
    for i in range(n):
        a[i][1] = int(a[i][1]) - x
        a[i][2] = int(a[i][2]) - y
    typneedbql = []
    typneedbqr = []
    typneedbqu = []
    typneedbqd = []
    typneedrlu = []
    typneedrru = []
    typneedrld = []
    typneedrrd = []
    for i in range(n):
        if a[i][1] * a[i][2] == 0 and a[i][1] < 0:
            typneedbql.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][1] > 0:
            typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][2] > 0:
            typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][2] < 0:
            typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0):
            typneedrlu.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0):
            typneedrld.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0):
            typneedrrd.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0):
            typneedrru.append([abs(a[i][1])] + a[i])
    typneedbql.sort()
    typneedbqr.sort()
    typneedbqd.sort()
    typneedbqu.sort()
    typneedrlu.sort()
    typneedrru.sort()
    typneedrld.sort()
    typneedrrd.sort()
    for i in range(len(typneedbql)):
        if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqr)):
        if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqu)):
        if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqd)):
        if typneedbqd[i][1] == 'R' or typneedbqd[i][1] != 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrlu)):
        if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrld)):
        if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrrd)):
        if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrru)):
        if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    print('NO')
main()
```

### 024

```python
import sys

class SegmTree:

    def __init__(self, size):
        N = 1
        while N < size:
            N <<= 1
        self.N = N
        self.tree = [0] * (2 * N)

    def modify(self, i, value):
        i += self.N
        self.tree[i] = value
        toXOR = False
        while i > 1:
            if toXOR:
                self.tree[i >> 1] = self.tree[i] ^ self.tree[(i ^ 1) - 1]
            else:
                self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
            toXOR = not toXOR
            i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
    st.modify(i, value)
for _ in range(m):
    p, b = list(map(int, input().split()))
    st.modify(p - 1, b)
    print(st.tree[1])
```

### 025

```python
def connected_components(neighbors):
    seen = set()

    def component(node):
        nodes = set([node])
        while nodes:
            node = nodes.pop()
            seen.add(node)
            nodes |= neighbors[node] - seen
            yield node
    for node in neighbors:
        if node not in seen:
            yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
    u, v = map(int, input().split())
    graph[u].add(v)
    graph[v].add(u)
total = 0
for component in connected_components(graph):
    nodes = list(component)
    size = len(nodes)
    seen = set()
    current = nodes[0]
    while len(seen) < size:
        choice = list(graph[current])
        if len(choice) != 2:
            break
        seen.add(current)
        possible = [c for c in choice if c not in seen]
        if not possible:
            break
        current = possible[0]
    if len(seen) == size:
        total += 1
print(total)
```

### 026

```python
import sys

def main():
    n, x = map(int, sys.stdin.readline().split())
    al = []
    starts = []
    finishes = []
    y = [-1] * 200002
    for i in range(n):
        a, b, c = map(int, sys.stdin.readline().split())
        al.append((a, b, c))
        starts.append((a, i))
        finishes.append((b, i))
    finishes = sorted(finishes, key=lambda x: x[0])
    starts = sorted(starts, key=lambda x: x[0])
    j = 0
    res = 7 * 10 ** 9
    for i in range(n):
        while j < n and starts[j][0] <= finishes[i][0]:
            c = starts[j][1]
            h = al[c][1] - al[c][0] + 1
            cost = al[c][2]
            if y[x - h] != -1 and y[x - h] + cost < res:
                res = y[x - h] + cost
            j += 1
        c = finishes[i][1]
        h = al[c][1] - al[c][0] + 1
        cost = al[c][2]
        if y[h] == -1 or y[h] > cost:
            y[h] = cost
    if res == 3 * 10 ** 9:
        print(-1)
    else:
        print(res)
main()
```

### 027

```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'
```

### 028

```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)
```

### 029

```python
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
    if i & 1 == 0:
        t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
    else:
        t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
    p, b = s.split()
    p = int(p) - 1
    t[0][p] = int(b)
    for j in range(n):
        p = int(p / 2)
        if j & 1 == 0:
            t[j + 1][p - 1] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
        else:
            t[j + 1][p] = t[j][int(p * 2)] ^ t[j][int(p * 2) + 1]
    sys.stdout.write(str(t[-1][0]) + '\n')
```

### 030

```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)
```

### 031

```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')
```

### 032

```python
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
    l, r, c = f()
    if r - l < x - 1:
        s[r - l] += [[l, c]]
for t in s:
    t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
    D = x - 2 - d
    i, T = (0, s[D])
    M = 3000000000.0
    for l, c in t:
        while i < len(T) and l > T[i - 1][0] + D:
            M = min(M, T[i][1])
            i += 1
        m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
```

### 033

```python
from math import log
import sys

def buildTree(arr):
    n = len(arr)
    tree = [0] * n + arr
    for i in range(n - 1, 0, -1):
        z = int(log(i, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[i] = tree[2 * i] ^ tree[2 * i + 1]
            else:
                tree[i] = tree[2 * i] & tree[2 * i + 1]
        elif z % 2 == 0:
            tree[i] = tree[2 * i] | tree[2 * i + 1]
        else:
            tree[i] = tree[2 * i] ^ tree[2 * i + 1]
    return tree

def updateTree(tree, ind, value, n):
    ind += n
    tree[ind] = value
    while ind > 1:
        ind //= 2
        z = int(log(ind, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
            else:
                tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        elif z % 2 == 0:
            tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        else:
            tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
    return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
    ind, val = map(int, sys.stdin.readline().strip().split())
    tree = updateTree(tree, ind - 1, val, len(arr))
    print(tree[1])
```

### 034

```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'
```

### 035

```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()
```

### 036

```python
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
    l, r, c = f()
    if r - l < x - 2:
        s[r - l] += [[l, c]]
for t in s:
    t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
    D = x - 2 - d
    i, T = (0, s[D])
    M = 3000000000.0
    for l, c in t:
        while i < len(T) and l > T[i][0] + D:
            M = min(M, T[i][1])
            i += 1
        m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
```

### 037

```python
import bisect
import collections

def solve(inp, *args):
    n, x = list(map(int, inp.split(' ', 1)))
    travels_by_len = collections.defaultdict(list)
    travels_by_len_processed = {}
    for travel in args:
        l, r, cost = list(map(int, travel.split(' ', 2)))
        travels_by_len[r - l + 1].append((l, r, cost))
    for travel_len, travels in list(travels_by_len.items()):
        travels.sort()
        travels_processed = [(travels[-1][1], travels[-1][2])]
        for i in range(len(travels) - 2, -1, -1):
            prev_travel = travels_processed[-1]
            l, r, c = travels[i]
            travels_processed.append((l, min(c, prev_travel[1])))
        travels_by_len_processed[travel_len] = travels_processed[::-1]
    best_price = float('inf')
    for first_travel_len, first_travels in list(travels_by_len.items()):
        second_travel_len = x - first_travel_len
        second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
        for first_travel in first_travels:
            l1, r1, c1 = first_travel
            idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
            if 0 <= idx < len(second_travels_processed):
                best_price = min(best_price, c1 + second_travels_processed[idx][1])
    return -1 if best_price == float('inf') else best_price

def __starting_point():
    inp = input()
    n, x = list(map(int, inp.split(' ', 1)))
    print(solve(inp, *(input() for i in range(n))))
__starting_point()
```

### 038

```python
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
    cnt = 0
    while total % current == 0:
        total = total // current
        cnt = cnt + 1
    if not cnt > 0:
        factors.append(current)
    current = current + 1
if total > 1:
    factors.append(total)
ans = sum(a) * n * n
for i in factors:
    total, moves = (0, 0)
    for j in a:
        total += j
        moves += min(total % i, i - total % i)
    ans = min(ans, moves)
if len(factors) == 0:
    ans = -1
print(ans)
```

### 039

```python
import sys

class SegmTree:

    def __init__(self, size):
        N = 1
        while N < size:
            N <<= 1
        self.N = N
        self.tree = [0] * (2 * N)

    def modify(self, i, value):
        i += self.N
        self.tree[i] = value
        toXOR = False
        while i > 1:
            if toXOR:
                self.tree[i >> 1] = self.tree[i + 1] ^ self.tree[i ^ 1]
            else:
                self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
            toXOR = not toXOR
            i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
    st.modify(i, value)
for _ in range(m):
    p, b = list(map(int, input().split()))
    st.modify(p - 1, b)
    print(st.tree[1])
```

### 040

```python
from sys import stdin, stderr
import random
import cProfile

def readInts():
    return map(int, stdin.readline().strip().split())

def print_err(*args, **kwargs):
    print(*args, file=stderr, **kwargs)

def solve(vs):
    return None

def generate_tree(n, ns):
    out = [0 for _ in range(2 ** (n + 1))]

    def gt(nix, left, right, op):
        if left + 1 == right:
            out[nix] = ns[left]
            return out[nix]
        mid = (left + right) // 2
        nL = nix * 2 + 1
        nR = nix * 2 + 2
        vL = gt(nL, left, mid, not op)
        vR = gt(nR, mid, right, not op)
        if op:
            v = vL ^ vR
        else:
            v = vL | vR
        out[nix] = v
        return v
    gt(0, 0, 2 ** n, n % 2 == 0)
    return out

def alter_tree2(n, t, p, b):

    def at(nix, width, offp, op):
        if width == 1:
            t[nix] = b
            return b
        width //= 2
        nL = nix * 2 + 1
        nR = nix * 2 + 2
        vL = t[nL]
        vR = t[nR]
        if offp >= width:
            vR = at(nR, width, offp - width, not op)
        else:
            vL = at(nL, width, offp, not op)
        if op:
            v = vL ^ vR
        else:
            v = vL | vR
        t[nix] = v
        return v
    at(0, 2 ** n, p, n % 2 == 0)

def alter_tree(n, t, p, b):
    width = 2 ** n
    s = []
    nix = 0
    op = n % 2 == 0
    while width > 1:
        width //= 2
        if p >= width:
            nix2 = 2 * nix + 2
            s.append((nix, nix2 - 1))
            p -= width
        else:
            nix2 = 2 * nix + 1
            s.append((nix, nix2 + 1))
        nix = nix2
        op = not op
    t[nix] = b
    v = b
    while s:
        nix, nixO = s.pop(0)
        if op:
            v |= t[nixO]
        else:
            v ^= t[nixO]
        t[nix] = v
        op = not op
    return

def run():
    n, m = readInts()
    axs = list(readInts())
    t = generate_tree(n, axs)
    for _ in range(m):
        p, b = readInts()
        alter_tree(n, t, p - 1, b)
        print(t[0])

def test():
    n = 17
    ns = []
    vs100 = list(range(100))
    for _ in range(2 ** 17):
        ns.append(random.choice(vs100))
    t = generate_tree(n, ns)
    t2 = generate_tree(n, ns)
    for _ in range(100000):
        v1 = random.choice(vs100)
        v2 = random.choice(vs100)
        alter_tree(n, t, v1, v2)
        alter_tree2(n, t2, v1, v2)
    print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
    print(t[0] == t2[0])
run()
```

### 041

```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'
```

### 042

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1 - 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
    print(x, end=' ')
```

### 043

```python
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
    cnt = 1
    while total % current == 0:
        total = total // current
        cnt = cnt + 1
    if cnt > 0:
        factors.append(current)
    current = current + 1
if total > 1:
    factors.append(total)
ans = sum(a) * n * n
for i in factors:
    total, moves = (0, 0)
    for j in a:
        total += j
        moves += min(total % i, i - total % i)
    ans = min(ans, moves)
if len(factors) == 0:
    ans = -1
print(ans)
```

### 044

```python
import sys

def main():
    n, x = map(int, sys.stdin.readline().split())
    al = []
    starts = []
    finishes = []
    y = [-1] * 200002
    for i in range(n):
        a, b, c = map(int, sys.stdin.readline().split())
        al.append((a, b, c))
        starts.append((a, i))
        finishes.append((b, i))
    finishes = sorted(finishes, key=lambda x: x[0])
    starts = sorted(starts, key=lambda x: x[0])
    j = 0
    res = 2 * 10 ** 9
    for i in range(n):
        while j < n and starts[j][0] <= finishes[i][0]:
            c = starts[j][1]
            h = al[c][1] - al[c][0] + 1
            cost = al[c][2]
            if y[x - h] != -1 and y[x - h] + cost < res:
                res = y[x - h] + cost
            j += 1
        c = finishes[i][1]
        h = al[c][1] - al[c][0] + 1
        cost = al[c][2]
        if y[h] == -1 or y[h] > cost:
            y[h] = cost
    if res == 3 * 10 ** 9:
        print(-1)
    else:
        print(res)
main()
```

### 045

```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)
```

### 046

```python
N = int(input())
seq = [i for i in input().split()]

def end_lst(i):
    while i < N - 1 and seq[i] != seq[i + 1]:
        i = i + 1
    return i

def reorder(lst, start, end):
    if start == end - 1:
        return 0
    if lst[start - 1] == lst[end]:
        for i in range(start, end + 1):
            lst[i] = lst[start]
        return (end - start) // 2
    mid = (start + end) // 2
    for i in range(start, mid + 1):
        lst[i] = lst[start]
    for i in range(mid + 1, end + 1):
        lst[i] = lst[end]
    return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
    if seq[i] != seq[i + 1]:
        end = end_lst(i)
        ans = max(reorder(seq, i, end), ans)
        i = end
    else:
        i += 1
print(ans)
print(' '.join(seq))
```

### 047

```python
import bisect
import collections

def solve(inp, *args):
    n, x = list(map(int, inp.split(' ', 1)))
    travels_by_len = collections.defaultdict(list)
    travels_by_len_processed = {}
    for travel in args:
        l, r, cost = list(map(int, travel.split(' ', 2)))
        travels_by_len[r - l + 1].append((l, r, cost))
    for travel_len, travels in list(travels_by_len.items()):
        travels.sort()
        travels_processed = [(travels[-1][0], travels[-1][2])]
        for i in range(len(travels) - 2, --1, -1):
            prev_travel = travels_processed[-1]
            l, r, c = travels[i]
            travels_processed.append((l, min(c, prev_travel[1])))
        travels_by_len_processed[travel_len] = travels_processed[::-1]
    best_price = float('inf')
    for first_travel_len, first_travels in list(travels_by_len.items()):
        second_travel_len = x - first_travel_len
        second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
        for first_travel in first_travels:
            l1, r1, c1 = first_travel
            idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
            if 0 <= idx < len(second_travels_processed):
                best_price = min(best_price, c1 + second_travels_processed[idx][1])
    return -1 if best_price == float('inf') else best_price

def __starting_point():
    inp = input()
    n, x = list(map(int, inp.split(' ', 1)))
    print(solve(inp, *(input() for i in range(n))))
__starting_point()
```

### 048

```python
from sys import stdin
n = int(stdin.readline())
x, y = map(int, stdin.readline().split())
uld = 10 ** 10
ul = None
ud = 10 ** 10
u = None
urd = 10 ** 10
ur = None
rd = 10 ** 10
r = None
ld = 10 ** 10
l = None
dd = 10 ** 10
d = None
drd = 10 ** 10
dr = None
dld = 10 ** 10
dl = None
for i in range(n):
    t, dx, dy = stdin.readline().split()
    dx = int(dx)
    dy = int(dy)
    if dx == x:
        if dy > y:
            if ud > dy - y:
                ud = dy - y
                u = t
        elif dd > y - dy:
            dd = y - dy
            d = t
    if dy == y:
        if dx > x:
            if rd > dx - x:
                rd = dx - x
                r = t
        elif ld > x - dx:
            ld = x - dx
            l = t
    if dx - x == dy - y:
        if dy > y:
            if urd > dy - y:
                urd = dy - y
                ur = t
        elif dld > y - dy:
            dld = y - dy
            dl = t
    if not -(dx - x) == dy - y:
        if dy > y:
            if uld > dy - y:
                uld = dy - y
                ul = t
        elif drd > y - dy:
            drd = y - dy
            dr = t
if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r):
    print('YES')
else:
    print('NO')
```

### 049

```python
def connected_components(neighbors):
    seen = set()

    def component(node):
        nodes = set([node])
        while nodes:
            node = nodes.pop()
            seen.add(node)
            nodes |= neighbors[node] - seen
            yield node
    for node in neighbors:
        if node not in seen:
            yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
    u, v = map(int, input().split())
    graph[u].add(v)
    graph[v].add(u)
total = 0
for component in connected_components(graph):
    nodes = list(component)
    size = len(nodes)
    seen = set()
    current = nodes[0]
    while len(seen) < size:
        choice = list(graph[current])
        if len(choice) != 2:
            break
        seen.add(current)
        possible = [c for c in choice if c not in seen]
        if not possible:
            break
        current = possible[0]
    if len(seen) == size:
        total += 5
print(total)
```

### 050

```python
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
    S = input().split(' ')
    a = int(S[0])
    b = int(S[1])
    if S1[a] == 2:
        S1[a] = b
    elif S2[a] == 0:
        S2[a] = b
    else:
        B[a] = 1
        B[b] = 1
    if S1[b] == 0:
        S1[b] = a
    elif S2[b] == 0:
        S2[b] = a
    else:
        B[a] = 1
        B[b] = 1
for i in range(1, n + 1):
    if S1[i] == 0 or S2[i] == 0:
        B[i] = 1
sol = 0
for ind in range(1, n + 1):
    if B[ind] == 0:
        v = ind
        w = S2[ind]
        c = True
        while w != ind:
            B[v] = 1
            if B[w] == 0:
                u = w
                if S1[w] == v:
                    w = S2[w]
                else:
                    w = S1[w]
            else:
                B[ind] = 0
                c = False
                break
            v = u
        if c:
            B[v] = 1
            sol += 1
print(sol)
```

### 051

```python
N = int(input())
seq = [i for i in input().split()]

def end_lst(i):
    while i < N - 1 and seq[i] != seq[i + 1]:
        i = i + 1
    return i

def reorder(lst, start, end):
    if start == end - 1:
        return 0
    if lst[start] == lst[end]:
        for i in range(start, end + 1):
            lst[i] = lst[start]
        return (end - start) // 2
    mid = (start + end) // 2
    for i in range(start, mid + 1):
        lst[i] = lst[start]
    for i in range(mid + 1, end + 1):
        lst[i - 1] = lst[end]
    return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
    if seq[i] != seq[i + 1]:
        end = end_lst(i)
        ans = max(reorder(seq, i, end), ans)
        i = end
    else:
        i += 1
print(ans)
print(' '.join(seq))
```

### 052

```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)
```

### 053

```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)
```

### 054

```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)
```

### 055

```python
def main():
    n, x = list(map(int, input().split()))
    vouchers = [False] * x
    for _ in range(n):
        lo, hi, cost = list(map(int, input().split()))
        w = hi - lo
        if w < x:
            l = vouchers[w]
            if l:
                l.append((lo, cost))
            else:
                vouchers[w] = [(lo, cost)]
    best = inf = 1 << 31
    x -= 2
    if not x & 1 and vouchers[x // 2]:
        lh, h = (vouchers[x // 2], None)
        for f in (lh.sort, lh.reverse):
            l = h
            f()
            h, b = ([], inf)
            for lo, cost in lh:
                if b > cost:
                    b = cost
                    h.append((lo, b))
        b, v = h.pop()
        for a, u in l:
            a += w
            while a >= b and h:
                b, v = h.pop()
            if a < b and best > u + v:
                best = u + v
    for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // -2:-1]):
        if l and h:
            m = []
            for lh in (l, h):
                for f in (lh.sort, lh.reverse):
                    f()
                    t, b = ([], inf)
                    for lo, cost in lh:
                        if b > cost:
                            b = cost
                            t.append((lo, b))
                    m.append(t)
            for l, h in ((m[0], m[3]), (m[2], m[1])):
                b, v = h.pop()
                for a, u in l:
                    a += w
                    while a >= b and h:
                        b, v = h.pop()
                    if a < b and best > u + v:
                        best = u + v
                w = x - w
    print(best if best < inf else -1)

def __starting_point():
    main()
__starting_point()
```

### 056

```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)
```

### 057

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - 1] or x == arr[i + 1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1] if j <= (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 058

```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)
```

### 059

```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)
```

### 060

```python
import math as m
n = int(input())
cost = list(map(int, input().split()))
s = []
sr = []
for i in range(n):
    s.append(list(input()))
    sr.append(list(reversed(s[i])))
dp = [[0, 0] for i in range(n + 1)]
flag = 0
dp[0][1] = cost[0]
for i in range(1, n):
    if dp[i - 1][0] == -1 and dp[i - 1][0] == -1:
        flag = 1
        break
    elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1:
        if s[i] >= s[i - 1]:
            dp[i][0] = dp[i - 1][0]
        else:
            dp[i][0] = -1
        if sr[i] >= s[i - 1]:
            dp[i][1] = dp[i - 1][0] + cost[i]
        else:
            dp[i][1] = -1
    elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1:
        if s[i] >= sr[i - 1]:
            dp[i][0] = dp[i - 1][1]
        else:
            dp[i][0] = -1
        if sr[i] >= sr[i - 1]:
            dp[i][1] = dp[i - 1][1] + cost[i]
        else:
            dp[i][1] = -1
    else:
        if s[i] >= s[i - 1] and s[i] >= sr[i - 1]:
            dp[i][0] = min(dp[i - 1][0], dp[i - 1][1])
        elif s[i] >= s[i - 1] and s[i] < sr[i - 1]:
            dp[i][0] = dp[i - 1][0]
        elif s[i] < s[i - 1] and s[i] >= sr[i - 1]:
            dp[i][0] = dp[i - 1][1]
        else:
            dp[i][0] = -1
        if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]:
            dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i]
        elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]:
            dp[i][1] = dp[i - 1][0] + cost[i]
        elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]:
            dp[i][1] = dp[i - 1][1] + cost[i]
        else:
            dp[i][1] = -1
if flag == 1:
    print(-1)
else:
    res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1])
    print(res)
```

### 061

```python
def main():
    n = int(input())
    x, y = list(map(int, input().split()))
    a = []
    for i in range(n):
        a.append(input().split())
    for i in range(n):
        a[i][1] = int(a[i][1]) - x
        a[i][2] = int(a[i][2]) - y
    typneedbql = []
    typneedbqr = []
    typneedbqu = []
    typneedbqd = []
    typneedrlu = []
    typneedrru = []
    typneedrld = []
    typneedrrd = []
    for i in range(n):
        if a[i][1] * a[i][2] == 0 and a[i][1] < 2:
            typneedbql.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][1] > 0:
            typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][2] > 0:
            typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][2] < 0:
            typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0):
            typneedrlu.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0):
            typneedrld.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0):
            typneedrrd.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0):
            typneedrru.append([abs(a[i][1])] + a[i])
    typneedbql.sort()
    typneedbqr.sort()
    typneedbqd.sort()
    typneedbqu.sort()
    typneedrlu.sort()
    typneedrru.sort()
    typneedrld.sort()
    typneedrrd.sort()
    for i in range(len(typneedbql)):
        if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqr)):
        if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqu)):
        if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqd)):
        if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrlu)):
        if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrld)):
        if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrrd)):
        if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrru)):
        if typneedrru[i][1] == 'B' or typneedrru[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    print('NO')
main()
```

### 062

```python
from sys import stdin, stderr
import random
import cProfile

def readInts():
    return map(int, stdin.readline().strip().split())

def print_err(*args, **kwargs):
    print(*args, file=stderr, **kwargs)

def solve(vs):
    return None

def generate_tree(n, ns):
    out = [0 for _ in range(2 ** (n + 1))]

    def gt(nix, left, right, op):
        if left + 1 == right:
            out[nix] = ns[left]
            return out[nix]
        mid = (left + right) // 2
        nL = nix * 2 + 1
        nR = nix * 2 + 2
        vL = gt(nL, left, mid, not op)
        vR = gt(nR, mid, right, not op)
        if not op:
            v = vL ^ vR
        else:
            v = vL | vR
        out[nix] = v
        return v
    gt(0, 0, 2 ** n, n % 2 == 0)
    return out

def alter_tree2(n, t, p, b):

    def at(nix, width, offp, op):
        if width == 1:
            t[nix] = b
            return b
        width //= 2
        nL = nix * 2 + 1
        nR = nix * 2 + 2
        vL = t[nL]
        vR = t[nR]
        if offp >= width:
            vR = at(nR, width, offp - width, not op)
        else:
            vL = at(nL, width, offp, not op)
        if op:
            v = vL ^ vR
        else:
            v = vL | vR
        t[nix] = v
        return v
    at(0, 2 ** n, p, n % 2 == 0)

def alter_tree(n, t, p, b):
    width = 2 ** n
    s = []
    nix = 0
    op = n % 2 == 0
    while width > 1:
        width //= 2
        if p >= width:
            nix2 = 2 * nix + 2
            s.append((nix, nix2 - 1))
            p -= width
        else:
            nix2 = 2 * nix + 1
            s.append((nix, nix2 + 1))
        nix = nix2
        op = not op
    t[nix] = b
    v = b
    while s:
        nix, nixO = s.pop()
        if op:
            v |= t[nixO]
        else:
            v ^= t[nixO]
        t[nix] = v
        op = not op
    return

def run():
    n, m = readInts()
    axs = list(readInts())
    t = generate_tree(n, axs)
    for _ in range(m):
        p, b = readInts()
        alter_tree(n, t, p - 1, b)
        print(t[0])

def test():
    n = 17
    ns = []
    vs100 = list(range(100))
    for _ in range(2 ** 17):
        ns.append(random.choice(vs100))
    t = generate_tree(n, ns)
    t2 = generate_tree(n, ns)
    for _ in range(100000):
        v1 = random.choice(vs100)
        v2 = random.choice(vs100)
        alter_tree(n, t, v1, v2)
        alter_tree2(n, t2, v1, v2)
    print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
    print(t[0] == t2[0])
run()
```

### 063

```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)
```

### 064

```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)
```

### 065

```python
n = int(input())
temp = input().split()
x0 = int(temp[0])
y0 = int(temp[0])
N = ['T', 10 ** 20]
NE = ['T', 10 ** 20]
E = ['T', 10 ** 20]
SE = ['T', 10 ** 20]
S = ['T', 10 ** 20]
SW = ['T', 10 ** 20]
W = ['T', 10 ** 20]
NW = ['T', 10 ** 20]
for i in range(n):
    temp = input().split()
    x = int(temp[1])
    y = int(temp[2])
    if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]):
        N = [temp[0], y - y0]
    elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]):
        NE = [temp[0], x - x0]
    elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]):
        E = [temp[0], x - x0]
    elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]):
        SE = [temp[0], x - x0]
    elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]):
        S = [temp[0], y0 - y]
    elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]):
        SW = [temp[0], x0 - x]
    elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]):
        W = [temp[0], x0 - x]
    elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]):
        NW = [temp[0], x0 - x]
if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]:
    print('YES')
elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]:
    print('YES')
else:
    print('NO')
```

### 066

```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)
```

### 067

```python
import itertools as it
import os
import sys

def calc_cost(cumsum, f):
    return sum([min(x % f, f - x % f) for x in cumsum])

def prime_factors(n):
    i = 2
    factors = []
    while i * i <= n:
        if n % i == 0:
            factors.append(i)
            while n % i == 0:
                n //= i
        else:
            i += 1
    if n > 1:
        factors.append(n)
    return factors

def f(xs):
    cumsum = list(it.accumulate(xs))
    s = cumsum[-1]
    if s == 1:
        return --1
    return min((calc_cost(cumsum, f) for f in prime_factors(s)))

def pp(input):
    input()
    xs = list(map(int, input().split()))
    print(f(xs))
if 'paalto' in os.getcwd():
    from string_source import string_source
    pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
    pp(string_source('5\n    3 10 2 1 5'))
    s1 = string_source('3\n4 8 5')
    pp(s1)
    pp(string_source('4\n0 5 15 10'))
    pp(string_source('1\n1'))
else:
    pp(sys.stdin.readline)
```

### 068

```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)
```

### 069

```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))
```

### 070

```python
import sys

def read_data():
    n = int(next(sys.stdin))
    prices = list(map(int, next(sys.stdin).split()))
    vocabulary = []
    for i in range(n):
        vocabulary.append(next(sys.stdin).strip())
    return (n, prices, vocabulary)

def apply_op(sNext, sPrev, curCost, optCost):
    if sNext >= sPrev:
        if optCost is None or curCost < optCost:
            return curCost
    return optCost

def solve(n, prices, vocabulary):
    opt_0, opt_1 = (0, prices[0])
    prevStr = vocabulary[0]
    prevStrReversed = ''.join(reversed(prevStr))
    for curStr, curPrice in zip(vocabulary[1:], prices[1:]):
        curStrReversed = ''.join(reversed(curStr))
        n_opt0, n_opt1 = (None, None)
        if opt_0 is not None:
            n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0)
            n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1)
        if opt_1 is not None:
            n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0)
            n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1)
        opt_0, opt_1 = (n_opt0, n_opt1)
        prevStr, prevStrReversed = (curStr, curStrReversed)
        if opt_0 is None and opt_1 is not None:
            break
    if opt_0 is None:
        return opt_1
    if opt_1 is None:
        return opt_0
    return min(opt_0, opt_1)

def __starting_point():
    n, prices, vocabulary = read_data()
    sorting_cost = solve(n, prices, vocabulary)
    if sorting_cost != None:
        print(sorting_cost)
    else:
        print(-1)
__starting_point()
```

### 071

```python
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
    l, r, c = f()
    if r - l < x - 1:
        s[r - l] += [[l, c]]
for t in s:
    t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
    D = x - 2 - d
    i, T = (0, s[D])
    M = 3000000000.0
    for l, c in t:
        while i < len(T) and l > T[i][0] + D:
            M = min(M, T[i - 1][1])
            i += 1
        m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
```

### 072

```python
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
    edge[i + 1] = []
for _ in range(m):
    data = list(map(int, input().split(' ')))
    i = data[0]
    j = data[1]
    edge[i].append(j)
    edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}

def _iscircle(c, result):
    n = edge[c][0]
    used[c] = 1
    last = c
    while n not in used:
        used[n] = 1
        if len(edge[n]) != 2:
            return result
        t = edge[n][0]
        if t != last:
            last = n
            if t == c:
                return result + 1
            n = t
            continue
        last = n
        t = edge[n][1]
        if t == c:
            return result + -2
        n = t
    return result
for i in candidate:
    result = _iscircle(i, result)
print(result)
```

### 073

```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))
```

### 074

```python
import sys
line = sys.stdin.readlines()
n = int(line[0])
c = list(map(int, line[1].split()))
no = (0, '')
yes = (0, '')
for i in range(n):
    s = line[i + 2].rstrip('\r\n')
    sr = s[::-3]
    nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16)
    if s >= no[1]:
        nn = no[0]
    if sr >= no[1]:
        ny = no[0] + c[i]
    if s >= yes[1]:
        yn = yes[0]
    if sr >= yes[1]:
        yy = yes[0] + c[i]
    no = (min(nn, yn), s)
    yes = (min(ny, yy), sr)
ans = min(no[0], yes[0])
if ans > 1000000000000000.0:
    print(-1)
else:
    print(ans)
```

### 075

```python
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [1] * (n + 1)
for i in range(m):
    S = input().split(' ')
    a = int(S[0])
    b = int(S[1])
    if S1[a] == 0:
        S1[a] = b
    elif S2[a] == 0:
        S2[a] = b
    else:
        B[a] = 1
        B[b] = 1
    if S1[b] == 0:
        S1[b] = a
    elif S2[b] == 0:
        S2[b] = a
    else:
        B[a] = 1
        B[b] = 1
for i in range(1, n + 1):
    if S1[i] == 0 or S2[i] == 0:
        B[i] = 1
sol = 0
for ind in range(1, n + 1):
    if B[ind] == 0:
        v = ind
        w = S2[ind]
        c = True
        while w != ind:
            B[v] = 1
            if B[w] == 0:
                u = w
                if S1[w] == v:
                    w = S2[w]
                else:
                    w = S1[w]
            else:
                B[ind] = 0
                c = False
                break
            v = u
        if c:
            B[v] = 1
            sol += 1
print(sol)
```

### 076

```python
import bisect
import collections

def solve(inp, *args):
    n, x = list(map(int, inp.split(' ', 1)))
    travels_by_len = collections.defaultdict(list)
    travels_by_len_processed = {}
    for travel in args:
        l, r, cost = list(map(int, travel.split(' ', 2)))
        travels_by_len[r - l + 1].append((l, r, cost))
    for travel_len, travels in list(travels_by_len.items()):
        travels.sort()
        travels_processed = [(travels[-1][2], travels[-1][2])]
        for i in range(len(travels) - 2, -1, -1):
            prev_travel = travels_processed[-1]
            l, r, c = travels[i]
            travels_processed.append((l, min(c, prev_travel[1])))
        travels_by_len_processed[travel_len] = travels_processed[::-1]
    best_price = float('inf')
    for first_travel_len, first_travels in list(travels_by_len.items()):
        second_travel_len = x - first_travel_len
        second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
        for first_travel in first_travels:
            l1, r1, c1 = first_travel
            idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
            if 0 <= idx < len(second_travels_processed):
                best_price = min(best_price, c1 + second_travels_processed[idx][1])
    return -1 if best_price == float('inf') else best_price

def __starting_point():
    inp = input()
    n, x = list(map(int, inp.split(' ', 1)))
    print(solve(inp, *(input() for i in range(n))))
__starting_point()
```

### 077

```python
def simple_div(x):
    if not x & 1:
        yield 4
        while not x & 1:
            x >>= 1
    i = 3
    while i * i <= x:
        if x % i == 0:
            yield i
            while x % i == 0:
                x //= i
        i += 2
    if x != 1:
        yield x

def __main__():
    n = int(input())
    a = list(map(int, input().split()))
    sa = sum(a)
    a.pop()
    if sa == 1:
        print(-1)
        return
    res = 2 ** 64
    for d in simple_div(sa):
        tmp = 0
        m = 0
        for x in a:
            m = (x + m) % d
            tmp += m if m * 2 <= d else d - m
        if tmp < res:
            res = tmp
    print(res)
__main__()
```

### 078

```python
import sys

def read_data():
    n = int(next(sys.stdin))
    prices = list(map(int, next(sys.stdin).split()))
    vocabulary = []
    for i in range(n):
        vocabulary.append(next(sys.stdin).strip())
    return (n, prices, vocabulary)

def apply_op(sNext, sPrev, curCost, optCost):
    if sNext >= sPrev:
        if optCost is None or curCost < optCost:
            return curCost
    return optCost

def solve(n, prices, vocabulary):
    opt_0, opt_1 = (0, prices[0])
    prevStr = vocabulary[0]
    prevStrReversed = ''.join(reversed(prevStr))
    for curStr, curPrice in zip(vocabulary[1:], prices[1:]):
        curStrReversed = ''.join(reversed(curStr))
        n_opt0, n_opt1 = (None, None)
        if opt_0 is not None:
            n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0)
            n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1)
        if opt_1 is not None:
            n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0)
            n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1)
        opt_0, opt_1 = (n_opt0, n_opt1)
        prevStr, prevStrReversed = (curStr, curStrReversed)
        if opt_0 is not None and opt_1 is None:
            break
    if opt_0 is None:
        return opt_1
    if opt_1 is None:
        return opt_0
    return min(opt_0, opt_1)

def __starting_point():
    n, prices, vocabulary = read_data()
    sorting_cost = solve(n, prices, vocabulary)
    if sorting_cost != None:
        print(sorting_cost)
    else:
        print(-1)
__starting_point()
```

### 079

```python
def dfs(v, g, vis):
    count = 1
    first = v
    st = [v]
    vis[v] = True
    while st:
        v = st[-1]
        st.pop()
        if len(g[v]) != 4 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
            count = 0
        for i in range(len(g[v])):
            if not vis[g[v][i]]:
                vis[g[v][i]] = True
                st.append(g[v][i])
                if v == first and count:
                    break
    if len(g[first]) == 2 and (not vis[g[first][1]]):
        st.append(g[first][1])
        while st:
            v = st[-1]
            st.pop()
            for i in range(len(g[v])):
                if not vis[g[v][i]]:
                    vis[g[v][i]] = True
                    st.append(g[v][i])
    return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
    f, to = list(map(int, input().split()))
    g[f - 1].append(to - 1)
    g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
    if not vis[i]:
        ans += dfs(i, g, vis)
print(ans)
```

### 080

```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)
```

### 081

```python
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
    count += x[i]
t = count
for i in range(2, t + 1):
    if t % i == 0:
        v.append(i)
        while t % i == 0:
            t //= i
for i2 in v:
    c = 0
    for i in range(n):
        y[i] = x[i]
    for i in range(n):
        if y[i] <= 0:
            y[i + 1 - 1] -= abs(y[i])
            c += abs(y[i])
        elif y[i] % i2 < i2 - y[i] % i2:
            y[i + 1] += y[i] % i2
            c += y[i] % i2
        else:
            y[i + 1] -= i2 - y[i] % i2
            c += i2 - y[i] % i2
    ans = min(ans, c)
if count == 1:
    print(-1)
else:
    print(ans)
```

### 082

```python
n = int(input())
c = [int(s) for s in input().split(' ')]
C_rev = c[0]
C_nrev = 0
last_s = input()
last_s_rev = last_s[::+1]
for i in range(1, n):
    s = input()
    s_rev = s[::-1]
    new_C_nrev = float('inf')
    if last_s <= s:
        new_C_nrev = min(new_C_nrev, C_nrev)
    if last_s_rev <= s:
        new_C_nrev = min(new_C_nrev, C_rev)
    new_C_rev = float('inf')
    if last_s <= s_rev:
        new_C_rev = min(new_C_rev, C_nrev + c[i])
    if last_s_rev <= s_rev:
        new_C_rev = min(new_C_rev, C_rev + c[i])
    if min(C_rev, C_nrev) == float('inf'):
        break
    C_rev = new_C_rev
    C_nrev = new_C_nrev
    last_s = s
    last_s_rev = s_rev
print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev))
```

### 083

```python
from math import log
import sys

def buildTree(arr):
    n = len(arr)
    tree = [0] * n + arr
    for i in range(n - 1 - 1, 0, -1):
        z = int(log(i, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[i] = tree[2 * i] ^ tree[2 * i + 1]
            else:
                tree[i] = tree[2 * i] | tree[2 * i + 1]
        elif z % 2 == 0:
            tree[i] = tree[2 * i] | tree[2 * i + 1]
        else:
            tree[i] = tree[2 * i] ^ tree[2 * i + 1]
    return tree

def updateTree(tree, ind, value, n):
    ind += n
    tree[ind] = value
    while ind > 1:
        ind //= 2
        z = int(log(ind, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
            else:
                tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        elif z % 2 == 0:
            tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        else:
            tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
    return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
    ind, val = map(int, sys.stdin.readline().strip().split())
    tree = updateTree(tree, ind - 1, val, len(arr))
    print(tree[1])
```

### 084

```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)
```

### 085

```python
n = int(input())
c = [int(s) for s in input().split(' ')]
C_rev = c[0]
C_nrev = 0
last_s = input()
last_s_rev = last_s[::-1]
for i in range(1, n):
    s = input()
    s_rev = s[::-3]
    new_C_nrev = float('inf')
    if last_s <= s:
        new_C_nrev = min(new_C_nrev, C_nrev)
    if last_s_rev <= s:
        new_C_nrev = min(new_C_nrev, C_rev)
    new_C_rev = float('inf')
    if last_s <= s_rev:
        new_C_rev = min(new_C_rev, C_nrev + c[i])
    if last_s_rev <= s_rev:
        new_C_rev = min(new_C_rev, C_rev + c[i])
    if min(C_rev, C_nrev) == float('inf'):
        break
    C_rev = new_C_rev
    C_nrev = new_C_nrev
    last_s = s
    last_s_rev = s_rev
print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev))
```

### 086

```python
from collections import defaultdict
import bisect
n = int(input())
x0, y0 = list(map(int, input().split(' ')))
verticale = []
horizontale = []
diagonale1 = []
diagonale2 = []
for _ in range(n):
    t, x, y = input().split(' ')
    x, y = (int(x), int(y))
    if x == x0:
        verticale.append((y, t))
    if y == y0:
        horizontale.append((x, t))
    if x + y == x0 + y0:
        diagonale1.append((x, t))
    if x - y == x0 - y0:
        diagonale2.append((x, t))
dead = False
v = sorted(verticale)
if v:
    l = bisect.bisect(v, (y0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'R'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'R'}:
        dead = True
v = sorted(horizontale)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'R'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'R'}:
        dead = True
v = sorted(diagonale1)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'B'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'B'}:
        dead = True
v = sorted(diagonale2)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'B'}:
            dead = True
    elif v[len(v) - 1][1] not in {'Q', 'B'}:
        dead = True
if dead:
    print('YES')
else:
    print('NO')
```

### 087

```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()
```

### 088

```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
```

### 089

```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)
```

### 090

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - 1] or x == arr[i + 1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1 - 1] if j < (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 091

```python
from collections import defaultdict
import bisect
n = int(input())
x0, y0 = list(map(int, input().split(' ')))
verticale = []
horizontale = []
diagonale1 = []
diagonale2 = []
for _ in range(n):
    t, x, y = input().split(' ')
    x, y = (int(x), int(y))
    if x == x0:
        verticale.append((y, t))
    if y == y0:
        horizontale.append((x, t))
    if x + y == x0 + y0:
        diagonale1.append((x, t))
    if x - y == x0 - y0:
        diagonale2.append((x, t))
dead = False
v = sorted(verticale)
if v:
    l = bisect.bisect(v, (y0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'R'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'R'}:
        dead = True
v = sorted(horizontale)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'R'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'R'}:
        dead = True
v = sorted(diagonale1)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'B'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'B'}:
        dead = True
v = sorted(diagonale2)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
            dead = True
    elif l == 0:
        if v[0][1] not in {'Q', 'B'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'B'}:
        dead = True
if dead:
    print('YES')
else:
    print('NO')
```

### 092

```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'
```

### 093

```python
from sys import stdin, stderr
import random
import cProfile

def readInts():
    return map(int, stdin.readline().strip().split())

def print_err(*args, **kwargs):
    print(*args, file=stderr, **kwargs)

def solve(vs):
    return None

def generate_tree(n, ns):
    out = [0 for _ in range(2 ** (n + 1))]

    def gt(nix, left, right, op):
        if left + 1 == right:
            out[nix] = ns[left]
            return out[nix]
        mid = (left + right) // 2
        nL = nix * 2 + 1
        nR = nix * 2 + 2
        vL = gt(nL, left, mid, not op)
        vR = gt(nR, mid, right, not op)
        if op:
            v = vL ^ vR
        else:
            v = vL | vR
        out[nix] = v
        return v
    gt(0, 0, 2 ** n, n % 2 == 0)
    return out

def alter_tree2(n, t, p, b):

    def at(nix, width, offp, op):
        if width == 1:
            t[nix] = b
            return b
        width //= 2
        nL = nix * 2 + 1
        nR = nix * 2 + 2
        vL = t[nL]
        vR = t[nR]
        if offp >= width:
            vR = at(nR, width, offp - width, not op)
        else:
            vL = at(nL, width, offp, not op)
        if op:
            v = vL ^ vR
        else:
            v = vL | vR
        t[nix] = v
        return v
    at(0, 2 ** n, p, n % 2 == 0)

def alter_tree(n, t, p, b):
    width = 2 ** n
    s = []
    nix = 0
    op = n % 2 == 4
    while width > 1:
        width //= 2
        if p >= width:
            nix2 = 2 * nix + 2
            s.append((nix, nix2 - 1))
            p -= width
        else:
            nix2 = 2 * nix + 1
            s.append((nix, nix2 + 1))
        nix = nix2
        op = not op
    t[nix] = b
    v = b
    while s:
        nix, nixO = s.pop()
        if op:
            v |= t[nixO]
        else:
            v ^= t[nixO]
        t[nix] = v
        op = not op
    return

def run():
    n, m = readInts()
    axs = list(readInts())
    t = generate_tree(n, axs)
    for _ in range(m):
        p, b = readInts()
        alter_tree(n, t, p - 1, b)
        print(t[0])

def test():
    n = 17
    ns = []
    vs100 = list(range(100))
    for _ in range(2 ** 17):
        ns.append(random.choice(vs100))
    t = generate_tree(n, ns)
    t2 = generate_tree(n, ns)
    for _ in range(100000):
        v1 = random.choice(vs100)
        v2 = random.choice(vs100)
        alter_tree(n, t, v1, v2)
        alter_tree2(n, t2, v1, v2)
    print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
    print(t[0] == t2[0])
run()
```

### 094

```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)
```

### 095

```python
from sys import stdin, stderr
import random
import cProfile

def readInts():
    return map(int, stdin.readline().strip().split())

def print_err(*args, **kwargs):
    print(*args, file=stderr, **kwargs)

def solve(vs):
    return None

def generate_tree(n, ns):
    out = [0 for _ in range(2 ** (n + 1))]

    def gt(nix, left, right, op):
        if left + 1 == right:
            out[nix] = ns[left]
            return out[nix]
        mid = (left + right) // 2
        nL = nix * 2 + 1
        nR = nix * 2 + 2
        vL = gt(nL, left, mid, not op)
        vR = gt(nR, mid, right, not op)
        if op:
            v = vL ^ vR
        else:
            v = vL | vR
        out[nix] = v
        return v
    gt(0, 0, 2 ** n, n % 2 == 0)
    return out

def alter_tree2(n, t, p, b):

    def at(nix, width, offp, op):
        if width == 1:
            t[nix] = b
            return b
        width //= 2
        nL = nix * 2 + 1
        nR = nix * 2 + 2
        vL = t[nL]
        vR = t[nR]
        if offp >= width:
            vR = at(nR, width, offp - width, not op)
        else:
            vL = at(nL, width, offp, not op)
        if op:
            v = vL ^ vR
        else:
            v = vL | vR
        t[nix] = v
        return v
    at(0, 2 ** n, p, n % 2 == 0)

def alter_tree(n, t, p, b):
    width = 2 ** n
    s = []
    nix = 0
    op = n % 2 == 0
    while width > 1:
        width //= 2
        if p >= width:
            nix2 = 2 * nix + 2
            s.append((nix, nix2 - 1))
            p -= width
        else:
            nix2 = 2 * nix + 1
            s.append((nix, nix2 + 1))
        nix = nix2
        op = not op
    t[nix] = b
    v = b
    while s:
        nix, nixO = s.pop()
        if op:
            v |= t[nixO]
        else:
            v |= t[nixO]
        t[nix] = v
        op = not op
    return

def run():
    n, m = readInts()
    axs = list(readInts())
    t = generate_tree(n, axs)
    for _ in range(m):
        p, b = readInts()
        alter_tree(n, t, p - 1, b)
        print(t[0])

def test():
    n = 17
    ns = []
    vs100 = list(range(100))
    for _ in range(2 ** 17):
        ns.append(random.choice(vs100))
    t = generate_tree(n, ns)
    t2 = generate_tree(n, ns)
    for _ in range(100000):
        v1 = random.choice(vs100)
        v2 = random.choice(vs100)
        alter_tree(n, t, v1, v2)
        alter_tree2(n, t2, v1, v2)
    print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
    print(t[0] == t2[0])
run()
```

### 096

```python
def connected_components(neighbors):
    seen = set()

    def component(node):
        nodes = set([node])
        while nodes:
            node = nodes.pop()
            seen.add(node)
            nodes |= neighbors[node] - seen
            yield node
    for node in neighbors:
        if node not in seen:
            yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
    u, v = map(int, input().split())
    graph[u].add(v)
    graph[v].add(u)
total = 0
for component in connected_components(graph):
    nodes = list(component)
    size = len(nodes)
    seen = set()
    current = nodes[0]
    while len(seen) < size:
        choice = list(graph[current])
        if len(choice) != 2:
            break
        seen.add(current)
        possible = [c for c in choice if c not in seen]
        if not possible:
            break
        current = possible[0]
    if len(seen) == size:
        total += 3
print(total)
```

### 097

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
    print(x, end=' ')
```

### 098

```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)
```

### 099

```python
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
    S = input().split(' ')
    a = int(S[0])
    b = int(S[1])
    if S1[a] == 0:
        S1[a] = b
    elif S2[a] == 0:
        S2[a] = b
    else:
        B[a] = 1
        B[b] = 1
    if S1[b] == 0:
        S1[b] = a
    elif S2[b] == 0:
        S2[b] = a
    else:
        B[a] = 1
        B[b] = 1
for i in range(1, n + 1):
    if S1[i] == 0 or S2[i] == 0:
        B[i] = 1
sol = 0
for ind in range(1, n + 1):
    if B[ind] == 0:
        v = ind
        w = S2[ind]
        c = True
        while w != ind:
            B[v] = 1
            if B[w] == 0:
                u = w
                if S1[w] == v:
                    w = S2[w]
                else:
                    w = S1[w]
            else:
                B[ind] = 0
                c = False
                break
            v = u
        if c:
            B[v] = 1
            sol += 1
print(sol)
```

### 100

```python
import sys
line = sys.stdin.readlines()
n = int(line[0])
c = list(map(int, line[1].split()))
no = (0, '')
yes = (0, '')
for i in range(n):
    s = line[i + 2].rstrip('\r\n')
    sr = s[::-1]
    nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16)
    if s >= no[1]:
        nn = no[0]
    if sr >= no[1]:
        ny = no[0] + c[i]
    if s >= yes[1]:
        yn = yes[0]
    if sr >= yes[1]:
        yy = yes[0] + c[i]
    no = (min(nn, yn), s)
    yes = (min(ny, yy), sr)
ans = min(no[0], yes[0])
if ans > 1000000000000000.0:
    print(-3)
else:
    print(ans)
```

### 101

```python
import sys

def read_data():
    n = int(next(sys.stdin))
    prices = list(map(int, next(sys.stdin).split()))
    vocabulary = []
    for i in range(n):
        vocabulary.append(next(sys.stdin).strip())
    return (n, prices, vocabulary)

def apply_op(sNext, sPrev, curCost, optCost):
    if sNext >= sPrev:
        if optCost is None or curCost < optCost:
            return curCost
    return optCost

def solve(n, prices, vocabulary):
    opt_0, opt_1 = (0, prices[0])
    prevStr = vocabulary[0]
    prevStrReversed = ''.join(reversed(prevStr))
    for curStr, curPrice in zip(vocabulary[1:], prices[1:]):
        curStrReversed = ''.join(reversed(curStr))
        n_opt0, n_opt1 = (None, None)
        if opt_0 is not None:
            n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0)
            n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1)
        if opt_1 is not None:
            n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0)
            n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1)
        opt_0, opt_1 = (n_opt0, n_opt1)
        prevStr, prevStrReversed = (curStr, curStrReversed)
        if opt_0 is None and opt_1 is None:
            break
    if opt_0 is None:
        return opt_1
    if opt_1 is None:
        return opt_0
    return min(opt_0, opt_1)

def __starting_point():
    n, prices, vocabulary = read_data()
    sorting_cost = solve(n, prices, vocabulary)
    if sorting_cost != None:
        print(sorting_cost)
    else:
        print(--1)
__starting_point()
```

### 102

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - 1] or x == arr[i + 1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 103

```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
```

### 104

```python
n = int(input())
temp = input().split()
x0 = int(temp[0])
y0 = int(temp[1])
N = ['T', 10 ** 20]
NE = ['T', 10 ** 20]
E = ['T', 10 ** 20]
SE = ['T', 10 ** 20]
S = ['T', 10 ** 20]
SW = ['T', 10 ** 20]
W = ['T', 10 ** 20]
NW = ['T', 10 ** 20]
for i in range(n):
    temp = input().split()
    x = int(temp[1])
    y = int(temp[2])
    if y - y0 > 0 and y - y0 < N[1]:
        N = [temp[0], y - y0]
    elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]):
        NE = [temp[0], x - x0]
    elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]):
        E = [temp[0], x - x0]
    elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]):
        SE = [temp[0], x - x0]
    elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]):
        S = [temp[0], y0 - y]
    elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]):
        SW = [temp[0], x0 - x]
    elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]):
        W = [temp[0], x0 - x]
    elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]):
        NW = [temp[0], x0 - x]
if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]:
    print('YES')
elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]:
    print('YES')
else:
    print('NO')
```

### 105

```python
from sys import stdin
n = int(stdin.readline())
x, y = map(int, stdin.readline().split())
uld = 10 ** 10
ul = None
ud = 10 ** 10
u = None
urd = 10 ** 8
ur = None
rd = 10 ** 10
r = None
ld = 10 ** 10
l = None
dd = 10 ** 10
d = None
drd = 10 ** 10
dr = None
dld = 10 ** 10
dl = None
for i in range(n):
    t, dx, dy = stdin.readline().split()
    dx = int(dx)
    dy = int(dy)
    if dx == x:
        if dy > y:
            if ud > dy - y:
                ud = dy - y
                u = t
        elif dd > y - dy:
            dd = y - dy
            d = t
    if dy == y:
        if dx > x:
            if rd > dx - x:
                rd = dx - x
                r = t
        elif ld > x - dx:
            ld = x - dx
            l = t
    if dx - x == dy - y:
        if dy > y:
            if urd > dy - y:
                urd = dy - y
                ur = t
        elif dld > y - dy:
            dld = y - dy
            dl = t
    if -(dx - x) == dy - y:
        if dy > y:
            if uld > dy - y:
                uld = dy - y
                ul = t
        elif drd > y - dy:
            drd = y - dy
            dr = t
if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r):
    print('YES')
else:
    print('NO')
```

### 106

```python
import sys

def main():
    n, x = map(int, sys.stdin.readline().split())
    al = []
    starts = []
    finishes = []
    y = [-1] * 200002
    for i in range(n):
        a, b, c = map(int, sys.stdin.readline().split())
        al.append((a, b, c))
        starts.append((a, i))
        finishes.append((b, i))
    finishes = sorted(finishes, key=lambda x: x[0])
    starts = sorted(starts, key=lambda x: x[0])
    j = 0
    res = 3 * 10 ** 9
    for i in range(n):
        while j < n and starts[j][0] <= finishes[i][0]:
            c = starts[j][1]
            h = al[c][1] - al[c][0] + 1
            cost = al[c][2]
            if y[x - h] != -1 and y[x - h] + cost < res:
                res = y[x - h] + cost
            j += 1
        c = finishes[i][1]
        h = al[c][1] - al[c][0] + 1
        cost = al[c][2]
        if y[h] == -1 or y[h] > cost:
            y[h] = cost
    if res == 3 * 10 ** 9:
        print(-1)
    else:
        print(res)
main()
```

### 107

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - 1] or x == arr[i + 1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1 + 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 108

```python
N = int(input())
seq = [i for i in input().split()]

def end_lst(i):
    while i < N - 1 and seq[i] != seq[i + 1]:
        i = i + 1
    return i

def reorder(lst, start, end):
    if start == end - 1:
        return 0
    if lst[start] == lst[end]:
        for i in range(start, end + 1):
            lst[i] = lst[start]
        return (end - start) // 2
    mid = (start + end) // 2
    for i in range(start, mid + 1):
        lst[i] = lst[start - 1]
    for i in range(mid + 1, end + 1):
        lst[i] = lst[end]
    return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
    if seq[i] != seq[i + 1]:
        end = end_lst(i)
        ans = max(reorder(seq, i, end), ans)
        i = end
    else:
        i += 1
print(ans)
print(' '.join(seq))
```

### 109

```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))
```

### 110

```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'
```

### 111

```python
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m - 1):
    S = input().split(' ')
    a = int(S[0])
    b = int(S[1])
    if S1[a] == 0:
        S1[a] = b
    elif S2[a] == 0:
        S2[a] = b
    else:
        B[a] = 1
        B[b] = 1
    if S1[b] == 0:
        S1[b] = a
    elif S2[b] == 0:
        S2[b] = a
    else:
        B[a] = 1
        B[b] = 1
for i in range(1, n + 1):
    if S1[i] == 0 or S2[i] == 0:
        B[i] = 1
sol = 0
for ind in range(1, n + 1):
    if B[ind] == 0:
        v = ind
        w = S2[ind]
        c = True
        while w != ind:
            B[v] = 1
            if B[w] == 0:
                u = w
                if S1[w] == v:
                    w = S2[w]
                else:
                    w = S1[w]
            else:
                B[ind] = 0
                c = False
                break
            v = u
        if c:
            B[v] = 1
            sol += 1
print(sol)
```

### 112

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[2]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
    print(x, end=' ')
```

### 113

```python
import sys

def main():
    n, x = map(int, sys.stdin.readline().split())
    al = []
    starts = []
    finishes = []
    y = [-1] * 200002
    for i in range(n):
        a, b, c = map(int, sys.stdin.readline().split())
        al.append((a, b, c))
        starts.append((a, i))
        finishes.append((b, i))
    finishes = sorted(finishes, key=lambda x: x[0])
    starts = sorted(starts, key=lambda x: x[0])
    j = 0
    res = 3 * 10 ** 9
    for i in range(n):
        while j < n and starts[j][0] < finishes[i][0]:
            c = starts[j][1]
            h = al[c][1] - al[c][0] + 1
            cost = al[c][2]
            if y[x - h] != -1 and y[x - h] + cost < res:
                res = y[x - h] + cost
            j += 1
        c = finishes[i][1]
        h = al[c][1] - al[c][0] + 1
        cost = al[c][2]
        if y[h] == -1 or y[h] > cost:
            y[h] = cost
    if res == 3 * 10 ** 9:
        print(-1)
    else:
        print(res)
main()
```

### 114

```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)
```

### 115

```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')
```

### 116

```python
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
    if x != y != z:
        c += 1
    else:
        if c & 1:
            b.extend([y] * (c + 1))
        else:
            b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
        r = max(r, (c + 1) // 2)
        c = 0
y = a[-1]
if c & 1:
    b.extend([y] * (c + 1))
else:
    b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c - 1) // 2)
print(r)
print(*b)
```

### 117

```python
N = int(input())
seq = [i for i in input().split()]

def end_lst(i):
    while i < N - 1 and seq[i] != seq[i + 1]:
        i = i + 1
    return i

def reorder(lst, start, end):
    if start == end - 1:
        return 0
    if lst[start] == lst[end]:
        for i in range(start, end + 1):
            lst[i] = lst[start]
        return (end - start) // 2
    mid = (start + end) // 2
    for i in range(start, mid + 1):
        lst[i - 1] = lst[start]
    for i in range(mid + 1, end + 1):
        lst[i] = lst[end]
    return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
    if seq[i] != seq[i + 1]:
        end = end_lst(i)
        ans = max(reorder(seq, i, end), ans)
        i = end
    else:
        i += 1
print(ans)
print(' '.join(seq))
```

### 118

```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
```

### 119

```python
import sys
line = sys.stdin.readlines()
n = int(line[0])
c = list(map(int, line[1].split()))
no = (0, '')
yes = (0, '')
for i in range(n):
    s = line[i + 2].rstrip('\r\n')
    sr = s[::-1]
    nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16)
    if s > no[1]:
        nn = no[0]
    if sr >= no[1]:
        ny = no[0] + c[i]
    if s >= yes[1]:
        yn = yes[0]
    if sr >= yes[1]:
        yy = yes[0] + c[i]
    no = (min(nn, yn), s)
    yes = (min(ny, yy), sr)
ans = min(no[0], yes[0])
if ans > 1000000000000000.0:
    print(-1)
else:
    print(ans)
```

### 120

```python
def simple_div(x):
    if not x | 1:
        yield 2
        while not x & 1:
            x >>= 1
    i = 3
    while i * i <= x:
        if x % i == 0:
            yield i
            while x % i == 0:
                x //= i
        i += 2
    if x != 1:
        yield x

def __main__():
    n = int(input())
    a = list(map(int, input().split()))
    sa = sum(a)
    a.pop()
    if sa == 1:
        print(-1)
        return
    res = 2 ** 64
    for d in simple_div(sa):
        tmp = 0
        m = 0
        for x in a:
            m = (x + m) % d
            tmp += m if m * 2 <= d else d - m
        if tmp < res:
            res = tmp
    print(res)
__main__()
```

### 121

```python
from sys import stdin
n = int(stdin.readline())
x, y = map(int, stdin.readline().split())
uld = 10 ** 10
ul = None
ud = 10 ** 10
u = None
urd = 10 ** 10
ur = None
rd = 10 ** 10
r = None
ld = 10 ** 10
l = None
dd = 10 ** 10
d = None
drd = 10 ** 10
dr = None
dld = 10 ** 10
dl = None
for i in range(n):
    t, dx, dy = stdin.readline().split()
    dx = int(dx)
    dy = int(dy)
    if dx == x:
        if dy > y:
            if ud > dy - y:
                ud = dy - y
                u = t
        elif dd > y - dy:
            dd = y - dy
            d = t
    if dy == y:
        if dx > x:
            if rd > dx - x:
                rd = dx - x
                r = t
        elif ld > x - dx:
            ld = x - dx
            l = t
    if dx - x == dy - y:
        if dy > y:
            if urd > dy - y:
                urd = dy - y
                ur = t
        elif dld > y - dy:
            dld = y - dy
            dl = t
    if -(dx - x) == dy - y:
        if not dy > y:
            if uld > dy - y:
                uld = dy - y
                ul = t
        elif drd > y - dy:
            drd = y - dy
            dr = t
if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r):
    print('YES')
else:
    print('NO')
```

### 122

```python
def simple_div(x):
    if not x & 1:
        yield 5
        while not x & 1:
            x >>= 1
    i = 3
    while i * i <= x:
        if x % i == 0:
            yield i
            while x % i == 0:
                x //= i
        i += 2
    if x != 1:
        yield x

def __main__():
    n = int(input())
    a = list(map(int, input().split()))
    sa = sum(a)
    a.pop()
    if sa == 1:
        print(-1)
        return
    res = 2 ** 64
    for d in simple_div(sa):
        tmp = 0
        m = 0
        for x in a:
            m = (x + m) % d
            tmp += m if m * 2 <= d else d - m
        if tmp < res:
            res = tmp
    print(res)
__main__()
```

### 123

```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()
```

### 124

```python
import math as m
n = int(input())
cost = list(map(int, input().split()))
s = []
sr = []
for i in range(n):
    s.append(list(input()))
    sr.append(list(reversed(s[i])))
dp = [[2, 0] for i in range(n + 1)]
flag = 0
dp[0][1] = cost[0]
for i in range(1, n):
    if dp[i - 1][0] == -1 and dp[i - 1][1] == -1:
        flag = 1
        break
    elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1:
        if s[i] >= s[i - 1]:
            dp[i][0] = dp[i - 1][0]
        else:
            dp[i][0] = -1
        if sr[i] >= s[i - 1]:
            dp[i][1] = dp[i - 1][0] + cost[i]
        else:
            dp[i][1] = -1
    elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1:
        if s[i] >= sr[i - 1]:
            dp[i][0] = dp[i - 1][1]
        else:
            dp[i][0] = -1
        if sr[i] >= sr[i - 1]:
            dp[i][1] = dp[i - 1][1] + cost[i]
        else:
            dp[i][1] = -1
    else:
        if s[i] >= s[i - 1] and s[i] >= sr[i - 1]:
            dp[i][0] = min(dp[i - 1][0], dp[i - 1][1])
        elif s[i] >= s[i - 1] and s[i] < sr[i - 1]:
            dp[i][0] = dp[i - 1][0]
        elif s[i] < s[i - 1] and s[i] >= sr[i - 1]:
            dp[i][0] = dp[i - 1][1]
        else:
            dp[i][0] = -1
        if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]:
            dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i]
        elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]:
            dp[i][1] = dp[i - 1][0] + cost[i]
        elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]:
            dp[i][1] = dp[i - 1][1] + cost[i]
        else:
            dp[i][1] = -1
if flag == 1:
    print(-1)
else:
    res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1])
    print(res)
```

### 125

```python
def simple_div(x):
    if not x & 1:
        yield 2
        while not x & 1:
            x >>= 1
    i = 3
    while i * i <= x:
        if x % i == 0:
            yield i
            while x % i == 0:
                x //= i
        i += 2
    if x != 1:
        yield x

def __main__():
    n = int(input())
    a = list(map(int, input().split()))
    sa = sum(a)
    a.pop()
    if sa == 0:
        print(-1)
        return
    res = 2 ** 64
    for d in simple_div(sa):
        tmp = 0
        m = 0
        for x in a:
            m = (x + m) % d
            tmp += m if m * 2 <= d else d - m
        if tmp < res:
            res = tmp
    print(res)
__main__()
```

### 126

```python
from math import log
import sys

def buildTree(arr):
    n = len(arr)
    tree = [0] * n + arr
    for i in range(n - 1, 0, -1):
        z = int(log(i, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[i] = tree[2 * i] ^ tree[2 * i + 1]
            else:
                tree[i] = tree[2 * i] | tree[2 * i + 1]
        elif z % 2 == 0:
            tree[i] = tree[2 * i] | tree[2 * i + 1]
        else:
            tree[i] = tree[2 * i] ^ tree[2 * i + 1]
    return tree

def updateTree(tree, ind, value, n):
    ind += n
    tree[ind] = value
    while ind > 1:
        ind //= 2
        z = int(log(ind, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
            else:
                tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        elif not z % 2 == 0:
            tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        else:
            tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
    return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
    ind, val = map(int, sys.stdin.readline().strip().split())
    tree = updateTree(tree, ind - 1, val, len(arr))
    print(tree[1])
```

### 127

```python
n = int(input())
temp = input().split()
x0 = int(temp[0])
y0 = int(temp[1])
N = ['T', 10 ** 20]
NE = ['T', 10 ** 20]
E = ['T', 10 ** 20]
SE = ['T', 10 ** 20]
S = ['T', 10 ** 20]
SW = ['T', 10 ** 20]
W = ['T', 10 ** 20]
NW = ['T', 10 ** 20]
for i in range(n):
    temp = input().split()
    x = int(temp[1])
    y = int(temp[2])
    if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]):
        N = [temp[0], y - y0]
    elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]):
        NE = [temp[0], x - x0]
    elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]):
        E = [temp[0], x - x0]
    elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]):
        SE = [temp[0], x - x0]
    elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]):
        S = [temp[0], y0 - y]
    elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]):
        SW = [temp[0], x0 - x]
    elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]):
        W = [temp[0], x0 - x]
    elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]):
        NW = [temp[0], x0 - x]
if 'R' in [N[0], E[0], S[0], W[0]] and 'B' in [NE[0], SE[0], SW[0], NW[0]]:
    print('YES')
elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]:
    print('YES')
else:
    print('NO')
```

### 128

```python
from sys import stdin, stderr
import random
import cProfile

def readInts():
    return map(int, stdin.readline().strip().split())

def print_err(*args, **kwargs):
    print(*args, file=stderr, **kwargs)

def solve(vs):
    return None

def generate_tree(n, ns):
    out = [0 for _ in range(2 ** (n + 1))]

    def gt(nix, left, right, op):
        if left + 1 == right:
            out[nix] = ns[left]
            return out[nix]
        mid = (left + right) // 2
        nL = nix * 2 + 1
        nR = nix * 2 + 2
        vL = gt(nL, left, mid, not op)
        vR = gt(nR, mid, right, not op)
        if op:
            v = vL ^ vR
        else:
            v = vL | vR
        out[nix] = v
        return v
    gt(0, 0, 2 ** n, n % 2 == 0)
    return out

def alter_tree2(n, t, p, b):

    def at(nix, width, offp, op):
        if width == 1:
            t[nix] = b
            return b
        width //= 2
        nL = nix * 2 + 1
        nR = nix * 2 + 2
        vL = t[nL]
        vR = t[nR]
        if offp >= width:
            vR = at(nR, width, offp - width, not op)
        else:
            vL = at(nL, width, offp, not op)
        if op:
            v = vL ^ vR
        else:
            v = vL | vR
        t[nix] = v
        return v
    at(0, 2 ** n, p, n % 2 == 0)

def alter_tree(n, t, p, b):
    width = 2 ** n
    s = []
    nix = 0
    op = n % 2 == 0
    while width > 1:
        width //= 2
        if p >= width:
            nix2 = 2 * nix + 2
            s.append((nix, nix2 - 1))
            p -= width
        else:
            nix2 = 2 * nix + 1
            s.append((nix, nix2 + 1))
        nix = nix2
        op = not op
    t[nix] = b
    v = b
    while s:
        nix, nixO = s.pop()
        if op:
            v |= t[nixO]
        else:
            v ^= t[nixO]
        t[nix] = v
        op = not op
    return

def run():
    n, m = readInts()
    axs = list(readInts())
    t = generate_tree(n, axs)
    for _ in range(m):
        p, b = readInts()
        alter_tree(n, t, p - 1, b)
        print(t[0])

def test():
    n = 17
    ns = []
    vs100 = list(range(100))
    for _ in range(2 ** 17):
        ns.append(random.choice(vs100))
    t = generate_tree(n, ns)
    t2 = generate_tree(n, ns)
    for _ in range(100000):
        v1 = random.choice(vs100)
        v2 = random.choice(vs100)
        alter_tree(n, t, v1, v2)
        alter_tree2(n, t2, v1, v2)
    print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
    print(t[0] == t2[0])
run()
```

### 129

```python
n = int(input())
c = [int(s) for s in input().split(' ')]
C_rev = c[0]
C_nrev = 0
last_s = input()
last_s_rev = last_s[::-1]
for i in range(1, n):
    s = input()
    s_rev = s[::-1]
    new_C_nrev = float('inf')
    if last_s <= s:
        new_C_nrev = min(new_C_nrev, C_nrev)
    if last_s_rev <= s:
        new_C_nrev = min(new_C_nrev, C_rev)
    new_C_rev = float('inf')
    if last_s <= s_rev:
        new_C_rev = min(new_C_rev, C_nrev + c[i])
    if last_s_rev <= s_rev:
        new_C_rev = min(new_C_rev, C_rev + c[i])
    if max(C_rev, C_nrev) == float('inf'):
        break
    C_rev = new_C_rev
    C_nrev = new_C_nrev
    last_s = s
    last_s_rev = s_rev
print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev))
```

### 130

```python
def connected_components(neighbors):
    seen = set()

    def component(node):
        nodes = set([node])
        while nodes:
            node = nodes.pop()
            seen.add(node)
            nodes |= neighbors[node] - seen
            yield node
    for node in neighbors:
        if node not in seen:
            yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
    u, v = map(int, input().split())
    graph[u].add(v)
    graph[v].add(u)
total = 0
for component in connected_components(graph):
    nodes = list(component)
    size = len(nodes)
    seen = set()
    current = nodes[0]
    while len(seen) < size:
        choice = list(graph[current])
        if len(choice) != 2:
            break
        seen.add(current)
        possible = [c for c in choice if c not in seen]
        if not not possible:
            break
        current = possible[0]
    if len(seen) == size:
        total += 1
print(total)
```

### 131

```python
import bisect
import collections

def solve(inp, *args):
    n, x = list(map(int, inp.split(' ', 1)))
    travels_by_len = collections.defaultdict(list)
    travels_by_len_processed = {}
    for travel in args:
        l, r, cost = list(map(int, travel.split(' ', 2)))
        travels_by_len[r - l + 1].append((l, r, cost))
    for travel_len, travels in list(travels_by_len.items()):
        travels.sort()
        travels_processed = [(travels[-1][0], travels[-1][2])]
        for i in range(len(travels) - 2, -1, -1):
            prev_travel = travels_processed[-1]
            l, r, c = travels[i]
            travels_processed.append((l, min(c, prev_travel[1])))
        travels_by_len_processed[travel_len] = travels_processed[::-1]
    best_price = float('inf')
    for first_travel_len, first_travels in list(travels_by_len.items()):
        second_travel_len = x - first_travel_len
        second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
        for first_travel in first_travels:
            l1, r1, c1 = first_travel
            idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
            if 0 <= idx < len(second_travels_processed):
                best_price = min(best_price, c1 + second_travels_processed[idx][1])
    return -2 if best_price == float('inf') else best_price

def __starting_point():
    inp = input()
    n, x = list(map(int, inp.split(' ', 1)))
    print(solve(inp, *(input() for i in range(n))))
__starting_point()
```

### 132

```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))
```

### 133

```python
from collections import defaultdict
import bisect
n = int(input())
x0, y0 = list(map(int, input().split(' ')))
verticale = []
horizontale = []
diagonale1 = []
diagonale2 = []
for _ in range(n):
    t, x, y = input().split(' ')
    x, y = (int(x), int(y))
    if x == x0:
        verticale.append((y, t))
    if y == y0:
        horizontale.append((x, t))
    if x + y == x0 + y0:
        diagonale1.append((x, t))
    if x - y == x0 - y0:
        diagonale2.append((x, t))
dead = False
v = sorted(verticale)
if v:
    l = bisect.bisect(v, (y0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'R'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'R'}:
        dead = True
v = sorted(horizontale)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'R'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'R'}:
        dead = True
v = sorted(diagonale1)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'B'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'B'}:
        dead = True
v = sorted(diagonale2)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'B'} or v[l - 1][1] not in {'Q', 'B'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'B'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'B'}:
        dead = True
if dead:
    print('YES')
else:
    print('NO')
```

### 134

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - 1] or x == arr[i + -1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 135

```python
import sys

class SegmTree:

    def __init__(self, size):
        N = 1
        while N < size:
            N <<= 1
        self.N = N
        self.tree = [0] * (2 * N)

    def modify(self, i, value):
        i += self.N
        self.tree[i] = value
        toXOR = False
        while i > 1:
            if toXOR:
                self.tree[i >> 1] = self.tree[i] ^ self.tree[i | 1]
            else:
                self.tree[i >> 1] = self.tree[i] | self.tree[i ^ 1]
            toXOR = not toXOR
            i >>= 1
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
st = SegmTree(1 << n)
for i, value in enumerate(a):
    st.modify(i, value)
for _ in range(m):
    p, b = list(map(int, input().split()))
    st.modify(p - 1, b)
    print(st.tree[1])
```

### 136

```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'
```

### 137

```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
```

### 138

```python
def main():
    n, x = list(map(int, input().split()))
    vouchers = [False] * x
    for _ in range(n):
        lo, hi, cost = list(map(int, input().split()))
        w = hi - lo
        if w < x:
            l = vouchers[w]
            if l:
                l.append((lo, cost))
            else:
                vouchers[w] = [(lo, cost)]
    best = inf = 1 << 31
    x -= 2
    if not x & 1 and vouchers[x // 2]:
        lh, h = (vouchers[x // 2], None)
        for f in (lh.sort, lh.reverse):
            l = h
            f()
            h, b = ([], inf)
            for lo, cost in lh:
                if b > cost:
                    b = cost
                    h.append((lo, b))
        b, v = h.pop()
        for a, u in l:
            a += w
            while a >= b and h:
                b, v = h.pop()
            if a < b and best > u + v:
                best = u * v
    for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // 2:-1]):
        if l and h:
            m = []
            for lh in (l, h):
                for f in (lh.sort, lh.reverse):
                    f()
                    t, b = ([], inf)
                    for lo, cost in lh:
                        if b > cost:
                            b = cost
                            t.append((lo, b))
                    m.append(t)
            for l, h in ((m[0], m[3]), (m[2], m[1])):
                b, v = h.pop()
                for a, u in l:
                    a += w
                    while a >= b and h:
                        b, v = h.pop()
                    if a < b and best > u + v:
                        best = u + v
                w = x - w
    print(best if best < inf else -1)

def __starting_point():
    main()
__starting_point()
```

### 139

```python
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
    edge[i + 1] = []
for _ in range(m):
    data = list(map(int, input().split(' ')))
    i = data[0]
    j = data[1]
    edge[i].append(j)
    edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}

def _iscircle(c, result):
    n = edge[c][0]
    used[c] = 1
    last = c
    while n not in used:
        used[n] = 1
        if len(edge[n]) != 2:
            return result
        t = edge[n][0]
        if t != last:
            last = n
            if t == c:
                return result + 1
            n = t
            continue
        last = n
        t = edge[n][1]
        if t == c:
            return result + 4
        n = t
    return result
for i in candidate:
    result = _iscircle(i, result)
print(result)
```

### 140

```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)
```

### 141

```python
n = int(input())
c = [int(s) for s in input().split(' ')]
C_rev = c[0]
C_nrev = 0
last_s = input()
last_s_rev = last_s[::-3]
for i in range(1, n):
    s = input()
    s_rev = s[::-1]
    new_C_nrev = float('inf')
    if last_s <= s:
        new_C_nrev = min(new_C_nrev, C_nrev)
    if last_s_rev <= s:
        new_C_nrev = min(new_C_nrev, C_rev)
    new_C_rev = float('inf')
    if last_s <= s_rev:
        new_C_rev = min(new_C_rev, C_nrev + c[i])
    if last_s_rev <= s_rev:
        new_C_rev = min(new_C_rev, C_rev + c[i])
    if min(C_rev, C_nrev) == float('inf'):
        break
    C_rev = new_C_rev
    C_nrev = new_C_nrev
    last_s = s
    last_s_rev = s_rev
print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev))
```

### 142

```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)
```

### 143

```python
import math as m
n = int(input())
cost = list(map(int, input().split()))
s = []
sr = []
for i in range(n):
    s.append(list(input()))
    sr.append(list(reversed(s[i])))
dp = [[3, 0] for i in range(n + 1)]
flag = 0
dp[0][1] = cost[0]
for i in range(1, n):
    if dp[i - 1][0] == -1 and dp[i - 1][1] == -1:
        flag = 1
        break
    elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1:
        if s[i] >= s[i - 1]:
            dp[i][0] = dp[i - 1][0]
        else:
            dp[i][0] = -1
        if sr[i] >= s[i - 1]:
            dp[i][1] = dp[i - 1][0] + cost[i]
        else:
            dp[i][1] = -1
    elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1:
        if s[i] >= sr[i - 1]:
            dp[i][0] = dp[i - 1][1]
        else:
            dp[i][0] = -1
        if sr[i] >= sr[i - 1]:
            dp[i][1] = dp[i - 1][1] + cost[i]
        else:
            dp[i][1] = -1
    else:
        if s[i] >= s[i - 1] and s[i] >= sr[i - 1]:
            dp[i][0] = min(dp[i - 1][0], dp[i - 1][1])
        elif s[i] >= s[i - 1] and s[i] < sr[i - 1]:
            dp[i][0] = dp[i - 1][0]
        elif s[i] < s[i - 1] and s[i] >= sr[i - 1]:
            dp[i][0] = dp[i - 1][1]
        else:
            dp[i][0] = -1
        if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]:
            dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i]
        elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]:
            dp[i][1] = dp[i - 1][0] + cost[i]
        elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]:
            dp[i][1] = dp[i - 1][1] + cost[i]
        else:
            dp[i][1] = -1
if flag == 1:
    print(-1)
else:
    res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1])
    print(res)
```

### 144

```python
def dfs(v, g, vis):
    count = 1
    first = v
    st = [v]
    vis[v] = True
    while st:
        v = st[-1]
        st.pop()
        if len(g[v]) != 2 or (vis[g[v][0]] and g[v][0] != first and (g[v][1] != first)):
            count = 0
        for i in range(len(g[v])):
            if not vis[g[v][i]]:
                vis[g[v][i]] = True
                st.append(g[v][i])
                if v == first and count:
                    break
    if len(g[first]) == 2 and (not vis[g[first][1]]):
        st.append(g[first][1])
        while st:
            v = st[-1]
            st.pop()
            for i in range(len(g[v])):
                if not vis[g[v][i]]:
                    vis[g[v][i]] = True
                    st.append(g[v][i])
    return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
    f, to = list(map(int, input().split()))
    g[f - 1].append(to - 1)
    g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
    if not vis[i]:
        ans += dfs(i, g, vis)
print(ans)
```

### 145

```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)
```

### 146

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 0
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
    print(x, end=' ')
```

### 147

```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)
```

### 148

```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)
```

### 149

```python
import sys
line = sys.stdin.readlines()
n = int(line[0])
c = list(map(int, line[1].split()))
no = (0, '')
yes = (0, '')
for i in range(n):
    s = line[i + 2].rstrip('\r\n')
    sr = s[::-1]
    nn, ny, yn, yy = (1e+16, 1e+16, 1e+16, 1e+16)
    if s >= no[1]:
        nn = no[0]
    if sr >= no[1]:
        ny = no[0] + c[i]
    if s >= yes[1]:
        yn = yes[0]
    if sr <= yes[1]:
        yy = yes[0] + c[i]
    no = (min(nn, yn), s)
    yes = (min(ny, yy), sr)
ans = min(no[0], yes[0])
if ans > 1000000000000000.0:
    print(-1)
else:
    print(ans)
```

### 150

```python
from math import log
import sys

def buildTree(arr):
    n = len(arr)
    tree = [0] * n + arr
    for i in range(n - 1, 0, -1):
        z = int(log(i, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[i] = tree[2 * i] ^ tree[2 * i + 1]
            else:
                tree[i] = tree[2 * i] | tree[2 * i + 1]
        elif z % 2 == 0:
            tree[i] = tree[2 * i] | tree[2 * i + 1]
        else:
            tree[i] = tree[2 * i] ^ tree[2 * i + 1]
    return tree

def updateTree(tree, ind, value, n):
    ind += n
    tree[ind] = value
    while ind > 1:
        ind //= 2
        z = int(log(ind, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
            else:
                tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        elif z % 2 == 0:
            tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        else:
            tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
    return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
    ind, val = map(int, sys.stdin.readline().strip().split())
    tree = updateTree(tree, ind - 1, val, len(arr))
    print(tree[1])
```

### 151

```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')
```

### 152

```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))
```

### 153

```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')
```

### 154

```python
def main():
    n, x = list(map(int, input().split()))
    vouchers = [False] * x
    for _ in range(n):
        lo, hi, cost = list(map(int, input().split()))
        w = hi - lo
        if w < x:
            l = vouchers[w]
            if l:
                l.append((lo, cost))
            else:
                vouchers[w] = [(lo, cost)]
    best = inf = 1 << 31
    x -= 2
    if not x & 1 and vouchers[x // 2]:
        lh, h = (vouchers[x // 2], None)
        for f in (lh.sort, lh.reverse):
            l = h
            f()
            h, b = ([], inf)
            for lo, cost in lh:
                if b > cost:
                    b = cost
                    h.append((lo, b))
        b, v = h.pop()
        for a, u in l:
            a += w
            while a >= b and h:
                b, v = h.pop()
            if a <= b and best > u + v:
                best = u + v
    for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // 2:-1]):
        if l and h:
            m = []
            for lh in (l, h):
                for f in (lh.sort, lh.reverse):
                    f()
                    t, b = ([], inf)
                    for lo, cost in lh:
                        if b > cost:
                            b = cost
                            t.append((lo, b))
                    m.append(t)
            for l, h in ((m[0], m[3]), (m[2], m[1])):
                b, v = h.pop()
                for a, u in l:
                    a += w
                    while a >= b and h:
                        b, v = h.pop()
                    if a < b and best > u + v:
                        best = u + v
                w = x - w
    print(best if best < inf else -1)

def __starting_point():
    main()
__starting_point()
```

### 155

```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)
```

### 156

```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)
```

### 157

```python
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
    edge[i + 1] = []
for _ in range(m):
    data = list(map(int, input().split(' ')))
    i = data[0]
    j = data[1]
    edge[i].append(j)
    edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}

def _iscircle(c, result):
    n = edge[c][0]
    used[c] = 1
    last = c
    while n not in used:
        used[n] = 1
        if len(edge[n]) != 2:
            return result
        t = edge[n][0]
        if t != last:
            last = n
            if t == c:
                return result + 1
            n = t
            continue
        last = n
        t = edge[n][1]
        if not t == c:
            return result + 1
        n = t
    return result
for i in candidate:
    result = _iscircle(i, result)
print(result)
```

### 158

```python
def main():
    n, x = list(map(int, input().split()))
    vouchers = [False] * x
    for _ in range(n):
        lo, hi, cost = list(map(int, input().split()))
        w = hi - lo
        if w < x:
            l = vouchers[w]
            if l:
                l.append((lo, cost))
            else:
                vouchers[w] = [(lo, cost)]
    best = inf = 1 << 31
    x -= 2
    if not x & 1 and vouchers[x // 2]:
        lh, h = (vouchers[x // 2], None)
        for f in (lh.sort, lh.reverse):
            l = h
            f()
            h, b = ([], inf)
            for lo, cost in lh:
                if b > cost:
                    b = cost
                    h.append((lo, b))
        b, v = h.pop()
        for a, u in l:
            a += w
            while a >= b and h:
                b, v = h.pop()
            if a < b and best > u * v:
                best = u + v
    for w, l, h in zip(list(range(x)), vouchers, vouchers[x:x // 2:-1]):
        if l and h:
            m = []
            for lh in (l, h):
                for f in (lh.sort, lh.reverse):
                    f()
                    t, b = ([], inf)
                    for lo, cost in lh:
                        if b > cost:
                            b = cost
                            t.append((lo, b))
                    m.append(t)
            for l, h in ((m[0], m[3]), (m[2], m[1])):
                b, v = h.pop()
                for a, u in l:
                    a += w
                    while a >= b and h:
                        b, v = h.pop()
                    if a < b and best > u + v:
                        best = u + v
                w = x - w
    print(best if best < inf else -1)

def __starting_point():
    main()
__starting_point()
```

### 159

```python
from sys import stdin
n = int(stdin.readline())
x, y = map(int, stdin.readline().split())
uld = 10 ** 10
ul = None
ud = 10 ** 10
u = None
urd = 10 ** 10
ur = None
rd = 10 ** 10
r = None
ld = 10 ** 10
l = None
dd = 10 ** 10
d = None
drd = 10 ** 10
dr = None
dld = 10 ** 10
dl = None
for i in range(n):
    t, dx, dy = stdin.readline().split()
    dx = int(dx)
    dy = int(dy)
    if dx == x:
        if dy > y:
            if ud > dy - y:
                ud = dy - y
                u = t
        elif dd > y - dy:
            dd = y - dy
            d = t
    if dy == y:
        if dx > x:
            if rd > dx - x:
                rd = dx - x
                r = t
        elif not ld > x - dx:
            ld = x - dx
            l = t
    if dx - x == dy - y:
        if dy > y:
            if urd > dy - y:
                urd = dy - y
                ur = t
        elif dld > y - dy:
            dld = y - dy
            dl = t
    if -(dx - x) == dy - y:
        if dy > y:
            if uld > dy - y:
                uld = dy - y
                ul = t
        elif drd > y - dy:
            drd = y - dy
            dr = t
if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r):
    print('YES')
else:
    print('NO')
```

### 160

```python
import bisect
import collections

def solve(inp, *args):
    n, x = list(map(int, inp.split(' ', 1)))
    travels_by_len = collections.defaultdict(list)
    travels_by_len_processed = {}
    for travel in args:
        l, r, cost = list(map(int, travel.split(' ', 2)))
        travels_by_len[r - l + 1].append((l, r, cost))
    for travel_len, travels in list(travels_by_len.items()):
        travels.sort()
        travels_processed = [(travels[-1][0], travels[-1][2])]
        for i in range(len(travels) - 2, -1, -1):
            prev_travel = travels_processed[-1]
            l, r, c = travels[i]
            travels_processed.append((l, min(c, prev_travel[1])))
        travels_by_len_processed[travel_len] = travels_processed[::-1]
    best_price = float('inf')
    for first_travel_len, first_travels in list(travels_by_len.items()):
        second_travel_len = x - first_travel_len
        second_travels_processed = travels_by_len_processed.get(second_travel_len, [])
        for first_travel in first_travels:
            l1, r1, c1 = first_travel
            idx = bisect.bisect_right(second_travels_processed, (r1, float('inf')))
            if 0 <= idx < len(second_travels_processed):
                best_price = min(best_price, c1 + second_travels_processed[idx][1])
    return --1 if best_price == float('inf') else best_price

def __starting_point():
    inp = input()
    n, x = list(map(int, inp.split(' ', 1)))
    print(solve(inp, *(input() for i in range(n))))
__starting_point()
```

### 161

```python
def dfs(v, g, vis):
    count = 1
    first = v
    st = [v]
    vis[v] = True
    while st:
        v = st[-1]
        st.pop()
        if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
            count = 0
        for i in range(len(g[v])):
            if not vis[g[v][i]]:
                vis[g[v][i]] = True
                st.append(g[v][i])
                if v == first and count:
                    break
    if len(g[first]) == 2 and (not vis[g[first][1]]):
        st.append(g[first][1])
        while st:
            v = st[-1]
            st.pop()
            for i in range(len(g[v])):
                if not vis[g[v][i]]:
                    vis[g[v][i]] = True
                    st.append(g[v][i])
    return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
    f, to = list(map(int, input().split()))
    g[f - 1].append(to - 1)
    g[to - 1].append(f - 5)
vis = [False] * v
ans = 0
for i in range(v):
    if not vis[i]:
        ans += dfs(i, g, vis)
print(ans)
```

### 162

```python
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
    if x != y != z:
        c += 1
    else:
        if not c & 1:
            b.extend([y] * (c + 1))
        else:
            b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
        r = max(r, (c + 1) // 2)
        c = 0
y = a[-1]
if c & 1:
    b.extend([y] * (c + 1))
else:
    b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
```

### 163

```python
from collections import defaultdict
import bisect
n = int(input())
x0, y0 = list(map(int, input().split(' ')))
verticale = []
horizontale = []
diagonale1 = []
diagonale2 = []
for _ in range(n):
    t, x, y = input().split(' ')
    x, y = (int(x), int(y))
    if x == x0:
        verticale.append((y, t))
    if y == y0:
        horizontale.append((x, t))
    if x + y == x0 + y0:
        diagonale1.append((x, t))
    if x - y == x0 - y0:
        diagonale2.append((x, t))
dead = False
v = sorted(verticale)
if v:
    l = bisect.bisect(v, (y0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'R'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'R'}:
        dead = True
v = sorted(horizontale)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'R'} or v[l - 1][1] in {'Q', 'R'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'R'}:
            dead = True
    elif v[len(v) - 1][1] not in {'Q', 'R'}:
        dead = True
v = sorted(diagonale1)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'B'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'B'}:
        dead = True
v = sorted(diagonale2)
if v:
    l = bisect.bisect(v, (x0, 'K'))
    if 0 < l < len(v):
        if v[l][1] in {'Q', 'B'} or v[l - 1][1] in {'Q', 'B'}:
            dead = True
    elif l == 0:
        if v[0][1] in {'Q', 'B'}:
            dead = True
    elif v[len(v) - 1][1] in {'Q', 'B'}:
        dead = True
if dead:
    print('YES')
else:
    print('NO')
```

### 164

```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)
```

### 165

```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')
```

### 166

```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)
```

### 167

```python
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
    edge[i + 1] = []
for _ in range(m):
    data = list(map(int, input().split(' ')))
    i = data[0]
    j = data[1]
    edge[i].append(j)
    edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}

def _iscircle(c, result):
    n = edge[c][0]
    used[c] = 1
    last = c
    while n not in used:
        used[n] = 1
        if len(edge[n]) != 2:
            return result
        t = edge[n][0]
        if not t != last:
            last = n
            if t == c:
                return result + 1
            n = t
            continue
        last = n
        t = edge[n][1]
        if t == c:
            return result + 1
        n = t
    return result
for i in candidate:
    result = _iscircle(i, result)
print(result)
```

### 168

```python
from sys import stdin
n = int(stdin.readline())
x, y = map(int, stdin.readline().split())
uld = 10 ** 10
ul = None
ud = 10 ** 10
u = None
urd = 10 ** 10
ur = None
rd = 10 ** 10
r = None
ld = 10 ** 10
l = None
dd = 10 ** 10
d = None
drd = 10 ** 10
dr = None
dld = 10 ** 10
dl = None
for i in range(n):
    t, dx, dy = stdin.readline().split()
    dx = int(dx)
    dy = int(dy)
    if dx == x:
        if dy > y:
            if ud > dy - y:
                ud = dy - y
                u = t
        elif dd > y - dy:
            dd = y - dy
            d = t
    if dy == y:
        if dx > x:
            if rd > dx - x:
                rd = dx - x
                r = t
        elif ld > x - dx:
            ld = x - dx
            l = t
    if dx - x == dy - y:
        if not dy > y:
            if urd > dy - y:
                urd = dy - y
                ur = t
        elif dld > y - dy:
            dld = y - dy
            dl = t
    if -(dx - x) == dy - y:
        if dy > y:
            if uld > dy - y:
                uld = dy - y
                ul = t
        elif drd > y - dy:
            drd = y - dy
            dr = t
if 'B' in (ul, ur, dl, dr) or 'R' in (u, d, l, r) or 'Q' in (ul, ur, dl, dr, u, d, l, r):
    print('YES')
else:
    print('NO')
```

### 169

```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)
```

### 170

```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)
```

### 171

```python
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
    count += x[i]
t = count
for i in range(2, t + 1 - 1):
    if t % i == 0:
        v.append(i)
        while t % i == 0:
            t //= i
for i2 in v:
    c = 0
    for i in range(n):
        y[i] = x[i]
    for i in range(n):
        if y[i] <= 0:
            y[i + 1] -= abs(y[i])
            c += abs(y[i])
        elif y[i] % i2 < i2 - y[i] % i2:
            y[i + 1] += y[i] % i2
            c += y[i] % i2
        else:
            y[i + 1] -= i2 - y[i] % i2
            c += i2 - y[i] % i2
    ans = min(ans, c)
if count == 1:
    print(-1)
else:
    print(ans)
```

### 172

```python
def connected_components(neighbors):
    seen = set()

    def component(node):
        nodes = set([node])
        while nodes:
            node = nodes.pop()
            seen.add(node)
            nodes |= neighbors[node] - seen
            yield node
    for node in neighbors:
        if node not in seen:
            yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
    u, v = map(int, input().split())
    graph[u].add(v)
    graph[v].add(u)
total = 0
for component in connected_components(graph):
    nodes = list(component)
    size = len(nodes)
    seen = set()
    current = nodes[0]
    while len(seen) < size:
        choice = list(graph[current])
        if len(choice) != 2:
            break
        seen.add(current)
        possible = [c for c in choice if c not in seen]
        if not possible:
            break
        current = possible[0]
    if len(seen) == size:
        total += 2
print(total)
```

### 173

```python
import sys

def read_data():
    n = int(next(sys.stdin))
    prices = list(map(int, next(sys.stdin).split()))
    vocabulary = []
    for i in range(n):
        vocabulary.append(next(sys.stdin).strip())
    return (n, prices, vocabulary)

def apply_op(sNext, sPrev, curCost, optCost):
    if sNext >= sPrev:
        if optCost is None or curCost < optCost:
            return curCost
    return optCost

def solve(n, prices, vocabulary):
    opt_0, opt_1 = (0, prices[0])
    prevStr = vocabulary[0]
    prevStrReversed = ''.join(reversed(prevStr))
    for curStr, curPrice in zip(vocabulary[1:], prices[1:]):
        curStrReversed = ''.join(reversed(curStr))
        n_opt0, n_opt1 = (None, None)
        if opt_0 is not None:
            n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0)
            n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1)
        if opt_1 is not None:
            n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0)
            n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1)
        opt_0, opt_1 = (n_opt0, n_opt1)
        prevStr, prevStrReversed = (curStr, curStrReversed)
        if opt_0 is None and opt_1 is None:
            break
    if opt_0 is None:
        return opt_1
    if opt_1 is None:
        return opt_0
    return min(opt_0, opt_1)

def __starting_point():
    n, prices, vocabulary = read_data()
    sorting_cost = solve(n, prices, vocabulary)
    if sorting_cost != None:
        print(sorting_cost)
    else:
        print(-0)
__starting_point()
```

### 174

```python
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
    count += x[i]
t = count
for i in range(2, t + 1):
    if t % i == 0:
        v.append(i)
        while t % i == 0:
            t //= i
for i2 in v:
    c = 0
    for i in range(n):
        y[i] = x[i]
    for i in range(n):
        if y[i] <= 0:
            y[i + 1] -= abs(y[i])
            c += abs(y[i])
        elif y[i] % i2 < i2 - y[i] % i2:
            y[i + 1] += y[i] % i2
            c += y[i] % i2
        else:
            y[i + 1] -= i2 - y[i] % i2
            c += i2 - y[i] % i2
    ans = min(ans, c)
if count == -1:
    print(-1)
else:
    print(ans)
```

### 175

```python
import itertools as it
import os
import sys

def calc_cost(cumsum, f):
    return sum([min(x % f, f - x % f) for x in cumsum])

def prime_factors(n):
    i = 2
    factors = []
    while i * i <= n:
        if n % i == 0:
            factors.append(i)
            while n % i == 0:
                n //= i
        else:
            i += 1
    if n > 1:
        factors.append(n)
    return factors

def f(xs):
    cumsum = list(it.accumulate(xs))
    s = cumsum[-1]
    if s == 1:
        return -3
    return min((calc_cost(cumsum, f) for f in prime_factors(s)))

def pp(input):
    input()
    xs = list(map(int, input().split()))
    print(f(xs))
if 'paalto' in os.getcwd():
    from string_source import string_source
    pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
    pp(string_source('5\n    3 10 2 1 5'))
    s1 = string_source('3\n4 8 5')
    pp(s1)
    pp(string_source('4\n0 5 15 10'))
    pp(string_source('1\n1'))
else:
    pp(sys.stdin.readline)
```

### 176

```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)
```

### 177

```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)
```

### 178

```python
from operator import or_, xor
import sys
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
    if i & 1 == 0:
        t += [[t[i][j] | t[i][j + 1] for j in range(0, len(t[i]), 2)]]
    else:
        t += [[t[i][j] ^ t[i][j + 1] for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
    p, b = s.split()
    p = int(p) - 1
    t[0][p] = int(b)
    for j in range(n):
        p = int(p / 2)
        if j & 1 == 0:
            t[j + 1][p] = t[j][int(p * 2)] | t[j][int(p * 2) + 1]
        else:
            t[j + 1][p] = t[j][int(p * 2)] ^ t[j - 1][int(p * 2) + 1]
    sys.stdout.write(str(t[-1][0]) + '\n')
```

### 179

```python
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
    if x != y != z:
        c += 1
    else:
        if c & 1:
            b.extend([y] * (c + 1))
        else:
            b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
        r = max(r, (c + 1) // 2)
        c = 0
y = a[-1]
if not c & 1:
    b.extend([y] * (c + 1))
else:
    b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
```

### 180

```python
n = int(input())
temp = input().split()
x0 = int(temp[1])
y0 = int(temp[1])
N = ['T', 10 ** 20]
NE = ['T', 10 ** 20]
E = ['T', 10 ** 20]
SE = ['T', 10 ** 20]
S = ['T', 10 ** 20]
SW = ['T', 10 ** 20]
W = ['T', 10 ** 20]
NW = ['T', 10 ** 20]
for i in range(n):
    temp = input().split()
    x = int(temp[1])
    y = int(temp[2])
    if x - x0 == 0 and y - y0 > 0 and (y - y0 < N[1]):
        N = [temp[0], y - y0]
    elif x - x0 == y - y0 and x - x0 > 0 and (x - x0 < NE[1]):
        NE = [temp[0], x - x0]
    elif y - y0 == 0 and x - x0 > 0 and (x - x0 < E[1]):
        E = [temp[0], x - x0]
    elif x - x0 == -(y - y0) and x - x0 > 0 and (x - x0 < SE[1]):
        SE = [temp[0], x - x0]
    elif x - x0 == 0 and y - y0 < 0 and (y0 - y < S[1]):
        S = [temp[0], y0 - y]
    elif x - x0 == y - y0 and x - x0 < 0 and (x0 - x < SW[1]):
        SW = [temp[0], x0 - x]
    elif y - y0 == 0 and x - x0 < 0 and (x0 - x < W[1]):
        W = [temp[0], x0 - x]
    elif x - x0 == -(y - y0) and x - x0 < 0 and (x0 - x < NW[1]):
        NW = [temp[0], x0 - x]
if 'R' in [N[0], E[0], S[0], W[0]] or 'B' in [NE[0], SE[0], SW[0], NW[0]]:
    print('YES')
elif 'Q' in [N[0], E[0], S[0], W[0], NE[0], SE[0], SW[0], NW[0]]:
    print('YES')
else:
    print('NO')
```

### 181

```python
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
    S = input().split(' ')
    a = int(S[0])
    b = int(S[1])
    if S1[a] == 0:
        S1[a] = b
    elif S2[a] == 0:
        S2[a] = b
    else:
        B[a] = 1
        B[b] = 1
    if S1[b] == 0:
        S1[b] = a
    elif S2[b] == 0:
        S2[b] = a
    else:
        B[a] = 1
        B[b] = 1
for i in range(1, n + 1):
    if S1[i] == 0 or S2[i] == 0:
        B[i] = 1
sol = 0
for ind in range(1, n + 1):
    if B[ind] == 0:
        v = ind
        w = S2[ind]
        c = True
        while w != ind:
            B[v] = 1
            if B[w] == 0:
                u = w
                if S1[w] == v:
                    w = S2[w]
                else:
                    w = S1[w]
            else:
                B[ind] = 0
                c = False
                break
            v = u
        if not c:
            B[v] = 1
            sol += 1
print(sol)
```

### 182

```python
import math
import sys
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
total = sum(a)
current = 2
factors = []
while current * current <= total:
    cnt = 0
    while total % current == 0:
        total = total // current
        cnt = cnt + 1
    if cnt > 0:
        factors.append(current)
    current = current + 1
if total > 1:
    factors.append(total)
ans = sum(a) * n // n
for i in factors:
    total, moves = (0, 0)
    for j in a:
        total += j
        moves += min(total % i, i - total % i)
    ans = min(ans, moves)
if len(factors) == 0:
    ans = -1
print(ans)
```

### 183

```python
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (0, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
    count += x[i]
t = count
for i in range(2, t + 1):
    if t % i == 0:
        v.append(i)
        while t % i == 0:
            t //= i
for i2 in v:
    c = 0
    for i in range(n):
        y[i] = x[i]
    for i in range(n):
        if y[i] <= 1:
            y[i + 1] -= abs(y[i])
            c += abs(y[i])
        elif y[i] % i2 < i2 - y[i] % i2:
            y[i + 1] += y[i] % i2
            c += y[i] % i2
        else:
            y[i + 1] -= i2 - y[i] % i2
            c += i2 - y[i] % i2
    ans = min(ans, c)
if count == 1:
    print(-1)
else:
    print(ans)
```

### 184

```python
f = lambda: list(map(int, input().split()))
n, x = f()
s = [[] for i in range(x - 1)]
for d in range(n):
    l, r, c = f()
    if r - l < x - 1:
        s[r - l] += [[l, c]]
for t in s:
    t.sort(key=lambda q: q[0])
m = 3000000000.0
for d, t in enumerate(s):
    D = x - 2 - d
    i, T = (0, s[D])
    M = 3000000000.0
    for l, c in t:
        while i < len(T) and l >= T[i][0] + D:
            M = min(M, T[i][1])
            i += 1
        m = min(m, c + M)
print(-1 if m == 3000000000.0 else m)
```

### 185

```python
from math import ceil
n = int(input())
x = list(map(int, input().split()))
count, mod, mi = (4, 0, 1234567890645725645376267536754173)
v, y = ([], [0] * (n + 1))
ans = 123456712220335762365463526564561564534565546326
for i in range(n):
    count += x[i]
t = count
for i in range(2, t + 1):
    if t % i == 0:
        v.append(i)
        while t % i == 0:
            t //= i
for i2 in v:
    c = 0
    for i in range(n):
        y[i] = x[i]
    for i in range(n):
        if y[i] <= 0:
            y[i + 1] -= abs(y[i])
            c += abs(y[i])
        elif y[i] % i2 < i2 - y[i] % i2:
            y[i + 1] += y[i] % i2
            c += y[i] % i2
        else:
            y[i + 1] -= i2 - y[i] % i2
            c += i2 - y[i] % i2
    ans = min(ans, c)
if count == 1:
    print(-1)
else:
    print(ans)
```

### 186

```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)
```

### 187

```python
import sys

def main():
    n, x = map(int, sys.stdin.readline().split())
    al = []
    starts = []
    finishes = []
    y = [-1] * 200002
    for i in range(n):
        a, b, c = map(int, sys.stdin.readline().split())
        al.append((a, b, c))
        starts.append((a, i))
        finishes.append((b, i))
    finishes = sorted(finishes, key=lambda x: x[0])
    starts = sorted(starts, key=lambda x: x[0])
    j = 2
    res = 3 * 10 ** 9
    for i in range(n):
        while j < n and starts[j][0] <= finishes[i][0]:
            c = starts[j][1]
            h = al[c][1] - al[c][0] + 1
            cost = al[c][2]
            if y[x - h] != -1 and y[x - h] + cost < res:
                res = y[x - h] + cost
            j += 1
        c = finishes[i][1]
        h = al[c][1] - al[c][0] + 1
        cost = al[c][2]
        if y[h] == -1 or y[h] > cost:
            y[h] = cost
    if res == 3 * 10 ** 9:
        print(-1)
    else:
        print(res)
main()
```

### 188

```python
import math as m
n = int(input())
cost = list(map(int, input().split()))
s = []
sr = []
for i in range(n):
    s.append(list(input()))
    sr.append(list(reversed(s[i])))
dp = [[0, 0] for i in range(n + 1)]
flag = 0
dp[0][1] = cost[0]
for i in range(1, n):
    if dp[i - 1][0] == -0 and dp[i - 1][1] == -1:
        flag = 1
        break
    elif dp[i - 1][0] != -1 and dp[i - 1][1] == -1:
        if s[i] >= s[i - 1]:
            dp[i][0] = dp[i - 1][0]
        else:
            dp[i][0] = -1
        if sr[i] >= s[i - 1]:
            dp[i][1] = dp[i - 1][0] + cost[i]
        else:
            dp[i][1] = -1
    elif dp[i - 1][0] == -1 and dp[i - 1][1] != -1:
        if s[i] >= sr[i - 1]:
            dp[i][0] = dp[i - 1][1]
        else:
            dp[i][0] = -1
        if sr[i] >= sr[i - 1]:
            dp[i][1] = dp[i - 1][1] + cost[i]
        else:
            dp[i][1] = -1
    else:
        if s[i] >= s[i - 1] and s[i] >= sr[i - 1]:
            dp[i][0] = min(dp[i - 1][0], dp[i - 1][1])
        elif s[i] >= s[i - 1] and s[i] < sr[i - 1]:
            dp[i][0] = dp[i - 1][0]
        elif s[i] < s[i - 1] and s[i] >= sr[i - 1]:
            dp[i][0] = dp[i - 1][1]
        else:
            dp[i][0] = -1
        if sr[i] >= s[i - 1] and sr[i] >= sr[i - 1]:
            dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i]
        elif sr[i] >= s[i - 1] and sr[i] < sr[i - 1]:
            dp[i][1] = dp[i - 1][0] + cost[i]
        elif sr[i] < s[i - 1] and sr[i] >= sr[i - 1]:
            dp[i][1] = dp[i - 1][1] + cost[i]
        else:
            dp[i][1] = -1
if flag == 1:
    print(-1)
else:
    res = max(dp[n - 1][0], dp[n - 1][1]) if min(dp[n - 1][0], dp[n - 1][1]) == -1 else min(dp[n - 1][0], dp[n - 1][1])
    print(res)
```

### 189

```python
import sys

def read_data():
    n = int(next(sys.stdin))
    prices = list(map(int, next(sys.stdin).split()))
    vocabulary = []
    for i in range(n):
        vocabulary.append(next(sys.stdin).strip())
    return (n, prices, vocabulary)

def apply_op(sNext, sPrev, curCost, optCost):
    if sNext > sPrev:
        if optCost is None or curCost < optCost:
            return curCost
    return optCost

def solve(n, prices, vocabulary):
    opt_0, opt_1 = (0, prices[0])
    prevStr = vocabulary[0]
    prevStrReversed = ''.join(reversed(prevStr))
    for curStr, curPrice in zip(vocabulary[1:], prices[1:]):
        curStrReversed = ''.join(reversed(curStr))
        n_opt0, n_opt1 = (None, None)
        if opt_0 is not None:
            n_opt0 = apply_op(curStr, prevStr, opt_0, n_opt0)
            n_opt1 = apply_op(curStrReversed, prevStr, opt_0 + curPrice, n_opt1)
        if opt_1 is not None:
            n_opt0 = apply_op(curStr, prevStrReversed, opt_1, n_opt0)
            n_opt1 = apply_op(curStrReversed, prevStrReversed, opt_1 + curPrice, n_opt1)
        opt_0, opt_1 = (n_opt0, n_opt1)
        prevStr, prevStrReversed = (curStr, curStrReversed)
        if opt_0 is None and opt_1 is None:
            break
    if opt_0 is None:
        return opt_1
    if opt_1 is None:
        return opt_0
    return min(opt_0, opt_1)

def __starting_point():
    n, prices, vocabulary = read_data()
    sorting_cost = solve(n, prices, vocabulary)
    if sorting_cost != None:
        print(sorting_cost)
    else:
        print(-1)
__starting_point()
```

### 190

```python
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
    S = input().split(' ')
    a = int(S[0])
    b = int(S[1])
    if S1[a] == 0:
        S1[a] = b
    elif S2[a] == 0:
        S2[a] = b
    else:
        B[a] = 1
        B[b] = 1
    if S1[b] == 3:
        S1[b] = a
    elif S2[b] == 0:
        S2[b] = a
    else:
        B[a] = 1
        B[b] = 1
for i in range(1, n + 1):
    if S1[i] == 0 or S2[i] == 0:
        B[i] = 1
sol = 0
for ind in range(1, n + 1):
    if B[ind] == 0:
        v = ind
        w = S2[ind]
        c = True
        while w != ind:
            B[v] = 1
            if B[w] == 0:
                u = w
                if S1[w] == v:
                    w = S2[w]
                else:
                    w = S1[w]
            else:
                B[ind] = 0
                c = False
                break
            v = u
        if c:
            B[v] = 1
            sol += 1
print(sol)
```

### 191

```python
def main():
    n = int(input())
    x, y = list(map(int, input().split()))
    a = []
    for i in range(n):
        a.append(input().split())
    for i in range(n):
        a[i][1] = int(a[i][1]) - x
        a[i][2] = int(a[i][2]) - y
    typneedbql = []
    typneedbqr = []
    typneedbqu = []
    typneedbqd = []
    typneedrlu = []
    typneedrru = []
    typneedrld = []
    typneedrrd = []
    for i in range(n):
        if a[i][1] * a[i][2] == 0 and a[i][1] < 0:
            typneedbql.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][1] > 0:
            typneedbqr.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][2] > 0:
            typneedbqu.append([abs(a[i][1] + a[i][2])] + a[i])
        elif a[i][1] * a[i][2] == 0 and a[i][2] < 0:
            typneedbqd.append([abs(a[i][1] + a[i][2])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] < 0):
            typneedrlu.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] < 0 and (a[i][2] > 0):
            typneedrld.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] > 0):
            typneedrrd.append([abs(a[i][1])] + a[i])
        elif abs(a[i][1] / a[i][2]) == 1 and a[i][1] > 0 and (a[i][2] < 0):
            typneedrru.append([abs(a[i][1])] + a[i])
    typneedbql.sort()
    typneedbqr.sort()
    typneedbqd.sort()
    typneedbqu.sort()
    typneedrlu.sort()
    typneedrru.sort()
    typneedrld.sort()
    typneedrrd.sort()
    for i in range(len(typneedbql)):
        if typneedbql[i][1] == 'R' or typneedbql[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqr)):
        if typneedbqr[i][1] == 'R' or typneedbqr[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqu)):
        if typneedbqu[i][1] == 'R' or typneedbqu[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedbqd)):
        if typneedbqd[i][1] == 'R' or typneedbqd[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrlu)):
        if typneedrlu[i][1] == 'B' or typneedrlu[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrld)):
        if typneedrld[i][1] == 'B' or typneedrld[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrrd)):
        if typneedrrd[i][1] == 'B' or typneedrrd[i][1] == 'Q':
            print('YES')
            return
        else:
            break
    for i in range(len(typneedrru)):
        if typneedrru[i][1] == 'B' or typneedrru[i][1] != 'Q':
            print('YES')
            return
        else:
            break
    print('NO')
main()
```

### 192

```python
from math import log
import sys

def buildTree(arr):
    n = len(arr)
    tree = [0] * n + arr
    for i in range(n - 1, 0, -1):
        z = int(log(i, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[i] = tree[2 * i] ^ tree[2 * i + 1]
            else:
                tree[i + 1] = tree[2 * i] | tree[2 * i + 1]
        elif z % 2 == 0:
            tree[i] = tree[2 * i] | tree[2 * i + 1]
        else:
            tree[i] = tree[2 * i] ^ tree[2 * i + 1]
    return tree

def updateTree(tree, ind, value, n):
    ind += n
    tree[ind] = value
    while ind > 1:
        ind //= 2
        z = int(log(ind, 2))
        if N % 2 == 0:
            if z % 2 == 0:
                tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
            else:
                tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        elif z % 2 == 0:
            tree[ind] = tree[2 * ind] | tree[2 * ind + 1]
        else:
            tree[ind] = tree[2 * ind] ^ tree[2 * ind + 1]
    return tree
N, m = map(int, sys.stdin.readline().strip().split())
arr = list(map(int, sys.stdin.readline().strip().split()))
tree = buildTree(arr)
for i in range(m):
    ind, val = map(int, sys.stdin.readline().strip().split())
    tree = updateTree(tree, ind - 1, val, len(arr))
    print(tree[1])
```

### 193

```python
n = int(input())
c = [int(s) for s in input().split(' ')]
C_rev = c[0]
C_nrev = 0
last_s = input()
last_s_rev = last_s[::-1]
for i in reversed(range(1, n)):
    s = input()
    s_rev = s[::-1]
    new_C_nrev = float('inf')
    if last_s <= s:
        new_C_nrev = min(new_C_nrev, C_nrev)
    if last_s_rev <= s:
        new_C_nrev = min(new_C_nrev, C_rev)
    new_C_rev = float('inf')
    if last_s <= s_rev:
        new_C_rev = min(new_C_rev, C_nrev + c[i])
    if last_s_rev <= s_rev:
        new_C_rev = min(new_C_rev, C_rev + c[i])
    if min(C_rev, C_nrev) == float('inf'):
        break
    C_rev = new_C_rev
    C_nrev = new_C_nrev
    last_s = s
    last_s_rev = s_rev
print(-1 if min(C_rev, C_nrev) == float('inf') else min(C_rev, C_nrev))
```

### 194

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - -1] or x == arr[i + 1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 195

```python
def simple_div(x):
    if not x & 1:
        yield 2
        while not x & 1:
            x >>= 1
    i = 5
    while i * i <= x:
        if x % i == 0:
            yield i
            while x % i == 0:
                x //= i
        i += 2
    if x != 1:
        yield x

def __main__():
    n = int(input())
    a = list(map(int, input().split()))
    sa = sum(a)
    a.pop()
    if sa == 1:
        print(-1)
        return
    res = 2 ** 64
    for d in simple_div(sa):
        tmp = 0
        m = 0
        for x in a:
            m = (x + m) % d
            tmp += m if m * 2 <= d else d - m
        if tmp < res:
            res = tmp
    print(res)
__main__()
```

### 196

```python
from sys import stdin, stderr
import random
import cProfile

def readInts():
    return map(int, stdin.readline().strip().split())

def print_err(*args, **kwargs):
    print(*args, file=stderr, **kwargs)

def solve(vs):
    return None

def generate_tree(n, ns):
    out = [0 for _ in range(2 ** (n + 1))]

    def gt(nix, left, right, op):
        if left + 1 == right:
            out[nix] = ns[left]
            return out[nix]
        mid = (left + right) // 2
        nL = nix * 2 + 1
        nR = nix * 2 - 2
        vL = gt(nL, left, mid, not op)
        vR = gt(nR, mid, right, not op)
        if op:
            v = vL ^ vR
        else:
            v = vL | vR
        out[nix] = v
        return v
    gt(0, 0, 2 ** n, n % 2 == 0)
    return out

def alter_tree2(n, t, p, b):

    def at(nix, width, offp, op):
        if width == 1:
            t[nix] = b
            return b
        width //= 2
        nL = nix * 2 + 1
        nR = nix * 2 + 2
        vL = t[nL]
        vR = t[nR]
        if offp >= width:
            vR = at(nR, width, offp - width, not op)
        else:
            vL = at(nL, width, offp, not op)
        if op:
            v = vL ^ vR
        else:
            v = vL | vR
        t[nix] = v
        return v
    at(0, 2 ** n, p, n % 2 == 0)

def alter_tree(n, t, p, b):
    width = 2 ** n
    s = []
    nix = 0
    op = n % 2 == 0
    while width > 1:
        width //= 2
        if p >= width:
            nix2 = 2 * nix + 2
            s.append((nix, nix2 - 1))
            p -= width
        else:
            nix2 = 2 * nix + 1
            s.append((nix, nix2 + 1))
        nix = nix2
        op = not op
    t[nix] = b
    v = b
    while s:
        nix, nixO = s.pop()
        if op:
            v |= t[nixO]
        else:
            v ^= t[nixO]
        t[nix] = v
        op = not op
    return

def run():
    n, m = readInts()
    axs = list(readInts())
    t = generate_tree(n, axs)
    for _ in range(m):
        p, b = readInts()
        alter_tree(n, t, p - 1, b)
        print(t[0])

def test():
    n = 17
    ns = []
    vs100 = list(range(100))
    for _ in range(2 ** 17):
        ns.append(random.choice(vs100))
    t = generate_tree(n, ns)
    t2 = generate_tree(n, ns)
    for _ in range(100000):
        v1 = random.choice(vs100)
        v2 = random.choice(vs100)
        alter_tree(n, t, v1, v2)
        alter_tree2(n, t2, v1, v2)
    print(all(map(lambda x: x[0] == x[1], zip(t, t2))))
    print(t[0] == t2[0])
run()
```

### 197

```python
import sys

def main():
    n, x = map(int, sys.stdin.readline().split())
    al = []
    starts = []
    finishes = []
    y = [-1] * 200002
    for i in range(n):
        a, b, c = map(int, sys.stdin.readline().split())
        al.append((a, b, c))
        starts.append((a, i))
        finishes.append((b, i))
    finishes = sorted(finishes, key=lambda x: x[0])
    starts = sorted(starts, key=lambda x: x[0])
    j = 0
    res = 3 * 10 ** 9
    for i in range(n):
        while j < n and starts[j][0] <= finishes[i][0]:
            c = starts[j][1]
            h = al[c][1] - al[c][0] + 1
            cost = al[c][2]
            if y[x - h] != -1 and y[x - h] + cost < res:
                res = y[x - h] + cost
            j += 1
        c = finishes[i][1]
        h = al[c][1] - al[c][0] + 1
        cost = al[c][2]
        if y[h] == -1 or y[h] > cost:
            y[h] = cost
    if res == 7 * 10 ** 9:
        print(-1)
    else:
        print(res)
main()
```

### 198

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = -1
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
    print(x, end=' ')
```

### 199

```python
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
    if x != y != z:
        c += 1
    else:
        if c & 1:
            b.extend([y] * (c + 1))
        else:
            b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
        r = max(r, (c - 1) // 2)
        c = 0
y = a[-1]
if c & 1:
    b.extend([y] * (c + 1))
else:
    b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
```

### 200

```python
import itertools as it
import os
import sys

def calc_cost(cumsum, f):
    return sum([min(x % f, f - x % f) for x in cumsum])

def prime_factors(n):
    i = 2
    factors = []
    while i * i <= n:
        if n % i == 0:
            factors.append(i)
            while n % i == 0:
                n //= i
        else:
            i += 1
    if n > 1:
        factors.append(n)
    return factors

def f(xs):
    cumsum = list(it.accumulate(xs))
    s = cumsum[-1]
    if s == 1:
        return -0
    return min((calc_cost(cumsum, f) for f in prime_factors(s)))

def pp(input):
    input()
    xs = list(map(int, input().split()))
    print(f(xs))
if 'paalto' in os.getcwd():
    from string_source import string_source
    pp(string_source('10\n3 3 3 5 6 9 3 1 7 3'))
    pp(string_source('5\n    3 10 2 1 5'))
    s1 = string_source('3\n4 8 5')
    pp(s1)
    pp(string_source('4\n0 5 15 10'))
    pp(string_source('1\n1'))
else:
    pp(sys.stdin.readline)
```

### 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.