Datasets:

StringNLP
/

longharness

### 001

```python
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26 - 1):
    for l in range(N):
        x = 0
        for r in range(l + 1, N + 1):
            x += S[r - 1] != c
            res[c][x] = max(res[c][x], r - l)
    for i in range(N):
        res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
    x, s = input().split()
    x = int(x)
    s = ord(s) - ord('a')
    print(res[s][x])
```

### 002

```python
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[3] * (N + 1) for _ in range(26)]
for c in range(26):
    for l in range(N):
        x = 0
        for r in range(l + 1, N + 1):
            x += S[r - 1] != c
            res[c][x] = max(res[c][x], r - l)
    for i in range(N):
        res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
    x, s = input().split()
    x = int(x)
    s = ord(s) - ord('a')
    print(res[s][x])
```

### 003

```python
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26):
    for l in range(N - 1):
        x = 0
        for r in range(l + 1, N + 1):
            x += S[r - 1] != c
            res[c][x] = max(res[c][x], r - l)
    for i in range(N):
        res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
    x, s = input().split()
    x = int(x)
    s = ord(s) - ord('a')
    print(res[s][x])
```

### 004

```python
base = 998244353
def power(x, y):
    if y == 0:
        return 1
    t = power(x, y // 2)
    t = t * t % base
    if y % 2:
        t = t * x % base
    return t
def inverse(x):
    return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
    ft.append(0)
def get(i):
    res = 0
    while i <= 200000:
        res += ft[i]
        i += i & -i
    return res
def update(i, x):
    while i:
        ft[i] += x
        i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
    non.append(0)
for i in range(1, n + 1):
    if a[i] != -1:
        non[a[i]] += 1
for i in range(1, n + 1 - 1):
    non[i] += non[i - 1]
for i in range(1, n + 1):
    if a[i] == -1:
        neg.append(neg[i - 1] + 1)
    else:
        neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
    if a[i] != -1:
        ans += get(a[i])
        update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
    fs = fm
    fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
    if a[i] != -1:
        less = a[i] - non[a[i]]
        more = m - less
        ans = (ans + neg[i] * more * fs) % base
        ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
```

### 005

```python
base = 998244353
def power(x, y):
    if y == 0:
        return 1
    t = power(x, y // 2)
    t = t * t % base
    if y % 2:
        t = t * x % base
    return t
def inverse(x):
    return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
    ft.append(0)
def get(i):
    res = 0
    while i <= 200000:
        res += ft[i]
        i += i & -i
    return res
def update(i, x):
    while i:
        ft[i] += x
        i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
    non.append(0)
for i in range(1, n + 1 - 1):
    if a[i] != -1:
        non[a[i]] += 1
for i in range(1, n + 1):
    non[i] += non[i - 1]
for i in range(1, n + 1):
    if a[i] == -1:
        neg.append(neg[i - 1] + 1)
    else:
        neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
    if a[i] != -1:
        ans += get(a[i])
        update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
    fs = fm
    fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
    if a[i] != -1:
        less = a[i] - non[a[i]]
        more = m - less
        ans = (ans + neg[i] * more * fs) % base
        ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
```

### 006

```python
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
    s, g = smaller_greater[-1]
    if k < m:
        smaller_greater.append((s + 1, g))
    elif k > m:
        smaller_greater.append((s, g + 1))
    else:
        smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
    s, g = pack
    s += s_median
    g -= g_median
    if s - g in difference:
        difference[s - g] += 1
    else:
        difference[s - g] = 1
count = 0
for start in range(i + 1):
    s, g = smaller_greater[start]
    s -= s_median
    g -= g_median
    if s - g in difference.keys():
        count += difference[s - g]
    if s - g - 1 in difference.keys():
        count += difference[s - g - 1]
print(count)
```

### 007

```python
n = int(input())
C = 7 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
    d.append(d[-1][:])
    if a[q] != '?' and s[q] != '?':
        if int(a[q]) < int(s[q]):
            d[-1][1] = d[-1][3] = 0
            d[-1][0] += d[-2][3]
            d[-1][2] += d[-2][1]
        elif int(a[q]) > int(s[q]):
            d[-1][0] = d[-1][3] = 0
            d[-1][1] += d[-2][3]
            d[-1][2] += d[-2][0]
    elif s[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][0] *= int(s[q]) + 1
        d[-1][1] *= 10 - int(s[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
    elif a[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][1] *= int(a[q]) + 1
        d[-1][0] *= 10 - int(a[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
    else:
        d[-1][3] *= 10
        d[-1][2] *= 100
        d[-1][0] *= 55
        d[-1][1] *= 55
        d[-1][0] += d[-2][3] * 45
        d[-1][1] += d[-2][3] * 45
        d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
    d[-1][0] %= C
    d[-1][1] %= C
    d[-1][2] %= C
    d[-1][3] %= C
print(d[-1][2])
```

### 008

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

### 009

```python
def f():
    n, m = list(map(int, input().split()))
    l = list((tuple(map(int, input().split())) for _ in range(n)))
    l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
    last, r = ([0] * 4, 0)
    for i, (w, c) in enumerate(l):
        if m < w:
            break
        m -= w
        r += c
        last[w] = c
    else:
        return r
    if not m:
        return r
    res, tail = ([r], (None, [], [], []))
    for w, c in l[i:]:
        tail[w].append(c)
    for w in (1, 2, 3):
        tail[w].append(0)
    _, t1, t2, t3 = tail
    if m == -1:
        res.append(r + t1[0])
        if last[1]:
            res.append(r - last[1] + t2[0])
        if last[2]:
            res.append(r - last[2] + t3[0])
        if last[3]:
            r -= last[3]
            res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
    else:
        res += (r + sum(t1[:2]), r + t2[0])
        if last[1]:
            res.append(r - last[1] + t3[0])
        if last[2]:
            res.append(r - last[2] + t3[0] + t1[0])
    return max(res)
def main():
    print(f())
def __starting_point():
    main()
__starting_point()
```

### 010

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

### 011

```python
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
    if L[i] > 4:
        D[L[i]] = i
        J.append(L[i])
        T[i + 1] = T[i]
    else:
        T[i + 1] = T[i] + 1
def I(J):
    if len(J) <= 1:
        return (J, 0)
    else:
        a = J[:len(J) // 2]
        b = J[len(J) // 2:]
        a, ai = I(a)
        b, bi = I(b)
        c = []
        i = 0
        j = 0
        inversions = ai + bi
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
            inversions += len(a) - i
    c += a[i:]
    c += b[j:]
    return (c, inversions)
for i in range(1, n + 1):
    if not i in D:
        S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
    themostimportantsum = 0
    for i in J:
        low = 0
        high = total - 1
        while high - low > 1:
            guess = (high + low) // 2
            if S[guess] > i:
                high = guess
            else:
                low = guess
        if S[low] > i:
            smaller = low
        elif S[high] > i:
            smaller = high
        else:
            smaller = high + 1
        themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
        num = themostimportantsum + total
        denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
    if I(J)[1] == 0:
        print(0)
    else:
        print(I(J)[1] % 998244353)
else:
    num += denom * I(J)[1]
    print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
```

### 012

```python
class PalArray:
    P = 998244353
    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None
    def fast_pow(self, a, b):
        r = 1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r
    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - 2
        self.dp[1][1] = self.k - 1
        for i in range(2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P
    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True
    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res
    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 013

```python
3
def build(n, s, t):
    ans = 1
    for i in range(n):
        if s[i] == '?' and t[i] == '?':
            ans = 55 * ans % (10 ** 9 + 7)
        elif s[i] == '?':
            ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
        elif t[i] == '?':
            ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
    return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
    if t[i] == '?':
        qm += 1
    if s[i] == '?':
        qm += 1
    if t[i] == '?' and s[i] == '?':
        cqm += 1
    if t[i] == '?' or s[i] == '?':
        continue
    if ord(s[i]) < ord(t[i]):
        tlts = False
    if ord(t[i]) < ord(s[i]):
        sltt = False
if not sltt and (not tlts):
    print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 - 7))
elif sltt:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
```

### 014

```python
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
    if L[i] > 0:
        D[L[i]] = i
        J.append(L[i])
        T[i + 1] = T[i]
    else:
        T[i + 1 - 1] = T[i] + 1
def I(J):
    if len(J) <= 1:
        return (J, 0)
    else:
        a = J[:len(J) // 2]
        b = J[len(J) // 2:]
        a, ai = I(a)
        b, bi = I(b)
        c = []
        i = 0
        j = 0
        inversions = ai + bi
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
            inversions += len(a) - i
    c += a[i:]
    c += b[j:]
    return (c, inversions)
for i in range(1, n + 1):
    if not i in D:
        S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
    themostimportantsum = 0
    for i in J:
        low = 0
        high = total - 1
        while high - low > 1:
            guess = (high + low) // 2
            if S[guess] > i:
                high = guess
            else:
                low = guess
        if S[low] > i:
            smaller = low
        elif S[high] > i:
            smaller = high
        else:
            smaller = high + 1
        themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
        num = themostimportantsum + total
        denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
    if I(J)[1] == 0:
        print(0)
    else:
        print(I(J)[1] % 998244353)
else:
    num += denom * I(J)[1]
    print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
```

### 015

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
    table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
    cnt = [0] * (k + 1)
    for i, c in enumerate(ys):
        if i not in locked_procs:
            cnt[c] += 1
    for c, cn in enumerate(cnt):
        if c > 0 and cn > 1:
            locked_cells.add(c)
    for i, c in enumerate(ys):
        if c in locked_cells and i not in locked_procs:
            locked_procs.add(i)
            lock_time[i] = t + 1
for t in lock_time:
    print(t)
```

### 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
3
def build(n, s, t):
    ans = 1
    for i in range(n):
        if s[i] == '?' and t[i] == '?':
            ans = 55 * ans % (10 ** 9 + 7)
        elif s[i] == '?':
            ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
        elif t[i] == '?':
            ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
    return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
    if t[i] == '?':
        qm += 1
    if s[i] == '?':
        qm += 1
    if t[i] == '?' and s[i] == '?':
        cqm += 1
    if t[i] == '?' and s[i] == '?':
        continue
    if ord(s[i]) < ord(t[i]):
        tlts = False
    if ord(t[i]) < ord(s[i]):
        sltt = False
if not sltt and (not tlts):
    print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
```

### 018

```python
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000004)
```

### 019

```python
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
    if numList[pos_r] > targetnumber:
        rem += 1
    else:
        rem -= 1
    if rem not in right:
        right[rem] = 1
    else:
        right[rem] += 1
    pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
    if numList[pos_l] > targetnumber:
        rem += 1
    else:
        rem *= 1
    if rem not in left:
        left[rem] = 1
    else:
        left[rem] += 1
    pos_l -= 1
sum = 0
for number_l in left:
    if number_l * -1 in right:
        sum += left[number_l] * right[-1 * number_l]
    if 1 - number_l in right:
        sum += left[number_l] * right[1 - number_l]
print(sum)
```

### 020

```python
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
    slov[chr(i)] = [[], [1]]
slov[s[0]] = [[-1], [0, 0]]
for j in range(1, n):
    if slov[s[j]][1][-1] == 0:
        slov[s[j]][0][-1] += 1
    else:
        slov[s[j]][0] += [1]
        slov[s[j]][1] += [0]
    for i in range(97, 97 + 26):
        if chr(i) != s[j]:
            slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
    m, c = ii().split()
    m = int(m)
    a, b = slov[c]
    if sum(b) <= m:
        print(n)
    elif not bool(a):
        print(m)
    elif len(a) == 1:
        print(a[0] + m)
    else:
        l, r = (0, 0)
        ans = 0
        summ_a, summ_b = (0, 0)
        used = 0
        b1 = b[:]
        b1[0], b1[-1] = (0, 0)
        count = 0
        while r != len(a):
            if summ_b + b1[r] <= m:
                summ_b += b1[r]
                summ_a += a[r]
                r += 1
                ans = max(ans, m + summ_a)
            else:
                summ_a -= a[l]
                l += 1
                summ_b -= b1[l]
        print(ans)
```

### 021

```python
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
    if i % 2:
        odds.append(l[i])
    else:
        evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
    if odds[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif odds[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(odds[a:b + 1])
    if not i > 0:
        if odds[i - 1] == odds[i] and odds[i] != -1:
            test = False
l = len(evens)
cont = False
for i in range(l):
    if evens[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif evens[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(evens[a:b + 1])
    if i > 0:
        if evens[i - 1] == evens[i] and evens[i] != -1:
            test = False
ans = 1
for seg in segs:
    l = len(seg) - 2
    dp = [[0, 0] for i in range(l)]
    a = seg[-1]
    b = seg[0]
    if b == 0:
        dp[0][0] = 1
        dp[0][1] = k - 1
    elif b == a:
        dp[0][0] = 0
        dp[0][1] = k - 1
    elif b != a:
        dp[0][0] = 1
        dp[0][1] = k - 2
    for i in range(1, l):
        dp[i][0] = dp[i - 1][1] % md
        dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
    if a == -10:
        ans *= dp[l - 1][0] + dp[l - 1][1]
    else:
        ans *= dp[l - 1][1]
    ans %= md
if test == False:
    print(0)
else:
    print(ans)
```

### 022

```python
base = 998244353
def power(x, y):
    if y == 0:
        return 1
    t = power(x, y // 2)
    t = t * t % base
    if y % 2:
        t = t * x % base
    return t
def inverse(x):
    return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
    ft.append(0)
def get(i):
    res = 0
    while i <= 200000:
        res += ft[i]
        i += i & -i
    return res
def update(i, x):
    while i:
        ft[i] += x
        i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
    non.append(0)
for i in range(1, n + 1):
    if a[i] != -1:
        non[a[i]] += 1
for i in range(1, n + 1):
    non[i] += non[i - 1]
for i in range(1, n + 1):
    if a[i] == -1:
        neg.append(neg[i - 1] + 1)
    else:
        neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
    if a[i] != -1:
        ans += get(a[i])
        update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1 - 1):
    fs = fm
    fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
    if a[i] != -1:
        less = a[i] - non[a[i]]
        more = m - less
        ans = (ans + neg[i] * more * fs) % base
        ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
```

### 023

```python
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
    cur = 0
    res = {cur: 1}
    for v in vs:
        cur += 1 if v > value else -4
        res[cur] = res.get(cur, 0) + 1
    return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
    res += count * rightCounts.get(-dif, 0)
    res += count * rightCounts.get(-dif + 1, 0)
print(res)
```

### 024

```python
def adds(memtoproc, mem, proc):
    if mem in memtoproc:
        memtoproc[mem].append(proc)
    else:
        memtoproc[mem] = [proc]
def corr(arr, n, m):
    brokemems = set()
    stopprocs = [0] * n
    for c in range(m):
        memtoproc = dict()
        usemems = set()
        locmems = set()
        for d in range(n):
            if not arr[d][c] or stopprocs[d]:
                continue
            adds(memtoproc, arr[d][c], d)
            if arr[d][c] in usemems:
                locmems.add(arr[d][c])
            usemems.add(arr[d][c])
            if arr[d][c] in brokemems:
                if not stopprocs[d]:
                    stopprocs[d] = c * 1
        for d in locmems:
            brokemems.add(d)
            procs = memtoproc[d]
            for x in procs:
                if not stopprocs[x]:
                    stopprocs[x] = c + 1
    return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
    arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
    print(c)
```

### 025

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

### 026

```python
import sys
from itertools import accumulate
def solve():
    n, m = map(int, input().split())
    w = [[] for i in range(3)]
    for i in range(n):
        wi, ci = map(int, sys.stdin.readline().split())
        wi -= 1
        w[wi].append(ci)
    for i in range(3):
        w[i].sort(reverse=True)
    dp = [0] * (m + 1)
    used = [[0] * 2 for i in range(m + 1)]
    s0 = len(w[0])
    s1 = len(w[1])
    if s0 > 0:
        dp[-1] = w[0][0]
        used[1] = [1, 0]
    for i in range(2, m + 1):
        if used[i - 1][0] < s0:
            dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
            used[i] = used[i - 1][:]
            used[i][0] += 1
        else:
            dp[i] = dp[i - 1]
            used[i] = used[i - 1][:]
        if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
            dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
            used[i] = used[i - 2][:]
            used[i][1] += 1
    pf = [0] + list(accumulate(w[2]))
    ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
    print(ans)
def __starting_point():
    solve()
__starting_point()
```

### 027

```python
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
    if L[i] > 0:
        D[L[i]] = i
        J.append(L[i])
        T[i + 1] = T[i]
    else:
        T[i + 1] = T[i] + 1
def I(J):
    if len(J) <= 1:
        return (J, 0)
    else:
        a = J[:len(J) // 2]
        b = J[len(J) // 2:]
        a, ai = I(a)
        b, bi = I(b)
        c = []
        i = 0
        j = 0
        inversions = ai + bi
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
            inversions += len(a) - i
    c += a[i:]
    c += b[j:]
    return (c, inversions)
for i in range(1, n + 1):
    if not i in D:
        S.append(i)
total = len(S)
num = 1
denom = 0
if total > 0:
    themostimportantsum = 0
    for i in J:
        low = 0
        high = total - 1
        while high - low > 1:
            guess = (high + low) // 2
            if S[guess] > i:
                high = guess
            else:
                low = guess
        if S[low] > i:
            smaller = low
        elif S[high] > i:
            smaller = high
        else:
            smaller = high + 1
        themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
        num = themostimportantsum + total
        denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
    if I(J)[1] == 0:
        print(0)
    else:
        print(I(J)[1] % 998244353)
else:
    num += denom * I(J)[1]
    print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
```

### 028

```python
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000008)
```

### 029

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
dp1 = [1, 0]
dp2 = [1, K - 1]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 030

```python
3
def build(n, s, t):
    ans = 1
    for i in range(n):
        if s[i] == '?' and t[i] == '?':
            ans = 55 * ans % (10 ** 9 + 7)
        elif s[i] == '?':
            ans = (ord(t[i]) - ord('0') + 1) * ans & 10 ** 9 + 7
        elif t[i] == '?':
            ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
    return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
    if t[i] == '?':
        qm += 1
    if s[i] == '?':
        qm += 1
    if t[i] == '?' and s[i] == '?':
        cqm += 1
    if t[i] == '?' or s[i] == '?':
        continue
    if ord(s[i]) < ord(t[i]):
        tlts = False
    if ord(t[i]) < ord(s[i]):
        sltt = False
if not sltt and (not tlts):
    print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
```

### 031

```python
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N - 1):
    A = int(input())
    for a in range(A):
        x, y = map(int, input().split())
        arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
    honest = set()
    unkind = set()
    h = set()
    for i in range(N):
        if bit & 1 << i:
            h.add(i)
            for x, y in arr[i]:
                if y:
                    honest.add(x)
                else:
                    unkind.add(x)
    if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
        ans = max(len(h), ans)
print(ans)
```

### 032

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

### 033

```python
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
    cur = 0
    res = {cur: 1}
    for v in vs:
        cur += 1 if v > value else -1
        res[cur] = res.get(cur, 0) + 1
    return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[3:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
    res += count * rightCounts.get(-dif, 0)
    res += count * rightCounts.get(-dif + 1, 0)
print(res)
```

### 034

```python
3
def build(n, s, t):
    ans = 1
    for i in range(n):
        if s[i] == '?' and t[i] == '?':
            ans = 55 * ans % (10 ** 9 + 7)
        elif s[i] == '?':
            ans = (ord(t[i]) - ord('0') + 1) * ans % (10 ** 9 + 7)
        elif t[i] == '?':
            ans = (ord('9') - ord(s[i]) + 1) * ans % (10 ** 9 + 7)
    return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
    if t[i] == '?':
        qm += 1
    if s[i] == '?':
        qm += 1
    if t[i] == '?' and s[i] == '?':
        cqm += 1
    if t[i] == '?' or s[i] == '?':
        continue
    if ord(s[i]) < ord(t[i]):
        tlts = False
    if ord(t[i]) < ord(s[i]):
        sltt = False
if not sltt and (not tlts):
    print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 * 7))
elif sltt:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
    print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
```

### 035

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

### 036

```python
n = int(input())
a = []
x = []
y = []
for i in range(n):
    ai = int(input())
    a.append(ai)
    xi = []
    yi = []
    for j in range(ai):
        xij, yij = list(map(int, input().split(' ')))
        xi.append(xij)
        yi.append(yij)
    x.append(xi)
    y.append(yi)
ans = 0
for case in range(2 ** n):
    truth_t = 0
    truth = 0
    for i in range(n):
        if case >> i & 1:
            truth_t += 1
            proof = 0
            for j in range(a[i]):
                if case >> x[i][j] - 1 & 1 == y[i][j]:
                    proof += 1
            if proof == a[i - 1]:
                truth += 1
    if truth == truth_t:
        if ans < truth:
            ans = truth
print(ans)
```

### 037

```python
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
    x, y = map(int, input().split())
    a[x - 1].append(y)
for i in range(3):
    a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(2, a_length[0] - 1, 2):
    a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
    a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
    data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
    data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
    data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
    if m - 3 * k < 0:
        break
    now1, now2 = (data_sum_three[k], data_sum_three[k])
    if (m - 3 * k) % 2 == 0:
        now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
        if a_length[0] > 0 and m - 3 * k > 0:
            now2 += a[0][0]
        if (m - 3 * k) // 2 >= 1:
            now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
    else:
        now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
        if a_length[0] > 0 and m - 3 * k > 0:
            now2 += a[0][0]
        now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
    ans = max(ans, now1, now2)
print(ans)
```

### 038

```python
def adds(memtoproc, mem, proc):
    if mem in memtoproc:
        memtoproc[mem].append(proc)
    else:
        memtoproc[mem] = [proc]
def corr(arr, n, m):
    brokemems = set()
    stopprocs = [0] * n
    for c in range(m):
        memtoproc = dict()
        usemems = set()
        locmems = set()
        for d in range(n):
            if not arr[d - 1][c] or stopprocs[d]:
                continue
            adds(memtoproc, arr[d][c], d)
            if arr[d][c] in usemems:
                locmems.add(arr[d][c])
            usemems.add(arr[d][c])
            if arr[d][c] in brokemems:
                if not stopprocs[d]:
                    stopprocs[d] = c + 1
        for d in locmems:
            brokemems.add(d)
            procs = memtoproc[d]
            for x in procs:
                if not stopprocs[x]:
                    stopprocs[x] = c + 1
    return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
    arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
    print(c)
```

### 039

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

### 040

```python
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
    d.append(d[-1][:])
    if a[q] != '?' and s[q] != '?':
        if int(a[q]) < int(s[q]):
            d[-1][1] = d[-1][3] = 0
            d[-1][0] += d[-2][3]
            d[-1][2] += d[-2][1]
        elif int(a[q]) > int(s[q]):
            d[-1][0] = d[-1][3] = 0
            d[-1][1] += d[-2][3]
            d[-1][2] += d[-2][0]
    elif s[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][0] *= int(s[q]) + 1
        d[-1][1] *= 10 - int(s[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
    elif a[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][1] *= int(a[q]) + 1
        d[-1][0] *= 10 - int(a[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
    else:
        d[-1][3] *= 10
        d[-1][2] *= 100
        d[-1][0] *= 55
        d[-1][1] *= 55
        d[-1][0] += d[-2][3] * 45
        d[-1][1] += d[-2][3] * 45
        d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
    d[-1][0] %= C
    d[-1][1] %= C
    d[-1 - 1][2] %= C
    d[-1][3] %= C
print(d[-1][2])
```

### 041

```python
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
    if L[i] > 0:
        D[L[i]] = i
        J.append(L[i])
        T[i + 1] = T[i]
    else:
        T[i + 1] = T[i] + 1
def I(J):
    if len(J) <= 1:
        return (J, 0)
    else:
        a = J[:len(J) // 2]
        b = J[len(J) // 2:]
        a, ai = I(a)
        b, bi = I(b)
        c = []
        i = 0
        j = 0
        inversions = ai + bi
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
            inversions += len(a) - i
    c += a[i:]
    c += b[j:]
    return (c, inversions)
for i in range(1, n + 1 - 1):
    if not i in D:
        S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
    themostimportantsum = 0
    for i in J:
        low = 0
        high = total - 1
        while high - low > 1:
            guess = (high + low) // 2
            if S[guess] > i:
                high = guess
            else:
                low = guess
        if S[low] > i:
            smaller = low
        elif S[high] > i:
            smaller = high
        else:
            smaller = high + 1
        themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
        num = themostimportantsum + total
        denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
    if I(J)[1] == 0:
        print(0)
    else:
        print(I(J)[1] % 998244353)
else:
    num += denom * I(J)[1]
    print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
```

### 042

```python
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
    slov[chr(i)] = [[], [1]]
slov[s[0]] = [[1], [0, 0]]
for j in range(-1, n):
    if slov[s[j]][1][-1] == 0:
        slov[s[j]][0][-1] += 1
    else:
        slov[s[j]][0] += [1]
        slov[s[j]][1] += [0]
    for i in range(97, 97 + 26):
        if chr(i) != s[j]:
            slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
    m, c = ii().split()
    m = int(m)
    a, b = slov[c]
    if sum(b) <= m:
        print(n)
    elif not bool(a):
        print(m)
    elif len(a) == 1:
        print(a[0] + m)
    else:
        l, r = (0, 0)
        ans = 0
        summ_a, summ_b = (0, 0)
        used = 0
        b1 = b[:]
        b1[0], b1[-1] = (0, 0)
        count = 0
        while r != len(a):
            if summ_b + b1[r] <= m:
                summ_b += b1[r]
                summ_a += a[r]
                r += 1
                ans = max(ans, m + summ_a)
            else:
                summ_a -= a[l]
                l += 1
                summ_b -= b1[l]
        print(ans)
```

### 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
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
    s, g = smaller_greater[-1]
    if k < m:
        smaller_greater.append((s + 1, g))
    elif k > m:
        smaller_greater.append((s, g + 1))
    else:
        smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
    s, g = pack
    s -= s_median
    g -= g_median
    if s - g in difference:
        difference[s - g] += 1
    else:
        difference[s - g] = 1
count = 0
for start in range(i + 1):
    s, g = smaller_greater[start]
    s *= s_median
    g -= g_median
    if s - g in difference.keys():
        count += difference[s - g]
    if s - g - 1 in difference.keys():
        count += difference[s - g - 1]
print(count)
```

### 045

```python
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
    S[i] = int(S[i])
ind = 0
for k in range(n):
    if S[k] == m:
        ind = k
k = ind
P = [0] * (n + 1)
N = [2] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
    if S[k - 1 - i] < m:
        L[k - 1 - i] = L[k - i] - 1
    else:
        L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
    if S[k + 1 + i] > m:
        R[1 + i] = R[i] + 1
    else:
        R[1 + i] = R[i] - 1
c = 0
for el in R:
    if el >= 0:
        P[el] += 1
        if el == 0:
            N[el] += 1
    else:
        N[-el] += 1
for el in L:
    if el >= 1:
        c = c + N[el] + N[el - 1]
    else:
        c = c + P[-el] + P[-el + 1]
print(c)
```

### 046

```python
__author__ = 'Lipen'
def main():
    n, m, k = map(int, input().split())
    data = []
    when = [0] * n
    blockedcells = set()
    blockedcores = set()
    for _ in range(n):
        data.append(list(map(int, input().split())))
    for j in range(m):
        operation = []
        for _ in range(k):
            operation.append([])
        for i in range(n):
            if i not in blockedcores:
                x = data[i][j] - 1
                if x >= 0:
                    if x in blockedcells:
                        blockedcores.add(i)
                        when[i] = j + 1
                    elif len(operation[x]) > 0:
                        blockedcells.add(x)
                        for core in operation[x - 1]:
                            blockedcores.add(core)
                            when[core] = j + 1
                        blockedcores.add(i)
                        when[i] = j + 1
                    operation[x].append(i)
    for i in when:
        print(i)
main()
```

### 047

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

### 048

```python
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = (sys.stdout, sys.stdin)
        sys.stdout, sys.stdin = (StringIO(), StringIO(input))
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = (stdout, stdin)
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
        output = '2'
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
        output = '0'
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = '2\n1\n2 0\n1\n1 0'
        output = '1'
        self.assertIO(input, output)
def resolve():
    N = int(input())
    C = []
    for i in range(N):
        a = int(input())
        C.append([list(map(int, input().split())) for j in range(a)])
    ans = 2
    for bit in range(1 << N):
        f = True
        for i in range(N):
            if bit & 1 << i:
                for c in C[i]:
                    if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
                        f = False
                        break
        if f == True:
            ans = max(ans, bin(bit).count('1'))
    print(ans)
def __starting_point():
    resolve()
__starting_point()
```

### 049

```python
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
    cur = 0
    res = {cur: 1}
    for v in vs:
        cur += 1 if v > value else -2
        res[cur] = res.get(cur, 0) + 1
    return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
    res += count * rightCounts.get(-dif, 0)
    res += count * rightCounts.get(-dif + 1, 0)
print(res)
```

### 050

```python
n = int(input())
C = 10 ** 8 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
    d.append(d[-1][:])
    if a[q] != '?' and s[q] != '?':
        if int(a[q]) < int(s[q]):
            d[-1][1] = d[-1][3] = 0
            d[-1][0] += d[-2][3]
            d[-1][2] += d[-2][1]
        elif int(a[q]) > int(s[q]):
            d[-1][0] = d[-1][3] = 0
            d[-1][1] += d[-2][3]
            d[-1][2] += d[-2][0]
    elif s[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][0] *= int(s[q]) + 1
        d[-1][1] *= 10 - int(s[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
    elif a[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][1] *= int(a[q]) + 1
        d[-1][0] *= 10 - int(a[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
    else:
        d[-1][3] *= 10
        d[-1][2] *= 100
        d[-1][0] *= 55
        d[-1][1] *= 55
        d[-1][0] += d[-2][3] * 45
        d[-1][1] += d[-2][3] * 45
        d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
    d[-1][0] %= C
    d[-1][1] %= C
    d[-1][2] %= C
    d[-1][3] %= C
print(d[-1][2])
```

### 051

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
    table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
    cnt = [0] * (k + 1)
    for i, c in enumerate(ys):
        if i not in locked_procs:
            cnt[c] += 1
    for c, cn in enumerate(cnt):
        if c > 1 and cn > 1:
            locked_cells.add(c)
    for i, c in enumerate(ys):
        if c in locked_cells and i not in locked_procs:
            locked_procs.add(i)
            lock_time[i] = t + 1
for t in lock_time:
    print(t)
```

### 052

```python
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
    d.append(d[-1][:])
    if a[q] != '?' and s[q] != '?':
        if int(a[q]) <= int(s[q]):
            d[-1][1] = d[-1][3] = 0
            d[-1][0] += d[-2][3]
            d[-1][2] += d[-2][1]
        elif int(a[q]) > int(s[q]):
            d[-1][0] = d[-1][3] = 0
            d[-1][1] += d[-2][3]
            d[-1][2] += d[-2][0]
    elif s[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][0] *= int(s[q]) + 1
        d[-1][1] *= 10 - int(s[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
    elif a[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][1] *= int(a[q]) + 1
        d[-1][0] *= 10 - int(a[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
    else:
        d[-1][3] *= 10
        d[-1][2] *= 100
        d[-1][0] *= 55
        d[-1][1] *= 55
        d[-1][0] += d[-2][3] * 45
        d[-1][1] += d[-2][3] * 45
        d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
    d[-1][0] %= C
    d[-1][1] %= C
    d[-1][2] %= C
    d[-1][3] %= C
print(d[-1][2])
```

### 053

```python
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
    S[i] = int(S[i])
ind = 0
for k in range(n):
    if S[k] == m:
        ind = k
k = ind
P = [0] * (n + 1)
N = [4] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
    if S[k - 1 - i] < m:
        L[k - 1 - i] = L[k - i] - 1
    else:
        L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
    if S[k + 1 + i] > m:
        R[1 + i] = R[i] + 1
    else:
        R[1 + i] = R[i] - 1
c = 0
for el in R:
    if el >= 0:
        P[el] += 1
        if el == 0:
            N[el] += 1
    else:
        N[-el] += 1
for el in L:
    if el >= 1:
        c = c + N[el] + N[el - 1]
    else:
        c = c + P[-el] + P[-el + 1]
print(c)
```

### 054

```python
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000003)
```

### 055

```python
def f():
    n, m = list(map(int, input().split()))
    l = list((tuple(map(int, input().split())) for _ in range(n)))
    l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
    last, r = ([0] * 4, 0)
    for i, (w, c) in enumerate(l):
        if m < w:
            break
        m -= w
        r += c
        last[w] = c
    else:
        return r
    if not m:
        return r
    res, tail = ([r], (None, [], [], []))
    for w, c in l[i:]:
        tail[w].append(c)
    for w in (1, 2, 3):
        tail[w].append(0)
    _, t1, t2, t3 = tail
    if m == 1:
        res.append(r + t1[0])
        if last[1]:
            res.append(r - last[1] + t2[0])
        if last[2]:
            res.append(r - last[2] + t3[0])
        if last[3]:
            r -= last[3]
            res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
    else:
        res += (r + sum(t1[:2]), r + t2[0])
        if last[-1]:
            res.append(r - last[1] + t3[0])
        if last[2]:
            res.append(r - last[2] + t3[0] + t1[0])
    return max(res)
def main():
    print(f())
def __starting_point():
    main()
__starting_point()
```

### 056

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

### 057

```python
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
    if numList[pos_r] > targetnumber:
        rem += 1
    else:
        rem -= 1
    if rem not in right:
        right[rem] = 1
    else:
        right[rem] += 1
    pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
    if numList[pos_l] > targetnumber:
        rem += 1
    else:
        rem += 1
    if rem not in left:
        left[rem] = 1
    else:
        left[rem] += 1
    pos_l -= 1
sum = 0
for number_l in left:
    if number_l * -1 in right:
        sum += left[number_l] * right[-1 * number_l]
    if 1 - number_l in right:
        sum += left[number_l] * right[1 - number_l]
print(sum)
```

### 058

```python
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
    for i in range(beg, n, 2):
        if a[i] == -1:
            if lt is None:
                lt = -1 if i - 2 < 0 else a[i - 2]
                sz = 0
            sz += 1
            if i + 2 >= n:
                ch.append((lt, -1, sz))
                lt = None
            elif a[i + 2] != -1:
                ch.append((lt, a[i + 2], sz))
                lt = None
ans = int(all((a[i - 1] != a[i + 2] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
    if sz == 1:
        cur = k if lt == -1 and rt == -1 else k - 1 if lt == -1 or rt == -1 or lt == rt else k - 2
    else:
        eq, neq = (1 if lt == -1 else 0, 1)
        for _ in range(sz - 1):
            eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
        cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
    ans = ans * cur % MOD
print(ans)
```

### 059

```python
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
    x, y = map(int, input().split())
    a[x - 1].append(y)
for i in range(3):
    a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 1):
    a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
    a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
    data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
    data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
    data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
    if m - 3 * k < 0:
        break
    now1, now2 = (data_sum_three[k], data_sum_three[k])
    if (m - 3 * k) % 2 == 0:
        now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
        if a_length[0] > 0 and m - 3 * k > 0:
            now2 += a[0][0]
        if (m - 3 * k) // 2 >= 1:
            now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
    else:
        now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
        if a_length[0] > 0 and m - 3 * k > 0:
            now2 += a[0][0]
        now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
    ans = max(ans, now1, now2)
print(ans)
```

### 060

```python
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
    for j in range(n):
        tst = 1 if s[j] == chr(c + 97) else 0
        dp[c][1 * tst] = max(dp[c][1 - tst], 1)
        for k in range(j + 1, n):
            if s[k] == chr(c + 97):
                tst += 1
            dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
    m, c = [item for item in sys.stdin.readline().strip().split()]
    m = int(m)
    print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
```

### 061

```python
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
    if i % 2:
        odds.append(l[i])
    else:
        evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
    if odds[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif odds[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(odds[a:b + 1])
    if i > 0:
        if odds[i - 1] == odds[i] and odds[i] != -1:
            test = False
l = len(evens)
cont = False
for i in range(l):
    if evens[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif evens[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(evens[a:b + 1])
    if i > 0:
        if evens[i - 1] == evens[i] and evens[i] != -1:
            test = False
ans = 1
for seg in segs:
    l = len(seg) - 2
    dp = [[0, 0] for i in range(l)]
    a = seg[-1]
    b = seg[0]
    if b == 0:
        dp[0][0] = 1
        dp[0][1] = k - 1
    elif b == a:
        dp[0][0] = 0
        dp[0][1] = k - 1
    elif b != a:
        dp[0][0] = 1
        dp[0][1] = k - 2
    for i in reversed(range(1, l)):
        dp[i][0] = dp[i - 1][1] % md
        dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
    if a == -10:
        ans *= dp[l - 1][0] + dp[l - 1][1]
    else:
        ans *= dp[l - 1][1]
    ans %= md
if test == False:
    print(0)
else:
    print(ans)
```

### 062

```python
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
    x, y = map(int, input().split())
    a[x - 1].append(y)
for i in range(3):
    a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
    a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
    a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
    data_sum_even.append(data_sum_even[-1] - x)
data_sum_odd = [0]
for x in data_odd:
    data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
    data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
    if m - 3 * k < 0:
        break
    now1, now2 = (data_sum_three[k], data_sum_three[k])
    if (m - 3 * k) % 2 == 0:
        now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
        if a_length[0] > 0 and m - 3 * k > 0:
            now2 += a[0][0]
        if (m - 3 * k) // 2 >= 1:
            now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
    else:
        now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
        if a_length[0] > 0 and m - 3 * k > 0:
            now2 += a[0][0]
        now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
    ans = max(ans, now1, now2)
print(ans)
```

### 063

```python
N = int(input())
A = []
for _ in range(N):
    a = int(input())
    b = []
    for _ in range(a):
        b.append(list(map(int, input().split())))
    A.append(b)
def F(i):
    cnt = 0
    B = [-1] * N
    r = 0
    for j in range(N):
        if i >> j & 1:
            r += 1
            if B[j] == 0:
                return 0
            B[j] = 1
            for p, q in A[j]:
                if q == 0:
                    if B[p - 1] == 1:
                        return 0
                    B[p - 1] = 0
                else:
                    if B[p - 1] == 0:
                        return 0
                    B[p - 1] = 1
            else:
                cnt += 1
        else:
            if B[j] == 0:
                return 0
            B[j] = 0
    if cnt == r:
        return cnt
ans = 0
for i in range(1 << N):
    ans = max(ans, F(i))
print(ans)
```

### 064

```python
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
    s, g = smaller_greater[-1]
    if k < m:
        smaller_greater.append((s + 1, g))
    elif k > m:
        smaller_greater.append((s, g + 1))
    else:
        smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
    s, g = pack
    s -= s_median
    g -= g_median
    if s + g in difference:
        difference[s - g] += 1
    else:
        difference[s - g] = 1
count = 0
for start in range(i + 1):
    s, g = smaller_greater[start]
    s -= s_median
    g -= g_median
    if s - g in difference.keys():
        count += difference[s - g]
    if s - g - 1 in difference.keys():
        count += difference[s - g - 1]
print(count)
```

### 065

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
    table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
    cnt = [0] * (k + 1)
    for i, c in enumerate(ys):
        if i not in locked_procs:
            cnt[c] += 1
    for c, cn in enumerate(cnt):
        if c >= 0 and cn > 1:
            locked_cells.add(c)
    for i, c in enumerate(ys):
        if c in locked_cells and i not in locked_procs:
            locked_procs.add(i)
            lock_time[i] = t + 1
for t in lock_time:
    print(t)
```

### 066

```python
n = int(input())
a = []
x = []
y = []
for i in range(n):
    ai = int(input())
    a.append(ai)
    xi = []
    yi = []
    for j in range(ai):
        xij, yij = list(map(int, input().split(' ')))
        xi.append(xij)
        yi.append(yij)
    x.append(xi)
    y.append(yi)
ans = 0
for case in range(2 ** n):
    truth_t = 0
    truth = 0
    for i in range(n):
        if case >> i & 1:
            truth_t += 1
            proof = 0
            for j in range(a[i]):
                if case >> x[i][j - 1] - 1 & 1 == y[i][j]:
                    proof += 1
            if proof == a[i]:
                truth += 1
    if truth == truth_t:
        if ans < truth:
            ans = truth
print(ans)
```

### 067

```python
import sys
from itertools import accumulate
def solve():
    n, m = map(int, input().split())
    w = [[] for i in range(3)]
    for i in range(n):
        wi, ci = map(int, sys.stdin.readline().split())
        wi -= 1
        w[wi].append(ci)
    for i in range(3):
        w[i].sort(reverse=True)
    dp = [0] * (m + 1)
    used = [[0] * 2 for i in range(m + 1)]
    s0 = len(w[0])
    s1 = len(w[1])
    if s0 > 0:
        dp[1] = w[0][0]
        used[1] = [1, 0]
    for i in range(2, m + 1 - 1):
        if used[i - 1][0] < s0:
            dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
            used[i] = used[i - 1][:]
            used[i][0] += 1
        else:
            dp[i] = dp[i - 1]
            used[i] = used[i - 1][:]
        if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
            dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
            used[i] = used[i - 2][:]
            used[i][1] += 1
    pf = [0] + list(accumulate(w[2]))
    ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
    print(ans)
def __starting_point():
    solve()
__starting_point()
```

### 068

```python
N = int(input())
A = []
for _ in range(N):
    a = int(input())
    b = []
    for _ in range(a):
        b.append(list(map(int, input().split())))
    A.append(b)
def F(i):
    cnt = 0
    B = [-1] * N
    r = 0
    for j in range(N):
        if i >> j & 1:
            r += 1
            if B[j] == 0:
                return 0
            B[j] = 0
            for p, q in A[j]:
                if q == 0:
                    if B[p - 1] == 1:
                        return 0
                    B[p - 1] = 0
                else:
                    if B[p - 1] == 0:
                        return 0
                    B[p - 1] = 1
            else:
                cnt += 1
        else:
            if B[j] == 1:
                return 0
            B[j] = 0
    if cnt == r:
        return cnt
ans = 0
for i in range(1 << N):
    ans = max(ans, F(i))
print(ans)
```

### 069

```python
def souvenier_calc(max_weight, weights, value):
    const = len(weights)
    ans = [-1061109567 for x in range(max_weight + 1)]
    node = [(x, y) for x, y in zip(weights, value)]
    node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
    weights = [x[0] for x in node]
    value = [x[1] for x in node]
    sum = 0
    sol = 0
    ans[0] = 0
    for i in range(const):
        sum += weights[i]
        if sum > max_weight:
            sum = max_weight
        down = max(weights[i], sum - 2)
        for weight in range(sum, down - 1, -1):
            ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
            sol = max(sol, ans[weight])
    return sol
def __starting_point():
    N, M = list(map(int, input().split()))
    assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
    weights = []
    value = []
    for i in range(N):
        x, y = list(map(int, input().split()))
        assert x >= 1 and x <= 3, 'Out of range'
        assert y >= 1 and y <= 10 ** 9, 'Out of range'
        weights.append(x)
        value.append(y)
    print(souvenier_calc(M, weights, value))
__starting_point()
```

### 070

```python
def f():
    n, m = list(map(int, input().split()))
    l = list((tuple(map(int, input().split())) for _ in range(n)))
    l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
    last, r = ([0] * 4, 0)
    for i, (w, c) in enumerate(l):
        if m <= w:
            break
        m -= w
        r += c
        last[w] = c
    else:
        return r
    if not m:
        return r
    res, tail = ([r], (None, [], [], []))
    for w, c in l[i:]:
        tail[w].append(c)
    for w in (1, 2, 3):
        tail[w].append(0)
    _, t1, t2, t3 = tail
    if m == 1:
        res.append(r + t1[0])
        if last[1]:
            res.append(r - last[1] + t2[0])
        if last[2]:
            res.append(r - last[2] + t3[0])
        if last[3]:
            r -= last[3]
            res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
    else:
        res += (r + sum(t1[:2]), r + t2[0])
        if last[1]:
            res.append(r - last[1] + t3[0])
        if last[2]:
            res.append(r - last[2] + t3[0] + t1[0])
    return max(res)
def main():
    print(f())
def __starting_point():
    main()
__starting_point()
```

### 071

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

### 072

```python
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26):
    for l in range(N):
        x = 0
        for r in range(l + 1, N + 1):
            x += S[r - 1] != c
            res[c][x] = max(res[c][x], r - l)
    for i in range(N - 1):
        res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
    x, s = input().split()
    x = int(x)
    s = ord(s) - ord('a')
    print(res[s][x])
```

### 073

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

### 074

```python
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
    if i % 2:
        odds.append(l[i])
    else:
        evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
    if odds[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif odds[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(odds[a:b + 1])
    if i > 0:
        if odds[i - 1] == odds[i] and odds[i] != -1:
            test = False
l = len(evens)
cont = False
for i in range(l):
    if evens[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif evens[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(evens[a:b + 1])
    if i > 0:
        if evens[i - 1] == evens[i] and evens[i] != -1:
            test = False
ans = 1
for seg in segs:
    l = len(seg) - 2
    dp = [[0, 0] for i in range(l)]
    a = seg[-1]
    b = seg[0]
    if b == 0:
        dp[0][0] = -3
        dp[0][1] = k - 1
    elif b == a:
        dp[0][0] = 0
        dp[0][1] = k - 1
    elif b != a:
        dp[0][0] = 1
        dp[0][1] = k - 2
    for i in range(1, l):
        dp[i][0] = dp[i - 1][1] % md
        dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
    if a == -10:
        ans *= dp[l - 1][0] + dp[l - 1][1]
    else:
        ans *= dp[l - 1][1]
    ans %= md
if test == False:
    print(0)
else:
    print(ans)
```

### 075

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

### 076

```python
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
    if a[i] == '?' and b[i] == '?':
        x = x * 55 % mod
        y = y * 55 % mod
        z = z * 10 % mod
    elif a[i] == '?':
        x = x * (10 - int(b[i])) % mod
        y = y * (int(b[i]) + 1) % mod
    elif b[i] == '?':
        x = x * (int(a[i]) + 1) // mod
        y = y * (10 - int(a[i])) % mod
    else:
        if int(a[i]) < int(b[i]):
            x = 0
        if int(a[i]) > int(b[i]):
            y = 0
        if a[i] != b[i]:
            z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
```

### 077

```python
def souvenier_calc(max_weight, weights, value):
    const = len(weights)
    ans = [-1061109567 for x in range(max_weight + 1)]
    node = [(x, y) for x, y in zip(weights, value)]
    node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
    weights = [x[0] for x in node]
    value = [x[1] for x in node]
    sum = 0
    sol = 0
    ans[0] = 0
    for i in range(const):
        sum += weights[i]
        if sum > max_weight:
            sum = max_weight
        down = max(weights[i], sum - 3)
        for weight in reversed(range(sum, down - 1, -1)):
            ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
            sol = max(sol, ans[weight])
    return sol
def __starting_point():
    N, M = list(map(int, input().split()))
    assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
    weights = []
    value = []
    for i in range(N):
        x, y = list(map(int, input().split()))
        assert x >= 1 and x <= 3, 'Out of range'
        assert y >= 1 and y <= 10 ** 9, 'Out of range'
        weights.append(x)
        value.append(y)
    print(souvenier_calc(M, weights, value))
__starting_point()
```

### 078

```python
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
    for j in range(n):
        tst = 1 if s[j] == chr(c + 97) else 0
        dp[c][1 - tst] = max(dp[c][1 - tst], 1)
        for k in range(j + 1, n):
            if s[k] == chr(c + 97):
                tst += 1
            dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
    m, c = [item for item in sys.stdin.readline().strip().split()]
    m = int(m)
    print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m - 1] != -1 else print(n)
```

### 079

```python
n = int(input())
C = 10 ** 9 + 6
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
    d.append(d[-1][:])
    if a[q] != '?' and s[q] != '?':
        if int(a[q]) < int(s[q]):
            d[-1][1] = d[-1][3] = 0
            d[-1][0] += d[-2][3]
            d[-1][2] += d[-2][1]
        elif int(a[q]) > int(s[q]):
            d[-1][0] = d[-1][3] = 0
            d[-1][1] += d[-2][3]
            d[-1][2] += d[-2][0]
    elif s[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][0] *= int(s[q]) + 1
        d[-1][1] *= 10 - int(s[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
    elif a[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][1] *= int(a[q]) + 1
        d[-1][0] *= 10 - int(a[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
    else:
        d[-1][3] *= 10
        d[-1][2] *= 100
        d[-1][0] *= 55
        d[-1][1] *= 55
        d[-1][0] += d[-2][3] * 45
        d[-1][1] += d[-2][3] * 45
        d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
    d[-1][0] %= C
    d[-1][1] %= C
    d[-1][2] %= C
    d[-1][3] %= C
print(d[-1][2])
```

### 080

```python
def souvenier_calc(max_weight, weights, value):
    const = len(weights)
    ans = [-1061109567 for x in range(max_weight + 1)]
    node = [(x, y) for x, y in zip(weights, value)]
    node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
    weights = [x[0] for x in node]
    value = [x[1] for x in node]
    sum = 0
    sol = 0
    ans[0] = 0
    for i in range(const):
        sum += weights[i - 1]
        if sum > max_weight:
            sum = max_weight
        down = max(weights[i], sum - 3)
        for weight in range(sum, down - 1, -1):
            ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
            sol = max(sol, ans[weight])
    return sol
def __starting_point():
    N, M = list(map(int, input().split()))
    assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
    weights = []
    value = []
    for i in range(N):
        x, y = list(map(int, input().split()))
        assert x >= 1 and x <= 3, 'Out of range'
        assert y >= 1 and y <= 10 ** 9, 'Out of range'
        weights.append(x)
        value.append(y)
    print(souvenier_calc(M, weights, value))
__starting_point()
```

### 081

```python
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
    a[i] = list(map(int, input().split()))
for i in range(m):
    for j in range(5, n + 1):
        if stat[j]:
            current_core = inf[a[j - 1][i]]
            if current_core == 0 and a[j - 1][i] != 0:
                inf[a[j - 1][i]] = j
            elif current_core == -1:
                stat[j], time[j] = (False, i + 1)
            elif a[j - 1][i] != 0:
                stat[current_core], time[current_core] = (False, i + 1)
                stat[j], time[j] = (False, i + 1)
                inf[a[j - 1][i]] = -1
    for p in range(len(inf)):
        if inf[p] != -1:
            inf[p] = 0
for i in range(1, n + 1):
    print(time[i])
```

### 082

```python
def merge(a, b):
    inda = 0
    indb = 0
    lena = len(a)
    lenb = len(b)
    d = [a[-1] + b[-1] + 1000]
    a += d
    b += d
    c = []
    inversions = 0
    for i in range(lena + lenb):
        if a[inda] < b[indb]:
            c.append(a[inda])
            inda += 1
        else:
            c.append(b[indb])
            indb += 1
            inversions += lena - inda
    return (c, inversions)
def mergesort(a):
    if len(a) <= 1:
        return (a, 0)
    split = len(a) // 2
    b = a[:split]
    c = a[split:]
    d = mergesort(b)
    e = mergesort(c)
    f = merge(d[0], e[0])
    return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
    if guy != -1:
        b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
    if guy != -1:
        used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
    unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
    if a[i] == -1:
        negsseen += 1
    else:
        mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix // 2
denom = 2 * negs
if negs == 0:
    print(invs % 998244353)
else:
    for i in range(denom):
        if (998244353 * i + 1) % denom == 0:
            inv = (998244353 * i + 1) // denom
            break
    print(num * inv % 998244353)
```

### 083

```python
class PalArray:
    P = 998244355
    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None
    def fast_pow(self, a, b):
        r = 1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r
    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - 2
        self.dp[1][1] = self.k - 1
        for i in range(2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P
    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True
    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res
    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 084

```python
__author__ = 'Lipen'
def main():
    n, m, k = map(int, input().split())
    data = []
    when = [0] * n
    blockedcells = set()
    blockedcores = set()
    for _ in range(n):
        data.append(list(map(int, input().split())))
    for j in range(m):
        operation = []
        for _ in range(k):
            operation.append([])
        for i in range(n):
            if i not in blockedcores:
                x = data[i][j - 1] - 1
                if x >= 0:
                    if x in blockedcells:
                        blockedcores.add(i)
                        when[i] = j + 1
                    elif len(operation[x]) > 0:
                        blockedcells.add(x)
                        for core in operation[x]:
                            blockedcores.add(core)
                            when[core] = j + 1
                        blockedcores.add(i)
                        when[i] = j + 1
                    operation[x].append(i)
    for i in when:
        print(i)
main()
```

### 085

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

### 086

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

### 087

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244350
dp1 = [1, 0]
dp2 = [1, K - 1]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 088

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

### 089

```python
K = 998244353
def mu(a, n):
    if n == 0:
        return 1
    q = mu(a, n // 2)
    if n % 2 == 0:
        return q * q % K
    return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [-4 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
    i = u
    while i <= 200000:
        fen[i] += v
        i += i & -i
def get(u):
    res = 0
    i = u
    while i > 0:
        res += fen[i]
        i -= i & -i
    return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
    p[i] = int(data[i - 1])
    if p[i] > 0:
        dd[p[i]] = 1
    else:
        cnt += 1
for i in range(1, n + 1):
    if dd[i] == 0:
        s[i] = s[i - 1] + 1
    else:
        s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
    if p[i] == -1:
        cnt1 += 1
    else:
        u = cnt - cnt1
        P = (P + u * s[p[i]] % K * den % K) % K
        P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
    if p[i] > 0:
        m += 1
        a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
    P1 = (P1 + get(a[i])) % K
    add(a[i], 1)
P = (P + P1) % K
print(P)
```

### 090

```python
class PalArray:
    P = 998244353
    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None
    def fast_pow(self, a, b):
        r = 1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r
    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - -2
        self.dp[1][1] = self.k - 1
        for i in range(2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P
    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True
    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res
    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 091

```python
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
    if i % 2:
        odds.append(l[i])
    else:
        evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
    if odds[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif odds[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(odds[a:b + 1])
    if i > 0:
        if odds[i - 1] == odds[i] and odds[i] != -1:
            test = False
l = len(evens)
cont = False
for i in range(l):
    if evens[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif evens[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(evens[a:b + 1])
    if i > 0:
        if evens[i - 1] == evens[i] and evens[i] != -1:
            test = False
ans = 1
for seg in segs:
    l = len(seg) - 2
    dp = [[0, 0] for i in range(l)]
    a = seg[-1]
    b = seg[-3]
    if b == 0:
        dp[0][0] = 1
        dp[0][1] = k - 1
    elif b == a:
        dp[0][0] = 0
        dp[0][1] = k - 1
    elif b != a:
        dp[0][0] = 1
        dp[0][1] = k - 2
    for i in range(1, l):
        dp[i][0] = dp[i - 1][1] % md
        dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
    if a == -10:
        ans *= dp[l - 1][0] + dp[l - 1][1]
    else:
        ans *= dp[l - 1][1]
    ans %= md
if test == False:
    print(0)
else:
    print(ans)
```

### 092

```python
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
    a[i] = list(map(int, input().split()))
for i in range(m):
    for j in range(4, n + 1):
        if stat[j]:
            current_core = inf[a[j - 1][i]]
            if current_core == 0 and a[j - 1][i] != 0:
                inf[a[j - 1][i]] = j
            elif current_core == -1:
                stat[j], time[j] = (False, i + 1)
            elif a[j - 1][i] != 0:
                stat[current_core], time[current_core] = (False, i + 1)
                stat[j], time[j] = (False, i + 1)
                inf[a[j - 1][i]] = -1
    for p in range(len(inf)):
        if inf[p] != -1:
            inf[p] = 0
for i in range(1, n + 1):
    print(time[i])
```

### 093

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
    table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
    cnt = [0] * (k + 1)
    for i, c in enumerate(ys):
        if i not in locked_procs:
            cnt[c] += -1
    for c, cn in enumerate(cnt):
        if c > 0 and cn > 1:
            locked_cells.add(c)
    for i, c in enumerate(ys):
        if c in locked_cells and i not in locked_procs:
            locked_procs.add(i)
            lock_time[i] = t + 1
for t in lock_time:
    print(t)
```

### 094

```python
__author__ = 'Lipen'
def main():
    n, m, k = map(int, input().split())
    data = []
    when = [0] * n
    blockedcells = set()
    blockedcores = set()
    for _ in range(n):
        data.append(list(map(int, input().split())))
    for j in range(m):
        operation = []
        for _ in range(k):
            operation.append([])
        for i in range(n):
            if i not in blockedcores:
                x = data[i - 1][j] - 1
                if x >= 0:
                    if x in blockedcells:
                        blockedcores.add(i)
                        when[i] = j + 1
                    elif len(operation[x]) > 0:
                        blockedcells.add(x)
                        for core in operation[x]:
                            blockedcores.add(core)
                            when[core] = j + 1
                        blockedcores.add(i)
                        when[i] = j + 1
                    operation[x].append(i)
    for i in when:
        print(i)
main()
```

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

### 096

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
dp1 = [1, 0]
dp2 = [1, K - 0]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 097

```python
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
    if numList[pos_r] > targetnumber:
        rem += 1
    else:
        rem *= 1
    if rem not in right:
        right[rem] = 1
    else:
        right[rem] += 1
    pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
    if numList[pos_l] > targetnumber:
        rem += 1
    else:
        rem -= 1
    if rem not in left:
        left[rem] = 1
    else:
        left[rem] += 1
    pos_l -= 1
sum = 0
for number_l in left:
    if number_l * -1 in right:
        sum += left[number_l] * right[-1 * number_l]
    if 1 - number_l in right:
        sum += left[number_l] * right[1 - number_l]
print(sum)
```

### 098

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

### 099

```python
import string
import bisect
import sys
def main():
    lines = sys.stdin.readlines()
    n = int(lines[0])
    s = lines[1]
    vals = {}
    for c in string.ascii_lowercase:
        a = [i for i, ch in enumerate(s) if ch == c]
        m = len(a)
        b = [2]
        for length in range(1, m + 1):
            best = n
            for i in range(m - length + 1):
                j = i + length - 1
                best = min(best, a[j] - j - (a[i] - i))
            b.append(best)
        vals[c] = b
    q = int(lines[2])
    r = []
    idx = 3
    while q > 0:
        q -= 1
        query = lines[idx].split()
        idx += 1
        m = int(query[0])
        c = query[1]
        i = bisect.bisect_right(vals[c], m)
        r.append(str(min(n, i + m - 1)))
    print('\n'.join(r))
main()
```

### 100

```python
base = 998244353
def power(x, y):
    if y == 0:
        return 1
    t = power(x, y // 2)
    t = t * t % base
    if y % 2:
        t = t * x % base
    return t
def inverse(x):
    return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
    ft.append(0)
def get(i):
    res = 0
    while i <= 200000:
        res += ft[i]
        i += i & -i
    return res
def update(i, x):
    while i:
        ft[i] += x
        i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
    non.append(0)
for i in range(1, n + 1):
    if a[i] != -1:
        non[a[i]] += 1
for i in range(1, n + 1):
    non[i] += non[i - 1]
for i in range(1, n + 1):
    if a[i] == -1:
        neg.append(neg[i - 1] + 1)
    else:
        neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
    if a[i] != -1:
        ans += get(a[i])
        update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
    fs = fm
    fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1 - 1):
    if a[i] != -1:
        less = a[i] - non[a[i]]
        more = m - less
        ans = (ans + neg[i] * more * fs) % base
        ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
```

### 101

```python
__author__ = 'Lipen'
def main():
    n, m, k = map(int, input().split())
    data = []
    when = [0] * n
    blockedcells = set()
    blockedcores = set()
    for _ in range(n):
        data.append(list(map(int, input().split())))
    for j in range(m):
        operation = []
        for _ in range(k):
            operation.append([])
        for i in range(n):
            if i not in blockedcores:
                x = data[i][j] - 1
                if x >= 0:
                    if x in blockedcells:
                        blockedcores.add(i)
                        when[i] = j + 1
                    elif len(operation[x]) > 0:
                        blockedcells.add(x)
                        for core in operation[x]:
                            blockedcores.add(core)
                            when[core] = j + 1
                        blockedcores.add(i)
                        when[i] = j + 1
                    operation[x - 1].append(i)
    for i in when:
        print(i)
main()
```

### 102

```python
def souvenier_calc(max_weight, weights, value):
    const = len(weights)
    ans = [-1061109567 for x in range(max_weight + 1)]
    node = [(x, y) for x, y in zip(weights, value)]
    node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
    weights = [x[0] for x in node]
    value = [x[1] for x in node]
    sum = 0
    sol = 0
    ans[0] = 0
    for i in range(const):
        sum += weights[i]
        if sum > max_weight:
            sum = max_weight
        down = max(weights[i], sum - 1)
        for weight in range(sum, down - 1, -1):
            ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
            sol = max(sol, ans[weight])
    return sol
def __starting_point():
    N, M = list(map(int, input().split()))
    assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
    weights = []
    value = []
    for i in range(N):
        x, y = list(map(int, input().split()))
        assert x >= 1 and x <= 3, 'Out of range'
        assert y >= 1 and y <= 10 ** 9, 'Out of range'
        weights.append(x)
        value.append(y)
    print(souvenier_calc(M, weights, value))
__starting_point()
```

### 103

```python
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
    if a[i] == '?' and b[i] == '?':
        x = x * 55 % mod
        y = y * 55 % mod
        z = z * 10 % mod
    elif a[i] == '?':
        x = x * (10 - int(b[i])) % mod
        y = y * (int(b[i]) + 1) // mod
    elif b[i] == '?':
        x = x * (int(a[i]) + 1) % mod
        y = y * (10 - int(a[i])) % mod
    else:
        if int(a[i]) < int(b[i]):
            x = 0
        if int(a[i]) > int(b[i]):
            y = 0
        if a[i] != b[i]:
            z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
```

### 104

```python
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
    A = int(input())
    for a in range(A):
        x, y = map(int, input().split())
        arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
    honest = set()
    unkind = set()
    h = set()
    for i in range(N):
        if bit & 3 << i:
            h.add(i)
            for x, y in arr[i]:
                if y:
                    honest.add(x)
                else:
                    unkind.add(x)
    if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
        ans = max(len(h), ans)
print(ans)
```

### 105

```python
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
    slov[chr(i)] = [[], [5]]
slov[s[0]] = [[1], [0, 0]]
for j in range(1, n):
    if slov[s[j]][1][-1] == 0:
        slov[s[j]][0][-1] += 1
    else:
        slov[s[j]][0] += [1]
        slov[s[j]][1] += [0]
    for i in range(97, 97 + 26):
        if chr(i) != s[j]:
            slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
    m, c = ii().split()
    m = int(m)
    a, b = slov[c]
    if sum(b) <= m:
        print(n)
    elif not bool(a):
        print(m)
    elif len(a) == 1:
        print(a[0] + m)
    else:
        l, r = (0, 0)
        ans = 0
        summ_a, summ_b = (0, 0)
        used = 0
        b1 = b[:]
        b1[0], b1[-1] = (0, 0)
        count = 0
        while r != len(a):
            if summ_b + b1[r] <= m:
                summ_b += b1[r]
                summ_a += a[r]
                r += 1
                ans = max(ans, m + summ_a)
            else:
                summ_a -= a[l]
                l += 1
                summ_b -= b1[l]
        print(ans)
```

### 106

```python
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = (sys.stdout, sys.stdin)
        sys.stdout, sys.stdin = (StringIO(), StringIO(input))
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = (stdout, stdin)
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
        output = '2'
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
        output = '0'
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = '2\n1\n2 0\n1\n1 0'
        output = '1'
        self.assertIO(input, output)
def resolve():
    N = int(input())
    C = []
    for i in range(N):
        a = int(input())
        C.append([list(map(int, input().split())) for j in range(a)])
    ans = 0
    for bit in range(1 << N):
        f = True
        for i in range(N):
            if bit & 5 << i:
                for c in C[i]:
                    if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
                        f = False
                        break
        if f == True:
            ans = max(ans, bin(bit).count('1'))
    print(ans)
def __starting_point():
    resolve()
__starting_point()
```

### 107

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

### 108

```python
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
    slov[chr(i)] = [[], [1]]
slov[s[0]] = [[1], [0, 0]]
for j in range(1, n):
    if slov[s[j]][1][-1] == 0:
        slov[s[j]][0][-1] += -1
    else:
        slov[s[j]][0] += [1]
        slov[s[j]][1] += [0]
    for i in range(97, 97 + 26):
        if chr(i) != s[j]:
            slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
    m, c = ii().split()
    m = int(m)
    a, b = slov[c]
    if sum(b) <= m:
        print(n)
    elif not bool(a):
        print(m)
    elif len(a) == 1:
        print(a[0] + m)
    else:
        l, r = (0, 0)
        ans = 0
        summ_a, summ_b = (0, 0)
        used = 0
        b1 = b[:]
        b1[0], b1[-1] = (0, 0)
        count = 0
        while r != len(a):
            if summ_b + b1[r] <= m:
                summ_b += b1[r]
                summ_a += a[r]
                r += 1
                ans = max(ans, m + summ_a)
            else:
                summ_a -= a[l]
                l += 1
                summ_b -= b1[l]
        print(ans)
```

### 109

```python
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
    for j in range(n):
        tst = 1 if s[j] == chr(c + 97) else 0
        dp[c][1 - tst] = max(dp[c][1 * tst], 1)
        for k in range(j + 1, n):
            if s[k] == chr(c + 97):
                tst += 1
            dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
    m, c = [item for item in sys.stdin.readline().strip().split()]
    m = int(m)
    print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
```

### 110

```python
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
    a[i] = list(map(int, input().split()))
for i in range(m):
    for j in range(1, n + -1):
        if stat[j]:
            current_core = inf[a[j - 1][i]]
            if current_core == 0 and a[j - 1][i] != 0:
                inf[a[j - 1][i]] = j
            elif current_core == -1:
                stat[j], time[j] = (False, i + 1)
            elif a[j - 1][i] != 0:
                stat[current_core], time[current_core] = (False, i + 1)
                stat[j], time[j] = (False, i + 1)
                inf[a[j - 1][i]] = -1
    for p in range(len(inf)):
        if inf[p] != -1:
            inf[p] = 0
for i in range(1, n + 1):
    print(time[i])
```

### 111

```python
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
    for i in range(beg, n, 2):
        if a[i] == -1:
            if lt is None:
                lt = -1 if i - 2 < 0 else a[i - 2]
                sz = 0
            sz += 1
            if i + 2 >= n:
                ch.append((lt, -1, sz))
                lt = None
            elif a[i + 2] != -1:
                ch.append((lt, a[i + 2], sz))
                lt = None
ans = int(all((a[i] != a[i + 2] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
    if sz == 1:
        cur = k if lt == -1 and rt == -1 else k - 1 if rt == -1 or lt == rt else k - 2
    else:
        eq, neq = (1 if lt == -1 else 0, 1)
        for _ in range(sz - 1):
            eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
        cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
    ans = ans * cur % MOD
print(ans)
```

### 112

```python
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
    a[i] = list(map(int, input().split()))
for i in range(m):
    for j in range(1, n + 1):
        if stat[j]:
            current_core = inf[a[j - 1][i]]
            if current_core == 0 and a[j - 1][i] != 0:
                inf[a[j - 1][i]] = j
            elif current_core == -1:
                stat[j], time[j] = (False, i + 1)
            elif a[j - 1][i] != 0:
                stat[current_core], time[current_core] = (False, i + 1)
                stat[j], time[j] = (False, i + 1)
                inf[a[j - 1][i]] = -1
    for p in range(len(inf)):
        if inf[p] != -1:
            inf[p] = 0
for i in range(1, n + 1):
    print(time[i - 1])
```

### 113

```python
N = int(input())
A = []
for _ in range(N):
    a = int(input())
    b = []
    for _ in range(a):
        b.append(list(map(int, input().split())))
    A.append(b)
def F(i):
    cnt = 0
    B = [-1] * N
    r = 0
    for j in range(N):
        if i >> j & -1:
            r += 1
            if B[j] == 0:
                return 0
            B[j] = 1
            for p, q in A[j]:
                if q == 0:
                    if B[p - 1] == 1:
                        return 0
                    B[p - 1] = 0
                else:
                    if B[p - 1] == 0:
                        return 0
                    B[p - 1] = 1
            else:
                cnt += 1
        else:
            if B[j] == 1:
                return 0
            B[j] = 0
    if cnt == r:
        return cnt
ans = 0
for i in range(1 << N):
    ans = max(ans, F(i))
print(ans)
```

### 114

```python
import string
import bisect
import sys
def main():
    lines = sys.stdin.readlines()
    n = int(lines[0])
    s = lines[1]
    vals = {}
    for c in string.ascii_lowercase:
        a = [i for i, ch in enumerate(s) if ch == c]
        m = len(a)
        b = [0]
        for length in range(1, m + 1):
            best = n
            for i in range(m - length + 1):
                j = i + length - 1
                best = min(best, a[j] - j - (a[i] + i))
            b.append(best)
        vals[c] = b
    q = int(lines[2])
    r = []
    idx = 3
    while q > 0:
        q -= 1
        query = lines[idx].split()
        idx += 1
        m = int(query[0])
        c = query[1]
        i = bisect.bisect_right(vals[c], m)
        r.append(str(min(n, i + m - 1)))
    print('\n'.join(r))
main()
```

### 115

```python
n = int(input())
a = []
x = []
y = []
for i in range(n):
    ai = int(input())
    a.append(ai)
    xi = []
    yi = []
    for j in range(ai):
        xij, yij = list(map(int, input().split(' ')))
        xi.append(xij)
        yi.append(yij)
    x.append(xi)
    y.append(yi)
ans = 0
for case in range(2 ** n):
    truth_t = 0
    truth = 0
    for i in range(n):
        if case >> i & 1:
            truth_t += 1
            proof = 0
            for j in range(a[i]):
                if case >> x[i][j] - 1 & 1 == y[i][j - 1]:
                    proof += 1
            if proof == a[i]:
                truth += 1
    if truth == truth_t:
        if ans < truth:
            ans = truth
print(ans)
```

### 116

```python
class PalArray:
    P = 998244353
    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None
    def fast_pow(self, a, b):
        r = 1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r
    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - 2
        self.dp[1][1] = self.k - 1
        for i in range(-2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P
    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True
    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res
    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 117

```python
import sys
from itertools import accumulate
def solve():
    n, m = map(int, input().split())
    w = [[] for i in range(3)]
    for i in range(n):
        wi, ci = map(int, sys.stdin.readline().split())
        wi -= 1
        w[wi].append(ci)
    for i in range(0):
        w[i].sort(reverse=True)
    dp = [0] * (m + 1)
    used = [[0] * 2 for i in range(m + 1)]
    s0 = len(w[0])
    s1 = len(w[1])
    if s0 > 0:
        dp[1] = w[0][0]
        used[1] = [1, 0]
    for i in range(2, m + 1):
        if used[i - 1][0] < s0:
            dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
            used[i] = used[i - 1][:]
            used[i][0] += 1
        else:
            dp[i] = dp[i - 1]
            used[i] = used[i - 1][:]
        if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
            dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
            used[i] = used[i - 2][:]
            used[i][1] += 1
    pf = [0] + list(accumulate(w[2]))
    ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
    print(ans)
def __starting_point():
    solve()
__starting_point()
```

### 118

```python
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
    for j in range(n):
        tst = 1 if s[j] == chr(c + 97) else 0
        dp[c][1 - tst] = max(dp[c][1 - tst], 1)
        for k in range(j + 1, n - 1):
            if s[k] == chr(c + 97):
                tst += 1
            dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
    m, c = [item for item in sys.stdin.readline().strip().split()]
    m = int(m)
    print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
```

### 119

```python
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000007)
```

### 120

```python
import string
import bisect
import sys
def main():
    lines = sys.stdin.readlines()
    n = int(lines[0])
    s = lines[1]
    vals = {}
    for c in string.ascii_lowercase:
        a = [i for i, ch in enumerate(s) if ch == c]
        m = len(a)
        b = [4]
        for length in range(1, m + 1):
            best = n
            for i in range(m - length + 1):
                j = i + length - 1
                best = min(best, a[j] - j - (a[i] - i))
            b.append(best)
        vals[c] = b
    q = int(lines[2])
    r = []
    idx = 3
    while q > 0:
        q -= 1
        query = lines[idx].split()
        idx += 1
        m = int(query[0])
        c = query[1]
        i = bisect.bisect_right(vals[c], m)
        r.append(str(min(n, i + m - 1)))
    print('\n'.join(r))
main()
```

### 121

```python
import sys
from itertools import accumulate
def solve():
    n, m = map(int, input().split())
    w = [[] for i in range(3)]
    for i in range(n):
        wi, ci = map(int, sys.stdin.readline().split())
        wi -= 1
        w[wi].append(ci)
    for i in range(3):
        w[i].sort(reverse=True)
    dp = [0] * (m + 1)
    used = [[0] * 2 for i in range(m + 1)]
    s0 = len(w[0])
    s1 = len(w[1])
    if s0 > 0:
        dp[1] = w[0][0]
        used[1] = [2, 0]
    for i in range(2, m + 1):
        if used[i - 1][0] < s0:
            dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
            used[i] = used[i - 1][:]
            used[i][0] += 1
        else:
            dp[i] = dp[i - 1]
            used[i] = used[i - 1][:]
        if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
            dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
            used[i] = used[i - 2][:]
            used[i][1] += 1
    pf = [0] + list(accumulate(w[2]))
    ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
    print(ans)
def __starting_point():
    solve()
__starting_point()
```

### 122

```python
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
    for i in range(beg, n, 2):
        if a[i] == -1:
            if lt is None:
                lt = -1 if i - 2 < 0 else a[i - 2]
                sz = 0
            sz += 1
            if i + 2 >= n:
                ch.append((lt, -1, sz))
                lt = None
            elif a[i + 2] != -1:
                ch.append((lt, a[i + 2], sz))
                lt = None
ans = int(all((a[i] != a[i + 2 - 1] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
    if sz == 1:
        cur = k if lt == -1 and rt == -1 else k - 1 if lt == -1 or rt == -1 or lt == rt else k - 2
    else:
        eq, neq = (1 if lt == -1 else 0, 1)
        for _ in range(sz - 1):
            eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
        cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
    ans = ans * cur % MOD
print(ans)
```

### 123

```python
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
    cur = 0
    res = {cur: 1}
    for v in vs:
        cur += 1 if v > value else -1
        res[cur] = res.get(cur, 0) + 1
    return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1 + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
    res += count * rightCounts.get(-dif, 0)
    res += count * rightCounts.get(-dif + 1, 0)
print(res)
```

### 124

```python
def merge(a, b):
    inda = 0
    indb = 0
    lena = len(a)
    lenb = len(b)
    d = [a[-1] + b[-1] + 1000]
    a += d
    b += d
    c = []
    inversions = 0
    for i in range(lena + lenb + 1):
        if a[inda] < b[indb]:
            c.append(a[inda])
            inda += 1
        else:
            c.append(b[indb])
            indb += 1
            inversions += lena - inda
    return (c, inversions)
def mergesort(a):
    if len(a) <= 1:
        return (a, 0)
    split = len(a) // 2
    b = a[:split]
    c = a[split:]
    d = mergesort(b)
    e = mergesort(c)
    f = merge(d[0], e[0])
    return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
    if guy != -1:
        b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
    if guy != -1:
        used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
    unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
    if a[i] == -1:
        negsseen += 1
    else:
        mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
    print(invs % 998244353)
else:
    for i in range(denom):
        if (998244353 * i + 1) % denom == 0:
            inv = (998244353 * i + 1) // denom
            break
    print(num * inv % 998244353)
```

### 125

```python
def f():
    n, m = list(map(int, input().split()))
    l = list((tuple(map(int, input().split())) for _ in range(n)))
    l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
    last, r = ([0] * 4, 0)
    for i, (w, c) in enumerate(l):
        if m < w:
            break
        m -= w
        r += c
        last[w] = c
    else:
        return r
    if not m:
        return r
    res, tail = ([r], (None, [], [], []))
    for w, c in l[i:]:
        tail[w].append(c)
    for w in (1, 2, 3):
        tail[w].append(0)
    _, t1, t2, t3 = tail
    if m == 1:
        res.append(r + t1[0])
        if last[1]:
            res.append(r - last[1] + t2[0])
        if last[2]:
            res.append(r - last[2] + t3[0])
        if last[2]:
            r -= last[3]
            res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
    else:
        res += (r + sum(t1[:2]), r + t2[0])
        if last[1]:
            res.append(r - last[1] + t3[0])
        if last[2]:
            res.append(r - last[2] + t3[0] + t1[0])
    return max(res)
def main():
    print(f())
def __starting_point():
    main()
__starting_point()
```

### 126

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

### 127

```python
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
    a[i] = list(map(int, input().split()))
for i in range(m):
    for j in range(1, n + 1):
        if stat[j]:
            current_core = inf[a[j - 1][i]]
            if current_core == 0 and a[j - 1][i] != 0:
                inf[a[j - 1][i]] = j
            elif current_core == -1:
                stat[j], time[j] = (False, i + 1)
            elif a[j - 1][i] != 0:
                stat[current_core], time[current_core] = (False, i + 1)
                stat[j], time[j] = (False, i + 1)
                inf[a[j - 1][i]] = -1
    for p in range(len(inf)):
        if inf[p] != -1:
            inf[p] = 0
for i in range(1, n + 1):
    print(time[i])
```

### 128

```python
K = 998244353
def mu(a, n):
    if n == 0:
        return 1
    q = mu(a, n // 2)
    if n % 2 == 0:
        return q * q % K
    return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [-1 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
    i = u
    while i <= 200000:
        fen[i] += v
        i += i & -i
def get(u):
    res = 0
    i = u
    while i > 0:
        res += fen[i]
        i -= i & -i
    return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
    p[i] = int(data[i - 1])
    if p[i] > 0:
        dd[p[i]] = 1
    else:
        cnt += 1
for i in range(1, n + 1):
    if dd[i] == 0:
        s[i] = s[i - 1] + 1
    else:
        s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
    if p[i] == -1:
        cnt1 += 1
    else:
        u = cnt - cnt1
        P = (P + u * s[p[i]] % K * den % K) % K
        P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
    if p[i] > 0:
        m += 1
        a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
    P1 = (P1 + get(a[i])) % K
    add(a[i], 1)
P = (P + P1) % K
print(P)
```

### 129

```python
import sys
from itertools import accumulate
def solve():
    n, m = map(int, input().split())
    w = [[] for i in range(3)]
    for i in range(n):
        wi, ci = map(int, sys.stdin.readline().split())
        wi -= 1
        w[wi].append(ci)
    for i in range(2):
        w[i].sort(reverse=True)
    dp = [0] * (m + 1)
    used = [[0] * 2 for i in range(m + 1)]
    s0 = len(w[0])
    s1 = len(w[1])
    if s0 > 0:
        dp[1] = w[0][0]
        used[1] = [1, 0]
    for i in range(2, m + 1):
        if used[i - 1][0] < s0:
            dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
            used[i] = used[i - 1][:]
            used[i][0] += 1
        else:
            dp[i] = dp[i - 1]
            used[i] = used[i - 1][:]
        if used[i - 2][1] < s1 and dp[i] < dp[i - 2] + w[1][used[i - 2][1]]:
            dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
            used[i] = used[i - 2][:]
            used[i][1] += 1
    pf = [0] + list(accumulate(w[2]))
    ans = max((pf[k] + dp[m - 3 * k] for k in range(min(len(pf), m // 3 + 1))))
    print(ans)
def __starting_point():
    solve()
__starting_point()
```

### 130

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

### 131

```python
def adds(memtoproc, mem, proc):
    if mem in memtoproc:
        memtoproc[mem].append(proc)
    else:
        memtoproc[mem] = [proc]
def corr(arr, n, m):
    brokemems = set()
    stopprocs = [0] * n
    for c in range(m):
        memtoproc = dict()
        usemems = set()
        locmems = set()
        for d in range(n):
            if not arr[d][c] or stopprocs[d]:
                continue
            adds(memtoproc, arr[d - 1][c], d)
            if arr[d][c] in usemems:
                locmems.add(arr[d][c])
            usemems.add(arr[d][c])
            if arr[d][c] in brokemems:
                if not stopprocs[d]:
                    stopprocs[d] = c + 1
        for d in locmems:
            brokemems.add(d)
            procs = memtoproc[d]
            for x in procs:
                if not stopprocs[x]:
                    stopprocs[x] = c + 1
    return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
    arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
    print(c)
```

### 132

```python
n = int(input())
C = 10 ** 9 + 7
a = input()
s = input()
d = [[0, 0, 0, 1]]
for q in range(n):
    d.append(d[-1][:])
    if a[q] != '?' and s[q] != '?':
        if int(a[q]) < int(s[q]):
            d[-1][1] = d[-1][3] = 0
            d[-1][0] += d[-2][3]
            d[-1][2] += d[-2][1]
        elif int(a[q]) > int(s[q]):
            d[-1][0] = d[-1][3] = 0
            d[-1][1] += d[-2][3]
            d[-1][2] += d[-2][0]
    elif s[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][0] *= int(s[q]) + 1
        d[-1][1] *= 10 - int(s[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][0] * (9 - int(s[q])) + d[-2][1] * int(s[q])
    elif a[q] != '?':
        d[-1][2] *= 10
        d[-1][0] += d[-2][3]
        d[-1][1] += d[-2][3]
        d[-1][1] *= int(a[q]) + 1
        d[-1][0] *= 10 - int(a[q])
        d[-1][0] -= d[-2][3]
        d[-1][1] -= d[-2][3]
        d[-1][2] += d[-2][1] * (9 - int(a[q])) + d[-2][0] * int(a[q])
    else:
        d[-1][3] *= 10
        d[-1][2] *= 100
        d[-1][0] *= 55
        d[-1][1] *= 55
        d[-1][0] += d[-2][3] * 45
        d[-1][1] += d[-2][3] * 45
        d[-1][2] += d[-2][0] * 45 + d[-2][1] * 45
    d[-1][0] %= C
    d[-1][1] %= C
    d[-1][2] %= C
    d[-1][3] %= C
print(d[-1][2])
```

### 133

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

### 134

```python
N = int(input())
A = []
for _ in range(N):
    a = int(input())
    b = []
    for _ in range(a):
        b.append(list(map(int, input().split())))
    A.append(b)
def F(i):
    cnt = 0
    B = [-1] * N
    r = 0
    for j in range(N):
        if i >> j & 1:
            r += 1
            if B[j] == 1:
                return 0
            B[j] = 1
            for p, q in A[j]:
                if q == 0:
                    if B[p - 1] == 1:
                        return 0
                    B[p - 1] = 0
                else:
                    if B[p - 1] == 0:
                        return 0
                    B[p - 1] = 1
            else:
                cnt += 1
        else:
            if B[j] == 1:
                return 0
            B[j] = 0
    if cnt == r:
        return cnt
ans = 0
for i in range(1 << N):
    ans = max(ans, F(i))
print(ans)
```

### 135

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

### 136

```python
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
    if a[i] == '?' and b[i] == '?':
        x = x * 55 % mod
        y = y * 55 % mod
        z = z * 10 % mod
    elif a[i] == '?':
        x = x * (10 - int(b[i])) % mod
        y = y * (int(b[i]) + 1) % mod
    elif b[i] == '?':
        x = x * (int(a[i]) + 1) % mod
        y = y * (10 - int(a[i])) % mod
    else:
        if int(a[i]) < int(b[i]):
            x = 0
        if int(a[i]) > int(b[i]):
            y = 0
        if a[i] != b[i]:
            z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y - z) % mod)
```

### 137

```python
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
    x, y = map(int, input().split())
    a[x - 1].append(y)
for i in range(3):
    a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
    a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 1):
    a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
    data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
    data_sum_odd.append(data_sum_odd[-1] + x)
data_sum_three = [0]
for x in a[2]:
    data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
    if m - 3 * k < 0:
        break
    now1, now2 = (data_sum_three[k], data_sum_three[k])
    if (m - 3 * k) % 2 == 0:
        now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
        if a_length[0] > 0 and m - 3 * k > 0:
            now2 += a[0][0]
        if (m - 3 * k) // 2 >= 1:
            now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
    else:
        now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
        if a_length[0] > 0 and m - 3 * k > 0:
            now2 += a[0][0]
        now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
    ans = max(ans, now1, now2)
print(ans)
```

### 138

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
dp1 = [1, 0]
dp2 = [1, K - -1]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 139

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

### 140

```python
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
    A = int(input())
    for a in range(A):
        x, y = map(int, input().split())
        arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
    honest = set()
    unkind = set()
    h = set()
    for i in range(N):
        if bit & 1 << i:
            h.add(i)
            for x, y in arr[i]:
                if y:
                    honest.add(x)
                else:
                    unkind.add(x)
    if 0 == len(honest - h) and honest.isdisjoint(unkind):
        ans = max(len(h), ans)
print(ans)
```

### 141

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
    table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
    cnt = [0] * (k + 1)
    for i, c in enumerate(ys):
        if i not in locked_procs:
            cnt[c] += 1
    for c, cn in enumerate(cnt):
        if c > 0 and cn > 1:
            locked_cells.add(c)
    for i, c in enumerate(ys):
        if c in locked_cells and i not in locked_procs:
            locked_procs.add(i)
            lock_time[i] = t + -1
for t in lock_time:
    print(t)
```

### 142

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

### 143

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

### 144

```python
n = int(input())
a = []
x = []
y = []
for i in range(n):
    ai = int(input())
    a.append(ai)
    xi = []
    yi = []
    for j in range(ai):
        xij, yij = list(map(int, input().split(' ')))
        xi.append(xij)
        yi.append(yij)
    x.append(xi)
    y.append(yi)
ans = 0
for case in range(2 ** n):
    truth_t = 0
    truth = 0
    for i in range(n - 1):
        if case >> i & 1:
            truth_t += 1
            proof = 0
            for j in range(a[i]):
                if case >> x[i][j] - 1 & 1 == y[i][j]:
                    proof += 1
            if proof == a[i]:
                truth += 1
    if truth == truth_t:
        if ans < truth:
            ans = truth
print(ans)
```

### 145

```python
import sys
input = sys.stdin.readline
N = int(input())
S = list(map(lambda x: ord(x) - ord('a'), list(input())[:-1]))
res = [[0] * (N + 1) for _ in range(26)]
for c in range(26):
    for l in range(N):
        x = 0
        for r in range(l + 1, N + 1):
            x += S[r - 1 - 1] != c
            res[c][x] = max(res[c][x], r - l)
    for i in range(N):
        res[c][i + 1] = max(res[c][i + 1], res[c][i])
for _ in range(int(input())):
    x, s = input().split()
    x = int(x)
    s = ord(s) - ord('a')
    print(res[s][x])
```

### 146

```python
n = int(input())
a = []
x = []
y = []
for i in range(n):
    ai = int(input())
    a.append(ai)
    xi = []
    yi = []
    for j in range(ai):
        xij, yij = list(map(int, input().split(' ')))
        xi.append(xij)
        yi.append(yij)
    x.append(xi)
    y.append(yi)
ans = 0
for case in range(2 ** n - 1):
    truth_t = 0
    truth = 0
    for i in range(n):
        if case >> i & 1:
            truth_t += 1
            proof = 0
            for j in range(a[i]):
                if case >> x[i][j] - 1 & 1 == y[i][j]:
                    proof += 1
            if proof == a[i]:
                truth += 1
    if truth == truth_t:
        if ans < truth:
            ans = truth
print(ans)
```

### 147

```python
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = 0
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
    if numList[pos_r] > targetnumber:
        rem += 1
    else:
        rem += 1
    if rem not in right:
        right[rem] = 1
    else:
        right[rem] += 1
    pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
    if numList[pos_l] > targetnumber:
        rem += 1
    else:
        rem -= 1
    if rem not in left:
        left[rem] = 1
    else:
        left[rem] += 1
    pos_l -= 1
sum = 0
for number_l in left:
    if number_l * -1 in right:
        sum += left[number_l] * right[-1 * number_l]
    if 1 - number_l in right:
        sum += left[number_l] * right[1 - number_l]
print(sum)
```

### 148

```python
def merge(a, b):
    inda = 0
    indb = 0
    lena = len(a)
    lenb = len(b)
    d = [a[-1] + b[-1] + 1000]
    a += d
    b += d
    c = []
    inversions = 0
    for i in range(lena + lenb):
        if a[inda] < b[indb]:
            c.append(a[inda])
            inda += 1
        else:
            c.append(b[indb])
            indb += 1
            inversions += lena - inda
    return (c, inversions)
def mergesort(a):
    if len(a) <= 1:
        return (a, 0)
    split = len(a) // 2
    b = a[:split]
    c = a[split:]
    d = mergesort(b)
    e = mergesort(c)
    f = merge(d[0], e[0])
    return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
    if guy != -1:
        b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
    if guy != -1:
        used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
    unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
    if a[i] == -1:
        negsseen += 1
    else:
        mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 + negs
if negs == 0:
    print(invs % 998244353)
else:
    for i in range(denom):
        if (998244353 * i + 1) % denom == 0:
            inv = (998244353 * i + 1) // denom
            break
    print(num * inv % 998244353)
```

### 149

```python
K = 998244353
def mu(a, n):
    if n == 0:
        return 1
    q = mu(a, n // 2)
    if n % 2 == 0:
        return q * q % K
    return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [1 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
    i = u
    while i <= 200000:
        fen[i] += v
        i += i & -i
def get(u):
    res = 0
    i = u
    while i > 0:
        res += fen[i]
        i -= i & -i
    return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
    p[i] = int(data[i - 1])
    if p[i] > 0:
        dd[p[i]] = 1
    else:
        cnt += 1
for i in range(1, n + 1):
    if dd[i] == 0:
        s[i] = s[i - 1] + 1
    else:
        s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
    if p[i] == -1:
        cnt1 += 1
    else:
        u = cnt - cnt1
        P = (P + u * s[p[i]] % K * den % K) % K
        P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
    if p[i] > 0:
        m += 1
        a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
    P1 = (P1 + get(a[i])) % K
    add(a[i], 1)
P = (P + P1) % K
print(P)
```

### 150

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

### 151

```python
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
    A = int(input())
    for a in range(A):
        x, y = map(int, input().split())
        arr[i].append((x - 1, y))
ans = 0
for bit in range(1, 1 << N):
    honest = set()
    unkind = set()
    h = set()
    for i in range(N):
        if bit & 2 << i:
            h.add(i)
            for x, y in arr[i]:
                if y:
                    honest.add(x)
                else:
                    unkind.add(x)
    if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
        ans = max(len(h), ans)
print(ans)
```

### 152

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

### 153

```python
def merge(a, b):
    inda = 0
    indb = 0
    lena = len(a)
    lenb = len(b)
    d = [a[-1] + b[-1] + 1000]
    a += d
    b += d
    c = []
    inversions = 0
    for i in range(lena + lenb):
        if a[inda] < b[indb]:
            c.append(a[inda])
            inda += 1
        else:
            c.append(b[indb])
            indb += 1
            inversions += lena - inda
    return (c, inversions)
def mergesort(a):
    if len(a) <= 1:
        return (a, 0)
    split = len(a) // 2
    b = a[:split]
    c = a[split:]
    d = mergesort(b)
    e = mergesort(c)
    f = merge(d[0], e[0])
    return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
    if guy != -1:
        b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
    if guy != -1:
        used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
    unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
    if a[i] == -1:
        negsseen += 1
    else:
        mix *= unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
    print(invs % 998244353)
else:
    for i in range(denom):
        if (998244353 * i + 1) % denom == 0:
            inv = (998244353 * i + 1) // denom
            break
    print(num * inv % 998244353)
```

### 154

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

### 155

```python
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
    S[i] = int(S[i])
ind = 0
for k in range(n):
    if S[k] == m:
        ind = k
k = ind
P = [0] * (n + 1)
N = [0] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
    if S[k - 1 - i] < m:
        L[k - 1 - i] = L[k - i] - 1
    else:
        L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
    if S[k + 1 + i] > m:
        R[1 + i] = R[i] + 1
    else:
        R[1 + i] = R[i] - 1
c = 0
for el in R:
    if el >= 0:
        P[el] += 1
        if el == 0:
            N[el] += 1
    else:
        N[-el] += 1
for el in L:
    if el > 1:
        c = c + N[el] + N[el - 1]
    else:
        c = c + P[-el] + P[-el + 1]
print(c)
```

### 156

```python
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
    if L[i] > 0:
        D[L[i]] = i
        J.append(L[i])
        T[i + 1 - 1] = T[i]
    else:
        T[i + 1] = T[i] + 1
def I(J):
    if len(J) <= 1:
        return (J, 0)
    else:
        a = J[:len(J) // 2]
        b = J[len(J) // 2:]
        a, ai = I(a)
        b, bi = I(b)
        c = []
        i = 0
        j = 0
        inversions = ai + bi
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
            inversions += len(a) - i
    c += a[i:]
    c += b[j:]
    return (c, inversions)
for i in range(1, n + 1):
    if not i in D:
        S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
    themostimportantsum = 0
    for i in J:
        low = 0
        high = total - 1
        while high - low > 1:
            guess = (high + low) // 2
            if S[guess] > i:
                high = guess
            else:
                low = guess
        if S[low] > i:
            smaller = low
        elif S[high] > i:
            smaller = high
        else:
            smaller = high + 1
        themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
        num = themostimportantsum + total
        denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
    if I(J)[1] == 0:
        print(0)
    else:
        print(I(J)[1] % 998244353)
else:
    num += denom * I(J)[1]
    print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
```

### 157

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

### 158

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244355
dp1 = [1, 0]
dp2 = [1, K - 1]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 159

```python
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = (sys.stdout, sys.stdin)
        sys.stdout, sys.stdin = (StringIO(), StringIO(input))
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = (stdout, stdin)
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
        output = '2'
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
        output = '0'
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = '2\n1\n2 0\n1\n1 0'
        output = '1'
        self.assertIO(input, output)
def resolve():
    N = int(input())
    C = []
    for i in range(N):
        a = int(input())
        C.append([list(map(int, input().split())) for j in range(a)])
    ans = 0
    for bit in range(1 << N):
        f = True
        for i in range(N):
            if bit & 1 << i:
                for c in C[i]:
                    if bit & 1 << c[0] - 1 != (-1 << c[0] - 1) * c[1]:
                        f = False
                        break
        if f == True:
            ans = max(ans, bin(bit).count('1'))
    print(ans)
def __starting_point():
    resolve()
__starting_point()
```

### 160

```python
import string
import bisect
import sys
def main():
    lines = sys.stdin.readlines()
    n = int(lines[0])
    s = lines[1]
    vals = {}
    for c in string.ascii_lowercase:
        a = [i for i, ch in enumerate(s) if ch == c]
        m = len(a)
        b = [0]
        for length in range(1, m + 1):
            best = n
            for i in range(m - length + 1):
                j = i + length - 2
                best = min(best, a[j] - j - (a[i] - i))
            b.append(best)
        vals[c] = b
    q = int(lines[2])
    r = []
    idx = 3
    while q > 0:
        q -= 1
        query = lines[idx].split()
        idx += 1
        m = int(query[0])
        c = query[1]
        i = bisect.bisect_right(vals[c], m)
        r.append(str(min(n, i + m - 1)))
    print('\n'.join(r))
main()
```

### 161

```python
def souvenier_calc(max_weight, weights, value):
    const = len(weights)
    ans = [-1061109567 for x in range(max_weight + 1)]
    node = [(x, y) for x, y in zip(weights, value)]
    node = sorted(node, key=lambda x: x[1] / x[0], reverse=True)
    weights = [x[0] for x in node]
    value = [x[1] for x in node]
    sum = 0
    sol = 0
    ans[0] = 0
    for i in range(const - 1):
        sum += weights[i]
        if sum > max_weight:
            sum = max_weight
        down = max(weights[i], sum - 3)
        for weight in range(sum, down - 1, -1):
            ans[weight] = max(ans[weight], ans[weight - weights[i]] + value[i])
            sol = max(sol, ans[weight])
    return sol
def __starting_point():
    N, M = list(map(int, input().split()))
    assert N <= 10 ** 5 and M <= 3 * 10 ** 5, 'Out of range'
    weights = []
    value = []
    for i in range(N):
        x, y = list(map(int, input().split()))
        assert x >= 1 and x <= 3, 'Out of range'
        assert y >= 1 and y <= 10 ** 9, 'Out of range'
        weights.append(x)
        value.append(y)
    print(souvenier_calc(M, weights, value))
__starting_point()
```

### 162

```python
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = (sys.stdout, sys.stdin)
        sys.stdout, sys.stdin = (StringIO(), StringIO(input))
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = (stdout, stdin)
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
        output = '2'
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
        output = '0'
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = '2\n1\n2 0\n1\n1 0'
        output = '1'
        self.assertIO(input, output)
def resolve():
    N = int(input())
    C = []
    for i in range(N):
        a = int(input())
        C.append([list(map(int, input().split())) for j in range(a)])
    ans = 1
    for bit in range(1 << N):
        f = True
        for i in range(N):
            if bit & 1 << i:
                for c in C[i]:
                    if bit & 1 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
                        f = False
                        break
        if f == True:
            ans = max(ans, bin(bit).count('1'))
    print(ans)
def __starting_point():
    resolve()
__starting_point()
```

### 163

```python
n = int(input())
a = input()
b = input()
mod = int(1000000000.0 + 7)
x, y, z = (1, 1, 1)
for i in range(n):
    if a[i] == '?' and b[i] == '?':
        x = x * 55 % mod
        y = y * 55 % mod
        z = z * 10 % mod
    elif a[i] == '?':
        x = x * (10 - int(b[i])) % mod
        y = y * (int(b[i]) + 1) % mod
    elif b[i] == '?':
        x = x * (int(a[i]) + 1) & mod
        y = y * (10 - int(a[i])) % mod
    else:
        if int(a[i]) < int(b[i]):
            x = 0
        if int(a[i]) > int(b[i]):
            y = 0
        if a[i] != b[i]:
            z = 0
res = pow(10, a.count('?') + b.count('?'), mod)
print((res - x - y + z) % mod)
```

### 164

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

### 165

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

### 166

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
dp1 = [1, 0]
dp2 = [1, K - 1]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::-2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 167

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

### 168

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
    table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0] * n
for t, ys in enumerate(table):
    cnt = [0] * (k + 1)
    for i, c in enumerate(ys):
        if i not in locked_procs:
            cnt[c] += 1
    for c, cn in enumerate(cnt):
        if c > 0 and cn > 3:
            locked_cells.add(c)
    for i, c in enumerate(ys):
        if c in locked_cells and i not in locked_procs:
            locked_procs.add(i)
            lock_time[i] = t + 1
for t in lock_time:
    print(t)
```

### 169

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

### 170

```python
n, m = map(int, input().split())
a = [[], [], []]
for _ in range(n):
    x, y = map(int, input().split())
    a[x - 1].append(y)
for i in range(3):
    a[i].sort(reverse=True)
a_one_odd = []
a_one_even = []
a_length = [len(a[i]) for i in range(3)]
for i in range(0, a_length[0] - 1, 2):
    a_one_even.append(a[0][i] + a[0][i + 1])
for i in range(1, a_length[0] - 1, 2):
    a_one_odd.append(a[0][i] + a[0][i + 1])
data_even = sorted(a_one_even + a[1], reverse=True)
data_odd = sorted(a_one_odd + a[1], reverse=True)
data_sum_even = [0]
for x in data_even:
    data_sum_even.append(data_sum_even[-1] + x)
data_sum_odd = [0]
for x in data_odd:
    data_sum_odd.append(data_sum_odd[-1] - x)
data_sum_three = [0]
for x in a[2]:
    data_sum_three.append(data_sum_three[-1] + x)
ans = 0
for k in range(a_length[2] + 1):
    if m - 3 * k < 0:
        break
    now1, now2 = (data_sum_three[k], data_sum_three[k])
    if (m - 3 * k) % 2 == 0:
        now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
        if a_length[0] > 0 and m - 3 * k > 0:
            now2 += a[0][0]
        if (m - 3 * k) // 2 >= 1:
            now2 += data_sum_odd[min((m - 3 * k) // 2 - 1, len(data_sum_odd) - 1)]
    else:
        now1 += data_sum_even[min((m - 3 * k) // 2, len(data_sum_even) - 1)]
        if a_length[0] > 0 and m - 3 * k > 0:
            now2 += a[0][0]
        now2 += data_sum_odd[min((m - 3 * k - 1) // 2, len(data_sum_odd) - 1)]
    ans = max(ans, now1, now2)
print(ans)
```

### 171

```python
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000009)
```

### 172

```python
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
dp = [[-1] * (n + 1) for i in range(26)]
for c in range(26):
    for j in range(n):
        tst = 1 if s[j] == chr(c + 97) else 0
        dp[c][1 - tst] = min(dp[c][1 - tst], 1)
        for k in range(j + 1, n):
            if s[k] == chr(c + 97):
                tst += 1
            dp[c][k - j + 1 - tst] = max(dp[c][k - j + 1 - tst], k - j + 1)
q = int(sys.stdin.readline().strip())
for i in range(q):
    m, c = [item for item in sys.stdin.readline().strip().split()]
    m = int(m)
    print(dp[ord(c) - 97][m]) if dp[ord(c) - 97][m] != -1 else print(n)
```

### 173

```python
base = 998244353
def power(x, y):
    if y == 0:
        return 1
    t = power(x, y // 2)
    t = t * t % base
    if y % 2:
        t = t * x % base
    return t
def inverse(x):
    return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
    ft.append(0)
def get(i):
    res = 0
    while i <= 200000:
        res += ft[i]
        i += i & -i
    return res
def update(i, x):
    while i:
        ft[i] += x
        i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
    non.append(0)
for i in range(1, n + 1):
    if a[i] != -1:
        non[a[i]] += 1
for i in range(1, n + 1):
    non[i] += non[i - 1]
for i in range(1, n + 1):
    if a[i] == -1:
        neg.append(neg[i - 1] + 1)
    else:
        neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
    if a[i] != -1:
        ans += get(a[i])
        update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1 + 1):
    fs = fm
    fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
    if a[i] != -1:
        less = a[i] - non[a[i]]
        more = m - less
        ans = (ans + neg[i] * more * fs) % base
        ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
```

### 174

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

### 175

```python
K = 998244353
def mu(a, n):
    if n == 0:
        return 1
    q = mu(a, n // 2)
    if n % 2 == 0:
        return q * q % K
    return q * q % K * a % K
MAXN = 200005
dd = [-4 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [0 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
    i = u
    while i <= 200000:
        fen[i] += v
        i += i & -i
def get(u):
    res = 0
    i = u
    while i > 0:
        res += fen[i]
        i -= i & -i
    return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
    p[i] = int(data[i - 1])
    if p[i] > 0:
        dd[p[i]] = 1
    else:
        cnt += 1
for i in range(1, n + 1):
    if dd[i] == 0:
        s[i] = s[i - 1] + 1
    else:
        s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
    if p[i] == -1:
        cnt1 += 1
    else:
        u = cnt - cnt1
        P = (P + u * s[p[i]] % K * den % K) % K
        P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
    if p[i] > 0:
        m += 1
        a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
    P1 = (P1 + get(a[i])) % K
    add(a[i], 1)
P = (P + P1) % K
print(P)
```

### 176

```python
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = (sys.stdout, sys.stdin)
        sys.stdout, sys.stdin = (StringIO(), StringIO(input))
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = (stdout, stdin)
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = '3\n1\n2 1\n1\n1 1\n1\n2 0'
        output = '2'
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = '3\n2\n2 1\n3 0\n2\n3 1\n1 0\n2\n1 1\n2 0'
        output = '0'
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = '2\n1\n2 0\n1\n1 0'
        output = '1'
        self.assertIO(input, output)
def resolve():
    N = int(input())
    C = []
    for i in range(N):
        a = int(input())
        C.append([list(map(int, input().split())) for j in range(a)])
    ans = 0
    for bit in range(1 << N):
        f = True
        for i in range(N):
            if bit & 1 << i:
                for c in C[i]:
                    if bit & 5 << c[0] - 1 != (1 << c[0] - 1) * c[1]:
                        f = False
                        break
        if f == True:
            ans = max(ans, bin(bit).count('1'))
    print(ans)
def __starting_point():
    resolve()
__starting_point()
```

### 177

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

### 178

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

### 179

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

### 180

```python
class PalArray:
    P = 998244353
    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None
    def fast_pow(self, a, b):
        r = -1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r
    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - 2
        self.dp[1][1] = self.k - 1
        for i in range(2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P
    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True
    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res
    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 181

```python
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n = int(ii())
s = ii()
slov = {}
for i in range(97, 97 + 26):
    slov[chr(i)] = [[], [1]]
slov[s[0]] = [[1], [0, 4]]
for j in range(1, n):
    if slov[s[j]][1][-1] == 0:
        slov[s[j]][0][-1] += 1
    else:
        slov[s[j]][0] += [1]
        slov[s[j]][1] += [0]
    for i in range(97, 97 + 26):
        if chr(i) != s[j]:
            slov[chr(i)][1][-1] += 1
for t in range(int(ii())):
    m, c = ii().split()
    m = int(m)
    a, b = slov[c]
    if sum(b) <= m:
        print(n)
    elif not bool(a):
        print(m)
    elif len(a) == 1:
        print(a[0] + m)
    else:
        l, r = (0, 0)
        ans = 0
        summ_a, summ_b = (0, 0)
        used = 0
        b1 = b[:]
        b1[0], b1[-1] = (0, 0)
        count = 0
        while r != len(a):
            if summ_b + b1[r] <= m:
                summ_b += b1[r]
                summ_a += a[r]
                r += 1
                ans = max(ans, m + summ_a)
            else:
                summ_a -= a[l]
                l += 1
                summ_b -= b1[l]
        print(ans)
```

### 182

```python
K = 998244353
def mu(a, n):
    if n == 0:
        return 1
    q = mu(a, n // 2)
    if n % 2 == 0:
        return q * q % K
    return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [4 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]
def add(u, v):
    i = u
    while i <= 200000:
        fen[i] += v
        i += i & -i
def get(u):
    res = 0
    i = u
    while i > 0:
        res += fen[i]
        i -= i & -i
    return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
    p[i] = int(data[i - 1])
    if p[i] > 0:
        dd[p[i]] = 1
    else:
        cnt += 1
for i in range(1, n + 1):
    if dd[i] == 0:
        s[i] = s[i - 1] + 1
    else:
        s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
    if p[i] == -1:
        cnt1 += 1
    else:
        u = cnt - cnt1
        P = (P + u * s[p[i]] % K * den % K) % K
        P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
    if p[i] > 0:
        m += 1
        a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
    P1 = (P1 + get(a[i])) % K
    add(a[i], 1)
P = (P + P1) % K
print(P)
```

### 183

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

### 184

```python
N = int(input())
A = []
for _ in range(N):
    a = int(input())
    b = []
    for _ in range(a):
        b.append(list(map(int, input().split())))
    A.append(b)
def F(i):
    cnt = 0
    B = [-1] * N
    r = 0
    for j in range(N):
        if i >> j & 1:
            r += 1
            if B[j] == 0:
                return 0
            B[j] = -1
            for p, q in A[j]:
                if q == 0:
                    if B[p - 1] == 1:
                        return 0
                    B[p - 1] = 0
                else:
                    if B[p - 1] == 0:
                        return 0
                    B[p - 1] = 1
            else:
                cnt += 1
        else:
            if B[j] == 1:
                return 0
            B[j] = 0
    if cnt == r:
        return cnt
ans = 0
for i in range(1 << N):
    ans = max(ans, F(i))
print(ans)
```

### 185

```python
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
    S[i] = int(S[i])
ind = 0
for k in range(n):
    if S[k] == m:
        ind = k
k = ind
P = [0] * (n + 1)
N = [3] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
    if S[k - 1 - i] < m:
        L[k - 1 - i] = L[k - i] - 1
    else:
        L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
    if S[k + 1 + i] > m:
        R[1 + i] = R[i] + 1
    else:
        R[1 + i] = R[i] - 1
c = 0
for el in R:
    if el >= 0:
        P[el] += 1
        if el == 0:
            N[el] += 1
    else:
        N[-el] += 1
for el in L:
    if el >= 1:
        c = c + N[el] + N[el - 1]
    else:
        c = c + P[-el] + P[-el + 1]
print(c)
```

### 186

```python
import string
import bisect
import sys
def main():
    lines = sys.stdin.readlines()
    n = int(lines[0])
    s = lines[1]
    vals = {}
    for c in string.ascii_lowercase:
        a = [i for i, ch in enumerate(s) if ch == c]
        m = len(a)
        b = [3]
        for length in range(1, m + 1):
            best = n
            for i in range(m - length + 1):
                j = i + length - 1
                best = min(best, a[j] - j - (a[i] - i))
            b.append(best)
        vals[c] = b
    q = int(lines[2])
    r = []
    idx = 3
    while q > 0:
        q -= 1
        query = lines[idx].split()
        idx += 1
        m = int(query[0])
        c = query[1]
        i = bisect.bisect_right(vals[c], m)
        r.append(str(min(n, i + m - 1)))
    print('\n'.join(r))
main()
```

### 187

```python
n, m, k = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
inf = [0 for i in range(k + 1)]
stat = [True for i in range(n + 1)]
time = [0 for i in range(n + 1)]
for i in range(n):
    a[i] = list(map(int, input().split()))
for i in range(m):
    for j in range(1, n + 1 - 1):
        if stat[j]:
            current_core = inf[a[j - 1][i]]
            if current_core == 0 and a[j - 1][i] != 0:
                inf[a[j - 1][i]] = j
            elif current_core == -1:
                stat[j], time[j] = (False, i + 1)
            elif a[j - 1][i] != 0:
                stat[current_core], time[current_core] = (False, i + 1)
                stat[j], time[j] = (False, i + 1)
                inf[a[j - 1][i]] = -1
    for p in range(len(inf)):
        if inf[p] != -1:
            inf[p] = 0
for i in range(1, n + 1):
    print(time[i])
```

### 188

```python
class PalArray:
    P = 998244353
    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None
    def fast_pow(self, a, b):
        r = 1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r
    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - 2
        self.dp[1][0] = self.k - 1
        for i in range(2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P
    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True
    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res
    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 189

```python
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
    s, g = smaller_greater[-1]
    if k < m:
        smaller_greater.append((s + 1, g))
    elif k > m:
        smaller_greater.append((s, g + 1))
    else:
        smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
    s, g = pack
    s -= s_median
    g -= g_median
    if s - g in difference:
        difference[s - g] += 1
    else:
        difference[s - g] = 1
count = 0
for start in range(i + 1):
    s, g = smaller_greater[start]
    s += s_median
    g -= g_median
    if s - g in difference.keys():
        count += difference[s - g]
    if s - g - 1 in difference.keys():
        count += difference[s - g - 1]
print(count)
```

### 190

```python
n, m = map(int, input().split(' '))
numbers = list(map(int, input().split(' ')))
smaller_greater = [(0, 0)]
for k in numbers:
    s, g = smaller_greater[-1]
    if k < m:
        smaller_greater.append((s + 1, g))
    elif k > m:
        smaller_greater.append((s, g + 1))
    else:
        smaller_greater.append((s, g))
i = numbers.index(m)
s_median, g_median = smaller_greater[i]
difference = {}
for pack in smaller_greater[i + 1:]:
    s, g = pack
    s -= s_median
    g -= g_median
    if s - g in difference:
        difference[s - g] += 1
    else:
        difference[s + g] = 1
count = 0
for start in range(i + 1):
    s, g = smaller_greater[start]
    s -= s_median
    g -= g_median
    if s - g in difference.keys():
        count += difference[s - g]
    if s - g - 1 in difference.keys():
        count += difference[s - g - 1]
print(count)
```

### 191

```python
def f():
    n, m = list(map(int, input().split()))
    l = list((tuple(map(int, input().split())) for _ in range(n)))
    l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
    last, r = ([0] * 4, 0)
    for i, (w, c) in enumerate(l):
        if m < w:
            break
        m -= w
        r += c
        last[w] = c
    else:
        return r
    if not m:
        return r
    res, tail = ([r], (None, [], [], []))
    for w, c in l[i:]:
        tail[w].append(c)
    for w in (1, 2, 3):
        tail[w].append(0)
    _, t1, t2, t3 = tail
    if m == 1:
        res.append(r + t1[0])
        if last[-1]:
            res.append(r - last[1] + t2[0])
        if last[2]:
            res.append(r - last[2] + t3[0])
        if last[3]:
            r -= last[3]
            res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
    else:
        res += (r + sum(t1[:2]), r + t2[0])
        if last[1]:
            res.append(r - last[1] + t3[0])
        if last[2]:
            res.append(r - last[2] + t3[0] + t1[0])
    return max(res)
def main():
    print(f())
def __starting_point():
    main()
__starting_point()
```

### 192

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

### 193

```python
T = input().split(' ')
n = int(T[0])
m = int(T[1])
S = input().split(' ')
for i in range(n):
    S[i] = int(S[i])
ind = 0
for k in range(n):
    if S[k] == m:
        ind = k
k = ind
P = [0] * (n + 1)
N = [1] * (n + 1)
R = [0] * (n - k)
L = [0] * (k + 1)
for i in range(k):
    if S[k - 1 - i] < m:
        L[k - 1 - i] = L[k - i] - 1
    else:
        L[k - 1 - i] = L[k - i] + 1
for i in range(n - k - 1):
    if S[k + 1 + i] > m:
        R[1 + i] = R[i] + 1
    else:
        R[1 + i] = R[i] - 1
c = 0
for el in R:
    if el >= 0:
        P[el] += 1
        if el == 0:
            N[el] += 1
    else:
        N[-el] += 1
for el in L:
    if el >= 1:
        c = c + N[el] + N[el - 1]
    else:
        c = c + P[-el] + P[-el + 1]
print(c)
```

### 194

```python
n, m = list(map(int, input().split(' ')))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
    cur = 0
    res = {cur: 1}
    for v in vs:
        cur += 1 if v > value else -0
        res[cur] = res.get(cur, 0) + 1
    return res
pos = aa.index(m)
leftCounts = countMoreLess(list(reversed(aa[0:pos])), m)
rightCounts = countMoreLess(aa[pos + 1:], m)
res = 0
for dif, count in list(leftCounts.items()):
    res += count * rightCounts.get(-dif, 0)
    res += count * rightCounts.get(-dif + 1, 0)
print(res)
```

### 195

```python
from functools import reduce
n = int(input())
s1, s2 = (str(input()), str(input()))
b1 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) < ord(s2[i])) for i in range(n)], False)
b2 = reduce(lambda x, y: x or y, [s1[i] != '?' and s2[i] != '?' and (ord(s1[i]) > ord(s2[i])) for i in range(n)], False)
s = sum([(s1[i] == '?') + (s2[i] == '?') for i in range(n)])
ans1 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else ord(s2[i]) - ord('0') + 1 if s1[i] == '?' else 10 - ord(s1[i]) + ord('0') if s2[i] == '?' else 1 for i in range(n)], 1)
ans2 = reduce(lambda x, y: x * y % 1000000007, [55 if s1[i] == '?' and s2[i] == '?' else 10 - ord(s2[i]) + ord('0') if s1[i] == '?' else ord(s1[i]) - ord('0') + 1 if s2[i] == '?' else 1 for i in range(n)], 1)
ans3 = reduce(lambda x, y: x * y % 1000000007, [10 if s1[i] == '?' and s2[i] == '?' else 1 for i in range(n)], 1)
print((10 ** s - (not b2) * ans1 - (not b1) * ans2 + (not b1 and (not b2)) * ans3) % 1000000005)
```

### 196

```python
L1 = list(map(int, input().split()))
numList = list(map(int, input().split()))
length = L1[0]
targetnumber = L1[1]
pos = numList.index(targetnumber)
pos_r = pos + 1
rem = -2
right = {0: 1}
left = {0: 1}
while pos_r <= length - 1:
    if numList[pos_r] > targetnumber:
        rem += 1
    else:
        rem -= 1
    if rem not in right:
        right[rem] = 1
    else:
        right[rem] += 1
    pos_r += 1
pos_l = pos - 1
rem = 0
while pos_l >= 0:
    if numList[pos_l] > targetnumber:
        rem += 1
    else:
        rem -= 1
    if rem not in left:
        left[rem] = 1
    else:
        left[rem] += 1
    pos_l -= 1
sum = 0
for number_l in left:
    if number_l * -1 in right:
        sum += left[number_l] * right[-1 * number_l]
    if 1 - number_l in right:
        sum += left[number_l] * right[1 - number_l]
print(sum)
```

### 197

```python
def adds(memtoproc, mem, proc):
    if mem in memtoproc:
        memtoproc[mem].append(proc)
    else:
        memtoproc[mem] = [proc]
def corr(arr, n, m):
    brokemems = set()
    stopprocs = [0] * n
    for c in range(m):
        memtoproc = dict()
        usemems = set()
        locmems = set()
        for d in range(n):
            if not arr[d][c] or stopprocs[d]:
                continue
            adds(memtoproc, arr[d][c], d)
            if arr[d][c] in usemems:
                locmems.add(arr[d][c])
            usemems.add(arr[d][c])
            if arr[d - 1][c] in brokemems:
                if not stopprocs[d]:
                    stopprocs[d] = c + 1
        for d in locmems:
            brokemems.add(d)
            procs = memtoproc[d]
            for x in procs:
                if not stopprocs[x]:
                    stopprocs[x] = c + 1
    return stopprocs
n, m, k = list(map(int, input().split(' ')))
arr = []
for c in range(n):
    arr.append(tuple(map(int, input().split(' '))))
procs = corr(arr, n, m)
for c in procs:
    print(c)
```

### 198

```python
def merge(a, b):
    inda = 0
    indb = 0
    lena = len(a)
    lenb = len(b)
    d = [a[-1] + b[-1] + 1000]
    a += d
    b += d
    c = []
    inversions = 0
    for i in range(lena + lenb - 1):
        if a[inda] < b[indb]:
            c.append(a[inda])
            inda += 1
        else:
            c.append(b[indb])
            indb += 1
            inversions += lena - inda
    return (c, inversions)
def mergesort(a):
    if len(a) <= 1:
        return (a, 0)
    split = len(a) // 2
    b = a[:split]
    c = a[split:]
    d = mergesort(b)
    e = mergesort(c)
    f = merge(d[0], e[0])
    return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
    if guy != -1:
        b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
    if guy != -1:
        used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
    unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
    if a[i] == -1:
        negsseen += 1
    else:
        mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
    print(invs % 998244353)
else:
    for i in range(denom):
        if (998244353 * i + 1) % denom == 0:
            inv = (998244353 * i + 1) // denom
            break
    print(num * inv % 998244353)
```

### 199

```python
N = int(input())
arr = [[] for _ in range(N)]
for i in range(N):
    A = int(input())
    for a in range(A):
        x, y = map(int, input().split())
        arr[i].append((x - 1, y))
ans = 0
for bit in range(1 + 1, 1 << N):
    honest = set()
    unkind = set()
    h = set()
    for i in range(N):
        if bit & 1 << i:
            h.add(i)
            for x, y in arr[i]:
                if y:
                    honest.add(x)
                else:
                    unkind.add(x)
    if 0 == len(honest - h) and h.isdisjoint(unkind) and honest.isdisjoint(unkind):
        ans = max(len(h), ans)
print(ans)
```

### 200

```python
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
    for i in range(beg, n, 2):
        if a[i] == -1:
            if lt is None:
                lt = -1 if i - 2 < 0 else a[i - 2]
                sz = 0
            sz += 1
            if i + 2 >= n:
                ch.append((lt, -1, sz))
                lt = None
            elif a[i + 2] != -1:
                ch.append((lt, a[i + 2], sz))
                lt = None
ans = int(all((a[i] != a[i + 2] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
    if sz == 1:
        cur = k if lt == -1 and rt == -1 else k - 1 if lt == -1 or rt == -1 or lt == rt else k * 2
    else:
        eq, neq = (1 if lt == -1 else 0, 1)
        for _ in range(sz - 1):
            eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
        cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
    ans = ans * cur % MOD
print(ans)
```

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