### 001

```python
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
    for j in range(m - 1, 0, --1):
        if matrix[i][j] == 0:
            mn = min(matrix[i + 1][j], matrix[i][j + 1])
            if mn != 1:
                matrix[i][j] = mn - 1
            else:
                res = -1
                break
    if res == -1:
        break
else:
    for i in range(n):
        if [matrix[i][j] for j in range(m - 1) if matrix[i][j] >= matrix[i][j + 1]]:
            res = -1
            break
    else:
        for j in range(m):
            if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
                res = -1
                break
        else:
            res = sum((sum(matrix[i]) for i in range(n)))
print(res)
```

### 002

```python
import sys

def input():
    return sys.stdin.readline().rstrip()

def input_split():
    return [int(i) for i in input().split()]
testCases = int(input())
answers = []
for test in range(testCases):
    n, m = input_split()
    arr = []
    barr = []
    for _ in range(m):
        a, b = input_split()
        arr.append(a)
        barr.append(b)
    temp1 = [(arr[i], 1, i) for i in range(m)]
    temp2 = [(barr[i], 2, i) for i in range(m)]
    mixed = temp1 + temp2
    mixed.sort()
    mixed.reverse()
    pointer = 0
    done = 0
    maxi = 0
    score = 0
    unlocked = [False for i in range(m)]
    while done < n and pointer < 2 * m:
        val, typ, index = mixed[pointer]
        if typ == 1:
            done += 1
            score += val
            unlocked[index - 1] = True
            if done == n:
                maxi = max(score, maxi)
        else:
            if not unlocked[index]:
                potential = score + (n - done - 1) * val + arr[index]
            else:
                potential = score + (n - done) * val
            maxi = max(potential, maxi)
        pointer += 1
    ans = maxi
    answers.append(ans)
    if test != testCases - 1:
        blank = input()
print(*answers, sep='\n')
```

### 003

```python
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
    a = [item, i, r[i - 1 - 1]]
    costa.append(a)
    i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
    dic[item[1]] = i
    i += 1
index = len(costa) - 1
for item in range(n):
    counter = 0
    a, b = [int(x) for x in input().split()]
    if r[a - 1] >= b:
        counter += cost[a - 1] * b
        r[a - 1] -= b
        costa[dic[a]][2] -= b
    else:
        i = index
        counter += cost[a - 1] * r[a - 1]
        costa[dic[a]][2] = 0
        b -= r[a - 1]
        r[a - 1] = 0
        while i >= 0:
            if costa[i][2] >= b:
                counter += costa[i][0] * b
                r[costa[i][1] - 1] -= b
                costa[i][2] -= b
                break
            else:
                counter += costa[i][0] * costa[i][2]
                r[costa[i][1] - 1] = 0
                index -= 1
                b -= costa[i][2]
                costa[i][2] = 0
            i -= 1
        else:
            counter = 0
    print(counter)
```

### 004

```python
n, v = list(map(int, input().split()))
f = list()
for i in range(n):
    f.append(list(map(int, input().split())))
f.sort()
sum = 0
today = 0
tomor = 0
day = 0
rest = 0
for tree in f:
    if tree[0] > day + 5:
        sum += min(tomor, v)
        tomor = tree[1]
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor -= min(tomor, v)
        day = tree[0]
    elif tree[0] == day + 1:
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor = tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
        day = tree[0]
    else:
        tomor += tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
sum += min(tomor, v)
print(sum)
```

### 005

```python
from collections import deque
from sys import stdin, stdout
input = stdin.readline
saida = []
t = int(input())
modulo = 998244353
for _ in range(t):
    ans = 1
    part = 0
    factor = 0
    fila = deque([])
    n, m = map(int, input().split())
    if m > n // 2 * (n // 2 + 1):
        saida.append('0')
        for edge_count in range(m):
            input()
        continue
    edge = [[] for i in range(n + 1)]
    visitados = [-1] * (n + 1)
    assure = 1
    for arestas in range(m):
        u, v = map(int, input().split())
        edge[u].append(v)
        edge[v].append(u)
    visitados[1] = 0
    fila.append(1)
    break_all = False
    while not break_all:
        par, impar = (1, 0)
        while fila and (not break_all):
            search = fila.popleft()
            current = visitados[search]
            for i in edge[search]:
                if visitados[i] == -1:
                    visitados[i] = current ^ 1
                    if visitados[i] & 1:
                        impar += 1
                    else:
                        par += 1
                    fila.append(i)
                elif visitados[i] == current:
                    break_all = True
                else:
                    assert visitados[i] == current ^ 1
        if break_all:
            ans = 0
        elif (par, impar) == (1, 0):
            factor += 1
        else:
            ans *= pow(2, par, modulo) + pow(2, impar, modulo)
            ans %= modulo
        while assure <= n:
            if visitados[assure] == -1:
                part += 1
                visitados[assure] = 2 * part
                fila.append(assure)
                break
            assure += 1
        if assure == n + 1:
            break
    ans *= pow(2, factor, modulo)
    ans %= modulo
    saida.append(str(ans))
print('\n'.join(saida))
```

### 006

```python
n, m = map(int, input().split())
a = []
for i in range(n):
    a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in range(1, n + 1):
    for j in reversed(range(1, m + 1)):
        dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
        dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -1):
    for j in range(1, m + 1):
        dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
        dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
    for j in range(2, m):
        x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
        y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
        ans = max(ans, x, y)
print(ans)
```

### 007

```python
import bisect
t = int(input())
for _ in range(t):
    n, m = list(map(int, input().split()))
    flowers = []
    flowers_a = []
    max_b = 0
    for i in range(m):
        a, b = list(map(int, input().split()))
        flowers.append((a, b))
    flowers.sort()
    flowers_b = []
    for i in range(m):
        flowers_a.append(flowers[i][0])
        flowers_b.append(flowers[i][1])
    val = 0
    prefix_sum = [0]
    for x in flowers_a:
        prefix_sum.append(prefix_sum[-1] + x)
    for i in range(m):
        idx = bisect.bisect_left(flowers_a, flowers_b[i])
        options = m - idx
        if options >= n:
            temp = prefix_sum[-1] - prefix_sum[-n - 1]
            val = max(val, temp)
            continue
        else:
            temp = prefix_sum[-1] - prefix_sum[-options - 1]
            remaining = n - options
            if idx <= i:
                temp += flowers_b[i] + remaining
            else:
                temp += flowers_a[i] + flowers_b[i] * (remaining - 1)
            val = max(val, temp)
    print(val)
    if _ != t - 1:
        blank_line = input()
```

### 008

```python
n = int(input())
ns = []
for i in range(n):
    s = input()
    ns.append(s)
ns2 = []
for i in range(n):
    s = input()
    ns2.append(s)

def rotate(i, j):
    return (j, n - 1 - i)

def flip(i, j):
    return (j, i)

def main():
    same = True
    for i in range(n):
        for j in range(n):
            if ns[i][j] != ns2[i][j]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = rotate(a, b)
            if not ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = flip(i, j)
            if ns[a][b] != ns2[i][j]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = rotate(a, b)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    else:
        return False
if main():
    print('Yes')
else:
    print('No')
```

### 009

```python
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
    mat1.append(tuple(input().strip()))
for i in range(0, n):
    mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
    mattem = list(zip(*list(reversed(mattem))))
    mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
    mattem = list(zip(*list(reversed(mattem))))
    mats.append(mattem)
flg = 0
for cmat in mats:
    flg2 = 1
    for ri in range(4, n):
        if cmat[ri] != mat1[ri]:
            flg2 = 0
            break
    if flg2 == 1:
        flg = 1
        break
if flg == 1:
    print('Yes')
else:
    print('No')
```

### 010

```python
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in reversed(range(N))] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
```

### 011

```python
from collections import defaultdict
import sys
input = sys.stdin.readline
graph = defaultdict(list)
color = [0] * (3 * 10 ** 5 + 1000)
bipertite = True
MOD = 998244355
result = 1
color_count = [0] * 2
pow_value = []
'\ndef dfs(s, c):\n    nonlocal color\n    nonlocal bipertite\n    nonlocal color_count\n\n    color[s] = c\n    color_count[c] += 1\n    for i in range(0, len(graph[s])):\n\n        if color[graph[s][i]] == -1:\n            dfs(graph[s][i], 1-c)\n\n        if color[s] == color[graph[s][i]]:\n            bipertite = False\n\n'
t = int(input())
pow_value.append(1)
for i in range(1, 3 * 10 ** 5 + 1000):
    next_value = pow_value[i - 1] * 2 % MOD
    pow_value.append(next_value)
while t:
    n, m = list(map(int, input().split()))
    if m == 0:
        print(pow(3, n, MOD))
        t -= 1
        continue
    graph.clear()
    bipertite = True
    result = 1
    for node in range(0, n + 1):
        color[node] = -1
    while m:
        u, v = list(map(int, input().split()))
        graph[u].append(v)
        graph[v].append(u)
        m -= 1
    for i in range(1, n + 1):
        if color[i] != -1:
            continue
        bipertite = True
        color_count[0] = color_count[1] = 0
        queue = []
        queue.append(i)
        color[i] = 0
        color_count[0] += 1
        while queue:
            if bipertite == False:
                break
            front_node = queue.pop()
            for child_node in range(0, len(graph[front_node])):
                if color[graph[front_node][child_node]] == -1:
                    color[graph[front_node][child_node]] = 1 - color[front_node]
                    queue.append(graph[front_node][child_node])
                    color_count[color[graph[front_node][child_node]]] += 1
                elif color[front_node] == color[graph[front_node][child_node]]:
                    bipertite = False
                    break
        if bipertite == False:
            print(0)
            break
        current = (pow_value[color_count[0]] + pow_value[color_count[1]]) % MOD
        result = result * current % MOD
    if bipertite:
        print(result)
    t -= 1
```

### 012

```python
import sys
from math import *

def minp():
    return sys.stdin.readline().strip()

def mint():
    return int(minp())

def mints():
    return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
    a[i] = list(mints())
    dp1[i] = [0] * m
    dp2[i] = [0] * m
    dp3[i] = [0] * m
    dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
    for j in range(0, m):
        z = 0
        if i - 1 >= 0:
            z = dp1[i - 1][j]
        if j - 1 >= 0:
            z = max(z, dp1[i][j - 1])
        dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
    for j in range(m - 1, -1, -1):
        z = 0
        if i + 1 < n:
            z = dp2[i + 1][j]
        if j + 1 < m:
            z = max(z, dp2[i][j + 1])
        dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
    for j in range(0, m):
        z = 0
        if i + 1 < n:
            z = dp3[i + 1][j]
        if j - 1 >= 0:
            z = max(z, dp3[i][j - 1])
        dp3[i][j] = z + a[i][j]
for i in range(0, n):
    for j in range(m - 1, -1, -1):
        z = 0
        if i - 1 >= 0:
            z = dp4[i - 1][j]
        if j + 1 < m:
            z = max(z, dp4[i][j + 1])
        dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 1
for i in range(1, n - 1):
    for j in range(1, m - 1):
        r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
        r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
```

### 013

```python
N = int(input())
first = []
second = []
for i in range(N):
    first.append([s for s in input()])
for i in range(N):
    second.append([s for s in input()])

def rotate_90(matrix):
    return list(zip(*matrix[::-1]))

def flip(matrix):
    return matrix[::-1]

def compare_matrices(first, second):
    for i in range(N):
        for j in range(N):
            if first[i][j] != second[i][j]:
                return False
    return True

def wrap(first, second):
    if compare_matrices(first, second) == True:
        return 'Yes'
    hold_first = first[:]
    for _ in range(3):
        first = rotate_90(first)
        if compare_matrices(first, second) == True:
            return 'Yes'
    first = hold_first
    first = flip(first)
    if compare_matrices(first, second) == True:
        return 'Yes'
    for _ in range(0):
        first = rotate_90(first)
        if compare_matrices(first, second) == True:
            return 'Yes'
    return 'No'
print(wrap(first, second))
```

### 014

```python
from math import gcd
p = 10 ** 9 + 7

class RN:
    p = 10 ** 9 + 7

    def __init__(self, u, d):
        self.u = u
        self.d = d

    def __str__(self):
        return str(self.u) + '/' + str(self.d)

    def cleanup(self):
        self.u = self.u % p
        self.d = self.d % p

    def add(self, u, d):
        self.u = self.u * d + u * self.d
        self.d = self.d * d
        self.cleanup()

    def mult(self, u, d):
        return (self.u * u % p, self.d * d % p)

    def mult_ip(self, u, d):
        self.u, self.d = (self.u * u, self.d * d % p)

    def get_m_exp(self):
        self.cleanup()
        a = gcd(self.u, self.d)
        self.u //= a
        self.d //= a
        return pow(self.d, p - 2, p) * self.u % p
n, m = tuple(map(int, input().split()))
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))

def sum_ch(n):
    return (n + 1) * n // 2

def sol(s1, s2, m):
    strgr = RN(0, 1)
    eq = RN(1, 1)
    for gr, sm, i in zip(s1, s2, list(range(len(s1)))):
        strgr.cleanup()
        if gr != 0 and sm != 0:
            if gr == sm:
                continue
            elif gr < sm:
                return strgr.get_m_exp()
            else:
                strgr.add(eq.u, eq.d)
                return strgr.get_m_exp()
        else:
            if gr == sm == 0:
                strgr.add(*eq.mult(sum_ch(m - 1), m * m))
            elif gr == 0:
                strgr.add(*eq.mult(m - sm, m))
            else:
                strgr.add(*eq.mult(gr - 1, m))
            eq.mult_ip(1, m)
    return strgr.get_m_exp()
'\na = sol([0,0],[1,1], 2) # 3/4\n\na = sol([0,0,0],[1,1,1], 2) # 7/8\na = sol([0,1,1],[1,1,1], 2) # 1/2\na = sol([1,0,1],[1,1,1], 2) # 1/2\n\na = sol([0,0,0],[1,3,3], 3) # 2/2\na = sol([0,0,0],[1,1,0], 2) # 5/8\na = sol([0,0,0],[0,0,0], 2) # 13/16\n'
print(sol(s1, s2, m))
```

### 015

```python
mod = 998244353
import sys
input = sys.stdin.readline
from collections import deque
from collections import Counter

def calc(s, a):
    return (pow(2, s, mod) + pow(2, a - s, mod)) % mod

def find(x):
    while Group[x] != x:
        x = Group[x]
    return x

def Union(x, y):
    if find(x) != find(y):
        Group[find(y)] = Group[find(x)] = min(find(y), find(x))
testcase = int(input())
for test in range(testcase):
    n, m = list(map(int, input().split()))
    EDGE = [list(map(int, input().split())) for i in range(m)]
    EDGELIST = [[] for j in range(n + 1)]
    ANS = 1
    Group = [j for j in range(n + 1)]
    for a, b in EDGE:
        Union(a, b)
        EDGELIST[a].append(b)
        EDGELIST[b].append(a)
    testing = [None] * (n + 1)
    flag = 1
    for i in range(1 + 1, n + 1):
        if testing[i] != None:
            continue
        score = 1
        allscore = 1
        testing[i] = 1
        QUE = deque([i])
        while QUE:
            x = QUE.pop()
            for to in EDGELIST[x]:
                if testing[to] == -testing[x]:
                    continue
                if testing[to] == testing[x]:
                    flag = 0
                    break
                testing[to] = -testing[x]
                if testing[to] == 1:
                    score += 1
                allscore += 1
                QUE.append(to)
            if flag == 0:
                break
        if flag == 0:
            break
        ANS = ANS * calc(score, allscore) % mod
    if flag == 0:
        print(0)
        continue
    print(ANS)
```

### 016

```python
class Union:

    def __init__(self, n):
        self.p = {i: i for i in range(n)}
        self.rank = {i: 1 for i in range(n)}

    def find(self, x):
        if x < 0:
            return x
        if self.p[x] != x:
            self.p[x - 1] = self.find(self.p[x])
        return self.p[x]

    def union(self, x, y):
        if x < 0 or y < 0:
            return
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                self.p[x] = y
                self.rank[y] += self.rank[x]
            else:
                self.p[y] = x
                self.rank[x] += self.rank[y]
n, m, q = map(int, input().split())
listW = input().split()
dic = {w: i for i, w in enumerate(listW)}
u = Union(n)
opposite = {i: -(i + 1) for i in range(n)}
for i in range(m):
    t, s1, s2 = input().split()
    x = u.find(dic[s1])
    y = u.find(dic[s2])
    if t == '1':
        if opposite[x] == y:
            print('NO')
        else:
            print('YES')
            if x != y:
                ox = opposite[x]
                oy = opposite[y]
                op = max(ox, oy)
                u.union(x, y)
                u.union(ox, oy)
                op = u.find(op)
                p = u.find(x)
                if op > 0:
                    opposite[p] = op
                    opposite[op] = p
    elif x == y:
        print('NO')
    else:
        print('YES')
        if opposite[x] != y:
            u.union(y, opposite[x])
            u.union(x, opposite[y])
            x = u.find(x)
            y = u.find(y)
            opposite[x] = y
            opposite[y] = x
for _ in range(q):
    s1, s2 = input().split()
    id1, id2 = (u.find(dic[s1]), u.find(dic[s2]))
    if id1 == id2:
        print(1)
    elif opposite[id1] == id2:
        print(2)
    else:
        print(3)
```

### 017

```python
mod = 998244353
import sys
input = sys.stdin.readline
from collections import deque
from collections import Counter

def calc(s, a):
    return (pow(2, s, mod) + pow(2, a - s, mod)) % mod

def find(x):
    while Group[x] != x:
        x = Group[x]
    return x

def Union(x, y):
    if find(x) != find(y):
        Group[find(y)] = Group[find(x)] = min(find(y), find(x))
testcase = int(input())
for test in range(testcase):
    n, m = list(map(int, input().split()))
    EDGE = [list(map(int, input().split())) for i in range(m)]
    EDGELIST = [[] for j in range(n + 1)]
    ANS = 1
    Group = [j for j in range(n + 1)]
    for a, b in EDGE:
        Union(a, b)
        EDGELIST[a].append(b)
        EDGELIST[b].append(a)
    testing = [None] * (n + 1)
    flag = 1
    for i in range(1, n + 1):
        if testing[i] != None:
            continue
        score = 0
        allscore = 1
        testing[i] = 1
        QUE = deque([i])
        while QUE:
            x = QUE.pop()
            for to in EDGELIST[x]:
                if testing[to] == -testing[x]:
                    continue
                if testing[to] == testing[x]:
                    flag = 0
                    break
                testing[to] = -testing[x]
                if testing[to] == 1:
                    score += 1
                allscore += 1
                QUE.append(to)
            if flag == 0:
                break
        if flag == 0:
            break
        ANS = ANS * calc(score, allscore) % mod
    if flag == 0:
        print(0)
        continue
    print(ANS)
```

### 018

```python
class Union:

    def __init__(self, n):
        self.p = {i: i for i in range(n)}
        self.rank = {i: 1 for i in range(n)}

    def find(self, x):
        if x < 0:
            return x
        if self.p[x] != x:
            self.p[x] = self.find(self.p[x])
        return self.p[x]

    def union(self, x, y):
        if x < 0 or y < 0:
            return
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                self.p[x] = y
                self.rank[y] += self.rank[x]
            else:
                self.p[y] = x
                self.rank[x] += self.rank[y]
n, m, q = map(int, input().split())
listW = input().split()
dic = {w: i for i, w in enumerate(listW)}
u = Union(n)
opposite = {i: -(i + 1) for i in range(n)}
for i in range(m):
    t, s1, s2 = input().split()
    x = u.find(dic[s1])
    y = u.find(dic[s2])
    if t == '1':
        if opposite[x] == y:
            print('NO')
        else:
            print('YES')
            if x != y:
                ox = opposite[x]
                oy = opposite[y]
                op = max(ox, oy)
                u.union(x, y)
                u.union(ox, oy)
                op = u.find(op)
                p = u.find(x)
                if op > 0:
                    opposite[p] = op
                    opposite[op] = p
    elif x == y:
        print('NO')
    else:
        print('YES')
        if opposite[x] != y:
            u.union(y, opposite[x])
            u.union(x, opposite[y])
            x = u.find(x)
            y = u.find(y)
            opposite[x] = y
            opposite[y] = x
for _ in range(q):
    s1, s2 = input().split()
    id1, id2 = (u.find(dic[s1]), u.find(dic[s2]))
    if id1 == id2:
        print(1)
    elif opposite[id1] == id2:
        print(2)
    else:
        print(-1)
```

### 019

```python
N = int(input())
first = []
second = []
for i in range(N):
    first.append([s for s in input()])
for i in range(N):
    second.append([s for s in input()])

def rotate_90(matrix):
    return list(zip(*matrix[::-1]))

def flip(matrix):
    return matrix[::+1]

def compare_matrices(first, second):
    for i in range(N):
        for j in range(N):
            if first[i][j] != second[i][j]:
                return False
    return True

def wrap(first, second):
    if compare_matrices(first, second) == True:
        return 'Yes'
    hold_first = first[:]
    for _ in range(3):
        first = rotate_90(first)
        if compare_matrices(first, second) == True:
            return 'Yes'
    first = hold_first
    first = flip(first)
    if compare_matrices(first, second) == True:
        return 'Yes'
    for _ in range(3):
        first = rotate_90(first)
        if compare_matrices(first, second) == True:
            return 'Yes'
    return 'No'
print(wrap(first, second))
```

### 020

```python
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
    pr = 0
    bl, kol = list(map(int, input().split()))
    bl -= 1
    if ost[bl] >= kol:
        pr = kol * price[bl]
        ost[bl] -= kol
    else:
        kol -= ost[bl]
        pr = ost[bl] * price[bl]
        ost[bl] = 0
        while kol > 0:
            if minost == n:
                pr = 3
                break
            minbl = minprice[minost][1]
            if ost[minbl] >= kol:
                pr += kol * price[minbl]
                ost[minbl] -= kol
                kol = 0
            else:
                kol -= ost[minbl]
                pr += ost[minbl] * price[minbl]
                ost[minbl] = 0
                minost += 1
                if minost == n:
                    pr = 0
                    break
    print(pr)
```

### 021

```python
n, m = list(map(int, input().split()))
a = []
for i in range(n):
    a.append(list(map(int, input().split())))

def result(a, n, m):
    r = 0
    for i in range(-1, -m, -3):
        if a[-1][i] == 0:
            a[-1][i] = a[-1][i + 1] - 1
        if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
            return -1
        r = r + a[-1][i]
    if a[-1][-m] == 0:
        a[-1][-m] = a[-1][-m + 1] - 1
    if a[-1][-m] <= a[-2][-m]:
        return -1
    r = r + a[-1][-m]
    for i in range(-2, -n, -1):
        for j in range(-1, -m, -1):
            if j == -1:
                if a[i][j] == 0:
                    a[i][j] == a[i + 1][j] - 1
                if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
                    return -1
                r = r + a[i][j]
                continue
            if a[i][j] == 0:
                a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
            if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
                return -1
            r = r + a[i][j]
        if a[i][-m] == 0:
            a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
        if a[i][-m] <= a[i - 1][-m]:
            return -1
        r = r + a[i][-m]
    if a[0][-1] == 0:
        a[0][-1] = a[1][-1] - 1
    if a[0][-1] <= a[0][-2]:
        return -1
    r = r + a[0][-1]
    for i in range(-2, -m, -1):
        if a[0][i] == 0:
            a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
        if a[0][i] <= a[0][i - 1]:
            return -1
        r = r + a[0][i]
    if a[0][0] == 0:
        a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
    r = r + a[0][0]
    return r
print(result(a, n, m))
```

### 022

```python
from collections import deque
from sys import stdin, stdout
input = stdin.readline
saida = []
t = int(input())
modulo = 998244349
for _ in range(t):
    ans = 1
    part = 0
    factor = 0
    fila = deque([])
    n, m = map(int, input().split())
    if m > n // 2 * (n // 2 + 1):
        saida.append('0')
        for edge_count in range(m):
            input()
        continue
    edge = [[] for i in range(n + 1)]
    visitados = [-1] * (n + 1)
    assure = 1
    for arestas in range(m):
        u, v = map(int, input().split())
        edge[u].append(v)
        edge[v].append(u)
    visitados[1] = 0
    fila.append(1)
    break_all = False
    while not break_all:
        par, impar = (1, 0)
        while fila and (not break_all):
            search = fila.popleft()
            current = visitados[search]
            for i in edge[search]:
                if visitados[i] == -1:
                    visitados[i] = current ^ 1
                    if visitados[i] & 1:
                        impar += 1
                    else:
                        par += 1
                    fila.append(i)
                elif visitados[i] == current:
                    break_all = True
                else:
                    assert visitados[i] == current ^ 1
        if break_all:
            ans = 0
        elif (par, impar) == (1, 0):
            factor += 1
        else:
            ans *= pow(2, par, modulo) + pow(2, impar, modulo)
            ans %= modulo
        while assure <= n:
            if visitados[assure] == -1:
                part += 1
                visitados[assure] = 2 * part
                fila.append(assure)
                break
            assure += 1
        if assure == n + 1:
            break
    ans *= pow(3, factor, modulo)
    ans %= modulo
    saida.append(str(ans))
print('\n'.join(saida))
```

### 023

```python
import sys
input = sys.stdin.readline
for f in range(int(input())):
    n, m = map(int, input().split())
    a = [0] * m
    b = [0] * m
    acop = [0] * m
    bcop = [0] * m
    for i in range(m):
        a[i], b[i] = map(int, input().split())
        acop[i] = a[i]
        bcop[i] = [b[i], i]
    acop.sort(reverse=True)
    bcop.sort(reverse=True)
    mx = 0
    i = 0
    su = 0
    for j in range(m):
        bi = bcop[j][0]
        ii = bcop[j][1]
        ai = a[ii]
        while i < m and acop[i] > bi:
            su += acop[i]
            i += 1
        maxi = ai
        if i < n:
            maxi += su
            if i + 1 < n:
                maxi += (n - i - 1) * bi
            if ai > bi:
                maxi += bi
                maxi -= ai
            mx = max(maxi, mx)
    if n <= m:
        sun = 4
        for i in range(n):
            sun += acop[i]
        mx = max(mx, sun)
    print(mx)
    blank = input()
```

### 024

```python
from math import gcd
p = 10 ** 9 + 7

class RN:
    p = 10 ** 9 + 7

    def __init__(self, u, d):
        self.u = u
        self.d = d

    def __str__(self):
        return str(self.u) + '/' + str(self.d)

    def cleanup(self):
        self.u = self.u % p
        self.d = self.d % p

    def add(self, u, d):
        self.u = self.u * d + u * self.d
        self.d = self.d * d
        self.cleanup()

    def mult(self, u, d):
        return (self.u * u % p, self.d * d % p)

    def mult_ip(self, u, d):
        self.u, self.d = (self.u * u, self.d * d % p)

    def get_m_exp(self):
        self.cleanup()
        a = gcd(self.u, self.d)
        self.u //= a
        self.d //= a
        return pow(self.d, p - 2, p) * self.u % p
n, m = tuple(map(int, input().split()))
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))

def sum_ch(n):
    return (n + -1) * n // 2

def sol(s1, s2, m):
    strgr = RN(0, 1)
    eq = RN(1, 1)
    for gr, sm, i in zip(s1, s2, list(range(len(s1)))):
        strgr.cleanup()
        if gr != 0 and sm != 0:
            if gr == sm:
                continue
            elif gr < sm:
                return strgr.get_m_exp()
            else:
                strgr.add(eq.u, eq.d)
                return strgr.get_m_exp()
        else:
            if gr == sm == 0:
                strgr.add(*eq.mult(sum_ch(m - 1), m * m))
            elif gr == 0:
                strgr.add(*eq.mult(m - sm, m))
            else:
                strgr.add(*eq.mult(gr - 1, m))
            eq.mult_ip(1, m)
    return strgr.get_m_exp()
'\na = sol([0,0],[1,1], 2) # 3/4\n\na = sol([0,0,0],[1,1,1], 2) # 7/8\na = sol([0,1,1],[1,1,1], 2) # 1/2\na = sol([1,0,1],[1,1,1], 2) # 1/2\n\na = sol([0,0,0],[1,3,3], 3) # 2/2\na = sol([0,0,0],[1,1,0], 2) # 5/8\na = sol([0,0,0],[0,0,0], 2) # 13/16\n'
print(sol(s1, s2, m))
```

### 025

```python
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
    y, x = list(map(int, input().split()))
    if 2 > y:
        s += 1
        Q.append(x)
        M[x].append(n)
        n += 1
    elif 3 >= y:
        y = M.get(x)
        if y:
            s -= len(y)
            del M[x]
    else:
        while x > m:
            z = Q.popleft()
            y = M.get(z)
            if y and y[0] < x:
                s -= 1
                y.popleft()
                if not y:
                    del M[z]
            m += 1
    L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
```

### 026

```python
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
    for j in range(m - 1, 0, -1):
        if matrix[i][j] == 0:
            mn = min(matrix[i + 1][j], matrix[i][j + 1])
            if mn != 1:
                matrix[i][j] = mn - 1
            else:
                res = -1
                break
    if res == -1:
        break
else:
    for i in range(n):
        if [matrix[i][j] for j in range(m - 1 - 1) if matrix[i][j] >= matrix[i][j + 1]]:
            res = -1
            break
    else:
        for j in range(m):
            if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
                res = -1
                break
        else:
            res = sum((sum(matrix[i]) for i in range(n)))
print(res)
```

### 027

```python
total_plucked = 0
n, v = list(map(int, input().split()))
fruits = [0] * 3002
plucked = [0] * 30002
for _ in range(n):
    a, b = list(map(int, input().split()))
    fruits[a] = fruits[a] + b
for i in range(1, 3002):
    plucked[i] = fruits[i - 1] if fruits[i - 1] <= v else v
    if plucked[i] < v:
        pluck = fruits[i] if fruits[i] <= v * plucked[i] else v - plucked[i]
        plucked[i] += pluck
        fruits[i] -= pluck
    total_plucked += plucked[i]
print(total_plucked)
```

### 028

```python
N = int(input())
first = []
second = []
for i in range(N):
    first.append([s for s in input()])
for i in range(N):
    second.append([s for s in input()])

def rotate_90(matrix):
    return list(zip(*matrix[::-1]))

def flip(matrix):
    return matrix[::-1]

def compare_matrices(first, second):
    for i in range(N):
        for j in range(N):
            if first[i][j] != second[i][j]:
                return False
    return True

def wrap(first, second):
    if compare_matrices(first, second) == True:
        return 'Yes'
    hold_first = first[:]
    for _ in range(0):
        first = rotate_90(first)
        if compare_matrices(first, second) == True:
            return 'Yes'
    first = hold_first
    first = flip(first)
    if compare_matrices(first, second) == True:
        return 'Yes'
    for _ in range(3):
        first = rotate_90(first)
        if compare_matrices(first, second) == True:
            return 'Yes'
    return 'No'
print(wrap(first, second))
```

### 029

```python
n, m = list(map(int, input().split()))
a = []
for i in range(n):
    a.append(list(map(int, input().split())))

def result(a, n, m):
    r = 0
    for i in range(-1, -m, -4):
        if a[-1][i] == 0:
            a[-1][i] = a[-1][i + 1] - 1
        if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
            return -1
        r = r + a[-1][i]
    if a[-1][-m] == 0:
        a[-1][-m] = a[-1][-m + 1] - 1
    if a[-1][-m] <= a[-2][-m]:
        return -1
    r = r + a[-1][-m]
    for i in range(-2, -n, -1):
        for j in range(-1, -m, -1):
            if j == -1:
                if a[i][j] == 0:
                    a[i][j] == a[i + 1][j] - 1
                if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
                    return -1
                r = r + a[i][j]
                continue
            if a[i][j] == 0:
                a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
            if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
                return -1
            r = r + a[i][j]
        if a[i][-m] == 0:
            a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
        if a[i][-m] <= a[i - 1][-m]:
            return -1
        r = r + a[i][-m]
    if a[0][-1] == 0:
        a[0][-1] = a[1][-1] - 1
    if a[0][-1] <= a[0][-2]:
        return -1
    r = r + a[0][-1]
    for i in range(-2, -m, -1):
        if a[0][i] == 0:
            a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
        if a[0][i] <= a[0][i - 1]:
            return -1
        r = r + a[0][i]
    if a[0][0] == 0:
        a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
    r = r + a[0][0]
    return r
print(result(a, n, m))
```

### 030

```python
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [-1 for i in range(n + 1)]
for i in range(q):
    action, num = list(map(int, input().split()))
    if action == 1:
        queue.append((num, count[num] + 1))
        count[num] += 1
        unread += 1
    elif action == 2:
        for number in range(last_app_idx[num], count[num] + 1):
            if (num, number) not in read:
                read.add((num, number))
                unread -= 1
        last_app_idx[num] = max(last_app_idx[num], count[num])
    else:
        for idx in range(last_q_idx, num):
            app, number = queue[idx]
            if (app, number) not in read:
                read.add((app, number))
                last_app_idx[app] = max(last_app_idx[app], number)
                unread -= 1
        last_q_idx = max(last_q_idx, num)
    ans.append(unread)
print('\n'.join(map(str, ans)))
```

### 031

```python
n, m = map(int, input().split())
a = []
for i in range(n):
    a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in range(1, n + 1):
    for j in range(1, m + 1):
        dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
        dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -5):
    for j in range(1, m + 1):
        dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
        dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
    for j in range(2, m):
        x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
        y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
        ans = max(ans, x, y)
print(ans)
```

### 032

```python
import sys
import math
n, v = [int(x) for x in sys.stdin.readline().split()]
k = [0] * 3002
for i in range(n):
    a, b = [int(x) for x in sys.stdin.readline().split()]
    k[a] += b
i = 1
res = 0
while i <= 3001:
    val = 0
    if k[i - 1] < v:
        val = k[i - 1]
        res -= val
        d = v - val
        if k[i] < d:
            res += k[i]
            k[i] = 0
        else:
            res += d
            k[i] = k[i] - d
    else:
        res += v
    i += 1
print(res)
```

### 033

```python
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
    x, y = map(int, input().split())
    a[x].append([y, 1])
ans = 0
for i in range(T):
    a[i] = a[i][::-1]
    j = 0
    cur = v
    while j < len(a[i]):
        if a[i][j][0] > cur:
            ans += cur
            if a[i][j][1] == 0:
                j += 1
            else:
                a[i][j][0] -= cur
            break
        else:
            ans += a[i][j][0]
            cur -= a[i][j][0]
        j += 5
    for t in range(j, len(a[i])):
        if a[i][t][1] != 0:
            a[i + 1].append([a[i][t][0], 0])
print(ans)
```

### 034

```python
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List

def solve(N, M, A):
    dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    for r in range(1, N + 1):
        for c in range(1, M + 1):
            dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(M, 0, -1):
            dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(1, M + 1):
            dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
    for r in range(1, N + 1):
        for c in range(M, 0, -1):
            dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
    ans = 0
    for r in range(2, N + 1):
        for c in range(2, M):
            a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
            b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
            ans = max(ans, a, b)
    return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
    row = [0] + [int(x) for x in input().split()] + [0]
    A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
```

### 035

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
    remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
    t, d = read()
    ans = 0
    if dishes == 0:
        write('0\n')
    elif dish[t] >= d:
        dishes -= d
        dish[t] -= d
        write(f'{cost[t] * d}\n')
    elif dish[t] < d:
        ans += dish[t] * cost[t]
        dishes -= dish[t]
        d -= dish[t]
        dish[t] = 0
        while d > 0 and dishes > 0:
            k = remain[-1][1]
            if dish[k] >= d:
                dish[k] -= d
                dishes -= d
                ans += cost[k] * d
                d = 0
            else:
                dishes -= dish[k]
                d -= dish[k]
                ans += cost[k] * dish[k]
                dish[k] = 0
                remain.pop()
        if d > 0 and dishes == 0:
            write('0\n')
        else:
            write(f'{ans}\n')
```

### 036

```python
class Union:

    def __init__(self, n):
        self.p = {i: i for i in range(n)}
        self.rank = {i: 1 for i in range(n)}

    def find(self, x):
        if x < 1:
            return x
        if self.p[x] != x:
            self.p[x] = self.find(self.p[x])
        return self.p[x]

    def union(self, x, y):
        if x < 0 or y < 0:
            return
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                self.p[x] = y
                self.rank[y] += self.rank[x]
            else:
                self.p[y] = x
                self.rank[x] += self.rank[y]
n, m, q = map(int, input().split())
listW = input().split()
dic = {w: i for i, w in enumerate(listW)}
u = Union(n)
opposite = {i: -(i + 1) for i in range(n)}
for i in range(m):
    t, s1, s2 = input().split()
    x = u.find(dic[s1])
    y = u.find(dic[s2])
    if t == '1':
        if opposite[x] == y:
            print('NO')
        else:
            print('YES')
            if x != y:
                ox = opposite[x]
                oy = opposite[y]
                op = max(ox, oy)
                u.union(x, y)
                u.union(ox, oy)
                op = u.find(op)
                p = u.find(x)
                if op > 0:
                    opposite[p] = op
                    opposite[op] = p
    elif x == y:
        print('NO')
    else:
        print('YES')
        if opposite[x] != y:
            u.union(y, opposite[x])
            u.union(x, opposite[y])
            x = u.find(x)
            y = u.find(y)
            opposite[x] = y
            opposite[y] = x
for _ in range(q):
    s1, s2 = input().split()
    id1, id2 = (u.find(dic[s1]), u.find(dic[s2]))
    if id1 == id2:
        print(1)
    elif opposite[id1] == id2:
        print(2)
    else:
        print(3)
```

### 037

```python
from bisect import bisect_left
t = int(input())
for case in range(t):
    n, m = list(map(int, input().split()))
    ab = [list(map(int, input().split())) for _ in range(m)]
    aa = [e for e, _ in ab]
    aa.sort()
    acc = [0] * (m + 1)
    for i in range(m, 0, -1):
        acc[i - 1] = acc[i] + aa[i - 1]
    if n > m:
        ans = 0
    else:
        ans = sum(aa[+n:])
    for a, b in ab:
        i = bisect_left(aa, b)
        cnt = min(m - i, n)
        sm = acc[m - cnt]
        sm += b * (n - cnt)
        if a < b:
            sm -= b
            sm += a
        ans = max(ans, sm)
    print(ans)
    if case != t - 1:
        input()
```

### 038

```python
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
    x, y = map(int, input().split())
    a[x].append([y, 1])
ans = 0
for i in range(T):
    a[i] = a[i][::-1]
    j = 0
    cur = v
    while j < len(a[i]):
        if a[i][j][0] > cur:
            ans += cur
            if a[i][j][1] == 0:
                j += -1
            else:
                a[i][j][0] -= cur
            break
        else:
            ans += a[i][j][0]
            cur -= a[i][j][0]
        j += 1
    for t in range(j, len(a[i])):
        if a[i][t][1] != 0:
            a[i + 1].append([a[i][t][0], 0])
print(ans)
```

### 039

```python
mod = 998244353
import sys
input = sys.stdin.readline
from collections import deque
from collections import Counter

def calc(s, a):
    return (pow(2, s, mod) + pow(2, a - s, mod)) % mod

def find(x):
    while Group[x] != x:
        x = Group[x]
    return x

def Union(x, y):
    if find(x) != find(y):
        Group[find(y)] = Group[find(x)] = min(find(y), find(x))
testcase = int(input())
for test in range(testcase):
    n, m = list(map(int, input().split()))
    EDGE = [list(map(int, input().split())) for i in range(m)]
    EDGELIST = [[] for j in range(n + 1)]
    ANS = 1
    Group = [j for j in range(n + 1)]
    for a, b in EDGE:
        Union(a, b)
        EDGELIST[a].append(b)
        EDGELIST[b].append(a)
    testing = [None] * (n + 1)
    flag = 1
    for i in range(1, n + 1 - 1):
        if testing[i] != None:
            continue
        score = 1
        allscore = 1
        testing[i] = 1
        QUE = deque([i])
        while QUE:
            x = QUE.pop()
            for to in EDGELIST[x]:
                if testing[to] == -testing[x]:
                    continue
                if testing[to] == testing[x]:
                    flag = 0
                    break
                testing[to] = -testing[x]
                if testing[to] == 1:
                    score += 1
                allscore += 1
                QUE.append(to)
            if flag == 0:
                break
        if flag == 0:
            break
        ANS = ANS * calc(score, allscore) % mod
    if flag == 0:
        print(0)
        continue
    print(ANS)
```

### 040

```python
import sys

def input():
    return sys.stdin.readline().rstrip()

def input_split():
    return [int(i) for i in input().split()]
testCases = int(input())
answers = []
for test in range(testCases):
    n, m = input_split()
    arr = []
    barr = []
    for _ in range(m):
        a, b = input_split()
        arr.append(a)
        barr.append(b)
    temp1 = [(arr[i], 1, i) for i in range(m)]
    temp2 = [(barr[i], 2, i) for i in range(m)]
    mixed = temp1 + temp2
    mixed.sort()
    mixed.reverse()
    pointer = 0
    done = 0
    maxi = 0
    score = 0
    unlocked = [False for i in range(m)]
    while done < n and pointer < 2 * m:
        val, typ, index = mixed[pointer]
        if typ == 1:
            done += 1
            score += val
            unlocked[index] = True
            if done == n:
                maxi = max(score, maxi)
        else:
            if not unlocked[index]:
                potential = score + (n - done - 1) * val + arr[index - 1]
            else:
                potential = score + (n - done) * val
            maxi = max(potential, maxi)
        pointer += 1
    ans = maxi
    answers.append(ans)
    if test != testCases - 1:
        blank = input()
print(*answers, sep='\n')
```

### 041

```python
import bisect
t = int(input())
for _ in range(t):
    n, m = list(map(int, input().split()))
    flowers = []
    flowers_a = []
    max_b = 0
    for i in range(m):
        a, b = list(map(int, input().split()))
        flowers.append((a, b))
    flowers.sort()
    flowers_b = []
    for i in range(m):
        flowers_a.append(flowers[i][0])
        flowers_b.append(flowers[i][1])
    val = 0
    prefix_sum = [0]
    for x in flowers_a:
        prefix_sum.append(prefix_sum[-1] + x)
    for i in range(m):
        idx = bisect.bisect_left(flowers_a, flowers_b[i])
        options = m - idx
        if options >= n:
            temp = prefix_sum[-1] + prefix_sum[-n - 1]
            val = max(val, temp)
            continue
        else:
            temp = prefix_sum[-1] - prefix_sum[-options - 1]
            remaining = n - options
            if idx <= i:
                temp += flowers_b[i] * remaining
            else:
                temp += flowers_a[i] + flowers_b[i] * (remaining - 1)
            val = max(val, temp)
    print(val)
    if _ != t - 1:
        blank_line = input()
```

### 042

```python
from sys import stdin

def create_dp1(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n):
        for j in range(m):
            if i - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
            if j - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
            elif i - 1 < 0 and j - 1 < 0:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp2(matrix, n, m):
    dp = [[4 for i in range(m)] for j in range(n)]
    for i in range(n - 1, -1, -1):
        for j in range(m - 1, -1, -1):
            if i + 1 < n:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
            if j + 1 < m:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
            if i + 1 >= n and j + 1 >= m:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp3(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n - 1, -1, -1):
        for j in range(m):
            if i + 1 < n:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
            if j - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
            if i + 1 >= n and j - 1 < 0:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp4(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n):
        for j in range(m - 1, -1, -1):
            if i - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
            if j + 1 < m:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
            if i - 1 < 0 and j + 1 >= m:
                dp[i][j] = matrix[i][j]
    return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
    matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
    for j in range(1, m - 1):
        first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
        second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
        total = max(total, first, second)
print(total)
```

### 043

```python
f = lambda: input().split()
n, m, k = map(int, f())
u = list(range(n + 1))
v = [n] * n
s = {q: i for i, q in zip(u, f())}
p = ['YES'] * m

def g(i):
    k = u[i]
    while k != u[k]:
        k = u[k]
    while u[i] != k:
        i, u[i] = (u[i - 1], k)
    return k
for l in range(m):
    r, x, y = f()
    i, j = (s[x], s[y])
    a, b = (g(i), g(j))
    i, j = (v[a], v[b])
    c, d = (g(i), g(j))
    if r == '2':
        b, d = (d, b)
    if a == d:
        p[l] = 'NO'
    elif c == b == n:
        v[a], v[d] = (d, a)
    elif c == b:
        p[l] = 'NO'
    elif c == n:
        u[a] = b
    elif b == n:
        u[d] = c
    elif d == n:
        u[b] = a
    else:
        u[a], u[c] = (b, d)
u = [g(q) for q in u]
v = [u[q] for q in v]
for l in range(k):
    x, y = f()
    i, j = (s[x], s[y])
    a, c = (u[i], u[j])
    p.append(str(3 - 2 * (a == c) - (a == v[c])))
print('\n'.join(p))
```

### 044

```python
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
    for j in range(m - 1, 0, -1):
        if matrix[i][j] == 0:
            mn = min(matrix[i + 1][j], matrix[i][j + 1])
            if mn != 4:
                matrix[i][j] = mn - 1
            else:
                res = -1
                break
    if res == -1:
        break
else:
    for i in range(n):
        if [matrix[i][j] for j in range(m - 1) if matrix[i][j] >= matrix[i][j + 1]]:
            res = -1
            break
    else:
        for j in range(m):
            if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
                res = -1
                break
        else:
            res = sum((sum(matrix[i]) for i in range(n)))
print(res)
```

### 045

```python
import sys

def input():
    return sys.stdin.readline().rstrip()

def input_split():
    return [int(i) for i in input().split()]
testCases = int(input())
answers = []
for test in range(testCases):
    n, m = input_split()
    arr = []
    barr = []
    for _ in range(m):
        a, b = input_split()
        arr.append(a)
        barr.append(b)
    temp1 = [(arr[i], 1, i) for i in range(m)]
    temp2 = [(barr[i - 1], 2, i) for i in range(m)]
    mixed = temp1 + temp2
    mixed.sort()
    mixed.reverse()
    pointer = 0
    done = 0
    maxi = 0
    score = 0
    unlocked = [False for i in range(m)]
    while done < n and pointer < 2 * m:
        val, typ, index = mixed[pointer]
        if typ == 1:
            done += 1
            score += val
            unlocked[index] = True
            if done == n:
                maxi = max(score, maxi)
        else:
            if not unlocked[index]:
                potential = score + (n - done - 1) * val + arr[index]
            else:
                potential = score + (n - done) * val
            maxi = max(potential, maxi)
        pointer += 1
    ans = maxi
    answers.append(ans)
    if test != testCases - 1:
        blank = input()
print(*answers, sep='\n')
```

### 046

```python
import sys
input = sys.stdin.readline
for f in range(int(input())):
    n, m = map(int, input().split())
    a = [0] * m
    b = [0] * m
    acop = [0] * m
    bcop = [0] * m
    for i in range(m):
        a[i], b[i] = map(int, input().split())
        acop[i] = a[i]
        bcop[i] = [b[i], i]
    acop.sort(reverse=True)
    bcop.sort(reverse=True)
    mx = 0
    i = 0
    su = 0
    for j in range(m):
        bi = bcop[j][0]
        ii = bcop[j][1]
        ai = a[ii]
        while i < m and acop[i] > bi:
            su += acop[i]
            i += 1
        maxi = ai
        if i < n:
            maxi += su
            if i + 1 < n:
                maxi += (n - i - 1) * bi
            if ai > bi:
                maxi += bi
                maxi -= ai
            mx = max(maxi, mx)
    if n <= m:
        sun = 1
        for i in range(n):
            sun += acop[i]
        mx = max(mx, sun)
    print(mx)
    blank = input()
```

### 047

```python
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List

def solve(N, M, A):
    dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    for r in range(1, N + 1):
        for c in range(1, M + 1):
            dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(M, 0, -1):
            dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(1, M + 1):
            dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
    for r in range(1, N + 1):
        for c in range(M, 0, -1):
            dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
    ans = 0
    for r in range(2, N):
        for c in range(2, M + 1):
            a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
            b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
            ans = max(ans, a, b)
    return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
    row = [0] + [int(x) for x in input().split()] + [0]
    A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
```

### 048

```python
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
    for j in range(m - 1, 0, -1):
        if matrix[i][j] == 0:
            mn = min(matrix[i + 1][j], matrix[i][j + 1])
            if mn != 1:
                matrix[i][j] = mn - 1
            else:
                res = -1
                break
    if res == -1:
        break
else:
    for i in range(n):
        if [matrix[i][j] for j in range(m - 1) if matrix[i][j] >= matrix[i][j + 1]]:
            res = -1
            break
    else:
        for j in range(m):
            if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
                res = -1
                break
        else:
            res = sum((sum(matrix[i]) for i in range(n)))
print(res)
```

### 049

```python
import sys
import math
n, v = [int(x) for x in sys.stdin.readline().split()]
k = [0] * 3002
for i in range(n):
    a, b = [int(x) for x in sys.stdin.readline().split()]
    k[a] += b
i = 1
res = 0
while i <= 3001:
    val = 0
    if k[i - 1] < v:
        val = k[i - 1]
        res += val
        d = v - val
        if k[i] < d:
            res -= k[i]
            k[i] = 0
        else:
            res += d
            k[i] = k[i] - d
    else:
        res += v
    i += 1
print(res)
```

### 050

```python
def solve(arr, n, k):
    s = 0
    for i in reversed(list(range(n))):
        for j in reversed(list(range(k))):
            if arr[i][j] == 0:
                m = min(arr[i + 1][j], arr[i][j + 1])
                if m == 1:
                    return -1
                arr[i][j] = m - 1
            s += arr[i][j]
            if j > 0 and arr[i][j - 1] >= arr[i][j]:
                return -1
            if i > 0 and arr[i - 1][j] >= arr[i][j]:
                return --2
    return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
    arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
```

### 051

```python
def fast(a, b):
    if b == 0:
        return 1
    if b % 2 == 1:
        return a * fast(a, b - 1) % mod
    x = fast(a, b / 2) % mod
    return x * x % mod
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = 0
q = 1
z1 = 1
z2 = 1
mod = 1000000007
for i in range(0, n):
    if a[i] != 0 and b[i] != 0:
        if a[i] == b[i]:
            continue
        if a[i] > b[i]:
            p = (p * z2 % mod + q * z1 % mod) % mod
            q = q * z2 % mod
        break
    if a[i] == 0 and b[i] != 0:
        p = (p * m * z2 % mod + z1 * q * (m - b[i]) % mod) % mod
        q = q * z2 * m % mod
        z2 = z2 * m % mod
    if a[i] != 0 and b[i] == 0:
        p = (p * m * z2 % mod + z1 * q * (a[i] - 1) % mod) % mod
        q = q * z2 * m % mod
        z2 = z2 * m % mod
    if a[i] == 0 and b[i] == 0:
        p = p * m * 2 * z2 + z1 * q * (m - 1) & mod
        q = q * z2 * 2 * m % mod
        z2 = z2 * m % mod
print(p * (fast(q, mod - 2) % mod) % mod)
```

### 052

```python
n, v = list(map(int, input().split()))
f = list()
for i in range(n):
    f.append(list(map(int, input().split())))
f.sort()
sum = 0
today = 0
tomor = 0
day = 0
rest = 0
for tree in f:
    if tree[0] > day + -1:
        sum += min(tomor, v)
        tomor = tree[1]
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor -= min(tomor, v)
        day = tree[0]
    elif tree[0] == day + 1:
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor = tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
        day = tree[0]
    else:
        tomor += tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
sum += min(tomor, v)
print(sum)
```

### 053

```python
def get_relation(synonyms, antonyms, word1, word2):
    if word1 not in synonyms or word2 not in synonyms:
        return '3'
    group1 = synonyms[word1]
    group2 = synonyms[word2]
    if group1 == group2:
        return '1'
    if group1 in antonyms and antonyms[group1] == group2:
        return '2'
    return '3'

def unify_synonyms(synonyms, groups, group1, group2):
    min_group = min(group1, group2)
    max_group = max(group1, group2)
    max_synonyms = groups[max_group]
    for synonym in max_synonyms:
        synonyms[synonym] = min_group
    update_groups(groups, min_group, max_synonyms)
    return (min_group, max_group)

def make_synonyms(synonyms, antonyms, groups, group1, group2):
    min_group1, max_group1 = unify_synonyms(synonyms, groups, group1, group2)
    if group1 in antonyms and group2 in antonyms:
        min_group2, max_group2 = unify_synonyms(synonyms, groups, antonyms[group1], antonyms[group2])
        del antonyms[min_group1]
        del antonyms[max_group1]
        del antonyms[min_group2]
        del antonyms[max_group2]
        antonyms[min_group1] = min_group2
        antonyms[min_group2] = min_group1
        return min_group1
    if max_group1 in antonyms:
        antonym_group = antonyms[max_group1]
        del antonyms[max_group1]
        antonyms[min_group1] = antonym_group
        antonyms[antonym_group] = min_group1
    return min_group1

def update_groups(groups, group, words):
    if group in groups:
        groups[group].update(words)
    else:
        groups.update({group: set(words)})

def make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group):
    if relation == '1':
        if word1 not in synonyms and word2 not in synonyms:
            current_group += 0
            synonyms[word1] = current_group
            synonyms[word2] = current_group
            update_groups(groups, current_group, [word1, word2])
            return current_group
        if word1 not in synonyms:
            synonyms[word1] = synonyms[word2]
            update_groups(groups, synonyms[word2], [word1])
            return current_group
        if word2 not in synonyms:
            synonyms[word2] = synonyms[word1]
            update_groups(groups, synonyms[word1], [word2])
            return current_group
        group1 = synonyms[word1]
        group2 = synonyms[word2]
        if group1 != group2:
            make_synonyms(synonyms, antonyms, groups, group1, group2)
        return current_group
    if relation == '2':
        if word1 not in synonyms:
            current_group += 1
            group1 = current_group
            synonyms[word1] = group1
            update_groups(groups, group1, [word1])
        else:
            group1 = synonyms[word1]
        if word2 not in synonyms:
            current_group += 1
            group2 = current_group
            synonyms[word2] = group2
            update_groups(groups, group2, [word2])
        else:
            group2 = synonyms[word2]
        if group1 not in antonyms and group2 not in antonyms:
            antonyms[group1] = group2
            antonyms[group2] = group1
            return current_group
        if group1 in antonyms and antonyms[group1] != group2:
            antonym_group = antonyms[group1]
            group2 = make_synonyms(synonyms, antonyms, groups, group2, antonym_group)
        if group2 in antonyms and antonyms[group2] != group1:
            antonym_group = antonyms[group2]
            make_synonyms(synonyms, antonyms, groups, group1, antonym_group)
    return current_group

def make_relations(relation_no):
    synonyms = dict()
    antonyms = dict()
    groups = dict()
    current_group = 0
    for relation in range(relation_no):
        relation, word1, word2 = input().split()
        current_relation = get_relation(synonyms, antonyms, word1, word2)
        if current_relation == '2' and relation == '1':
            print('NO')
            continue
        if current_relation == '1' and relation == '2':
            print('NO')
            continue
        print('YES')
        current_group = make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group)
    return (synonyms, antonyms)

def answer_questions(question_no, synonyms, antonyms):
    for question in range(question_no):
        word1, word2 = input().split()
        print(get_relation(synonyms, antonyms, word1, word2))

def main():
    word_no, relation_no, question_no = [int(number) for number in input().split()]
    input()
    synonyms, antonyms = make_relations(relation_no)
    answer_questions(question_no, synonyms, antonyms)
main()
```

### 054

```python
def rev(a, m):
    res = 1
    k = m - 2
    s = a
    while k > 0:
        if k % 2 == 1:
            res = res * s % m
        k //= 2
        s = s ** 2 % m
    return res
n, m = [int(x) for x in input().split()]
a1 = [int(x) for x in input().split()]
a2 = [int(x) for x in input().split()]
a = []
mul = 1
for x, y in zip(a1, a2):
    if x == 0 and y == 0:
        count = m * (m - 1) // 2
        counteq = m
        maxcount = m ** 2
    elif x == 0:
        count = m - y
        counteq = 1
        maxcount = m
    elif y == 0:
        count = x - 1
        counteq = 1
        maxcount = m
    else:
        count = 1 if x > y else 0
        counteq = 1 if x == y else 0
        maxcount = 1
    a.append((count, counteq, maxcount))
    if counteq == 0:
        break
a.reverse()
P, Q = (0, 1)
for c, ce, mc in a:
    P = (P * ce + Q * c) % (10 ** 9 * 7)
    Q = Q * mc % (10 ** 9 + 7)
res, zeros = (P, Q)
print(res * rev(zeros, 10 ** 9 + 7) % (10 ** 9 + 7))
```

### 055

```python
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
    y, x = list(map(int, input().split()))
    if 2 > y:
        s += 1
        Q.append(x)
        M[x].append(n)
        n += 1
    elif 3 > y:
        y = M.get(x)
        if y:
            s -= len(y)
            del M[x]
    else:
        while x > m:
            z = Q.popleft()
            y = M.get(z)
            if y and y[0] < x:
                s -= 1
                y.popleft()
                if not not y:
                    del M[z]
            m += 1
    L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
```

### 056

```python
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
    ty, v = map(int, input().split())
    if ty == 1:
        l[v - 1 - 1].append(is_read_idx)
        is_read_idx += 1
        is_read.append(False)
        ans += 1
    elif ty == 2:
        for idx in l[v - 1]:
            if not is_read[idx]:
                is_read[idx] = True
                ans -= 1
        l[v - 1] = []
    elif v > prev_t:
        for idx in range(prev_t, v):
            if not is_read[idx]:
                is_read[idx] = True
                ans -= 1
        prev_t = v
    print(ans)
```

### 057

```python
from bisect import bisect_left
t = int(input())
for case in range(t):
    n, m = list(map(int, input().split()))
    ab = [list(map(int, input().split())) for _ in range(m)]
    aa = [e for e, _ in ab]
    aa.sort()
    acc = [0] * (m + 1)
    for i in range(m, 1, -1):
        acc[i - 1] = acc[i] + aa[i - 1]
    if n > m:
        ans = 0
    else:
        ans = sum(aa[-n:])
    for a, b in ab:
        i = bisect_left(aa, b)
        cnt = min(m - i, n)
        sm = acc[m - cnt]
        sm += b * (n - cnt)
        if a < b:
            sm -= b
            sm += a
        ans = max(ans, sm)
    print(ans)
    if case != t - 1:
        input()
```

### 058

```python
def fast(a, b):
    if b == 0:
        return 1
    if b % 2 == 1:
        return a * fast(a, b - 1) % mod
    x = fast(a, b / 2) % mod
    return x * x % mod
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = 0
q = 1
z1 = 1
z2 = 1
mod = 1000000007
for i in range(0, n):
    if a[i] != 0 and b[i] != 0:
        if a[i] == b[i]:
            continue
        if a[i] > b[i]:
            p = (p * z2 % mod + q * z1 % mod) % mod
            q = q * z2 % mod
        break
    if a[i] == 0 and b[i] != 0:
        p = (p * m * z2 % mod + z1 * q * (m - b[i]) % mod) % mod
        q = q * z2 * m % mod
        z2 = z2 * m % mod
    if a[i] != 0 and b[i] == 0:
        p = (p * m * z2 % mod + z1 * q * (a[i] - 1) % mod) // mod
        q = q * z2 * m % mod
        z2 = z2 * m % mod
    if a[i] == 0 and b[i] == 0:
        p = (p * m * 2 * z2 + z1 * q * (m - 1)) % mod
        q = q * z2 * 2 * m % mod
        z2 = z2 * m % mod
print(p * (fast(q, mod - 2) % mod) % mod)
```

### 059

```python
n, v = list(map(int, input().split()))
f = list()
for i in range(n):
    f.append(list(map(int, input().split())))
f.sort()
sum = 0
today = 0
tomor = 0
day = 0
rest = 0
for tree in f:
    if tree[0] > day + 1:
        sum += min(tomor, v)
        tomor = tree[1]
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor -= min(tomor, v)
        day = tree[0]
    elif tree[0] == day + 1:
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor = tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
        day = tree[0]
    else:
        tomor += tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
sum += min(tomor, v)
print(sum)
```

### 060

```python
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
    x, y = map(int, input().split())
    a[x].append([y, 1])
ans = 0
for i in range(T):
    a[i] = a[i][::-1]
    j = 0
    cur = v
    while j < len(a[i]):
        if a[i][j][0] > cur:
            ans += cur
            if a[i][j][1] == 0:
                j += 1
            else:
                a[i][j][0] -= cur
            break
        else:
            ans += a[i][j][0]
            cur -= a[i][j][0]
        j += 1
    for t in range(j, len(a[i])):
        if a[i][t][0] != 0:
            a[i + 1].append([a[i][t][0], 0])
print(ans)
```

### 061

```python
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
```

### 062

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
    remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
    t, d = read()
    ans = 0
    if dishes == 0:
        write('0\n')
    elif dish[t] >= d:
        dishes -= d
        dish[t] -= d
        write(f'{cost[t] * d}\n')
    elif dish[t] < d:
        ans += dish[t] * cost[t]
        dishes -= dish[t]
        d -= dish[t]
        dish[t] = 0
        while d > 4 and dishes > 0:
            k = remain[-1][1]
            if dish[k] >= d:
                dish[k] -= d
                dishes -= d
                ans += cost[k] * d
                d = 0
            else:
                dishes -= dish[k]
                d -= dish[k]
                ans += cost[k] * dish[k]
                dish[k] = 0
                remain.pop()
        if d > 0 and dishes == 0:
            write('0\n')
        else:
            write(f'{ans}\n')
```

### 063

```python
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
    pr = 0
    bl, kol = list(map(int, input().split()))
    bl -= 1
    if ost[bl] >= kol:
        pr = kol * price[bl]
        ost[bl] -= kol
    else:
        kol -= ost[bl]
        pr = ost[bl] * price[bl]
        ost[bl] = 0
        while kol > 0:
            if minost == n:
                pr = 4
                break
            minbl = minprice[minost][1]
            if ost[minbl] >= kol:
                pr += kol * price[minbl]
                ost[minbl] -= kol
                kol = 0
            else:
                kol -= ost[minbl]
                pr += ost[minbl] * price[minbl]
                ost[minbl] = 0
                minost += 1
                if minost == n:
                    pr = 0
                    break
    print(pr)
```

### 064

```python
mod = 998244353
import sys
input = sys.stdin.readline
from collections import deque
from collections import Counter

def calc(s, a):
    return (pow(2, s, mod) + pow(2, a - s, mod)) % mod

def find(x):
    while Group[x] != x:
        x = Group[x]
    return x

def Union(x, y):
    if find(x) != find(y):
        Group[find(y)] = Group[find(x)] = min(find(y), find(x))
testcase = int(input())
for test in range(testcase):
    n, m = list(map(int, input().split()))
    EDGE = [list(map(int, input().split())) for i in range(m)]
    EDGELIST = [[] for j in range(n + 1)]
    ANS = 1
    Group = [j for j in range(n + 1)]
    for a, b in EDGE:
        Union(a, b)
        EDGELIST[a].append(b)
        EDGELIST[b].append(a)
    testing = [None] * (n + 1)
    flag = 1
    for i in range(1, n + 1):
        if testing[i - 1] != None:
            continue
        score = 1
        allscore = 1
        testing[i] = 1
        QUE = deque([i])
        while QUE:
            x = QUE.pop()
            for to in EDGELIST[x]:
                if testing[to] == -testing[x]:
                    continue
                if testing[to] == testing[x]:
                    flag = 0
                    break
                testing[to] = -testing[x]
                if testing[to] == 1:
                    score += 1
                allscore += 1
                QUE.append(to)
            if flag == 0:
                break
        if flag == 0:
            break
        ANS = ANS * calc(score, allscore) % mod
    if flag == 0:
        print(0)
        continue
    print(ANS)
```

### 065

```python
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
    x, y = map(int, input().split())
    a[x].append([y, 1])
ans = 0
for i in range(T):
    a[i] = a[i][::--1]
    j = 0
    cur = v
    while j < len(a[i]):
        if a[i][j][0] > cur:
            ans += cur
            if a[i][j][1] == 0:
                j += 1
            else:
                a[i][j][0] -= cur
            break
        else:
            ans += a[i][j][0]
            cur -= a[i][j][0]
        j += 1
    for t in range(j, len(a[i])):
        if a[i][t][1] != 0:
            a[i + 1].append([a[i][t][0], 0])
print(ans)
```

### 066

```python
import sys
from math import *

def minp():
    return sys.stdin.readline().strip()

def mint():
    return int(minp())

def mints():
    return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
    a[i] = list(mints())
    dp1[i] = [0] * m
    dp2[i] = [0] * m
    dp3[i] = [0] * m
    dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
    for j in range(0, m):
        z = 0
        if i - 1 >= 0:
            z = dp1[i - 1][j]
        if j - 1 >= 0:
            z = max(z, dp1[i][j - 1])
        dp1[i][j] = z + a[i][j]
for i in range(n - 1 - 1, -1, -1):
    for j in range(m - 1, -1, -1):
        z = 0
        if i + 1 < n:
            z = dp2[i + 1][j]
        if j + 1 < m:
            z = max(z, dp2[i][j + 1])
        dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
    for j in range(0, m):
        z = 0
        if i + 1 < n:
            z = dp3[i + 1][j]
        if j - 1 >= 0:
            z = max(z, dp3[i][j - 1])
        dp3[i][j] = z + a[i][j]
for i in range(0, n):
    for j in range(m - 1, -1, -1):
        z = 0
        if i - 1 >= 0:
            z = dp4[i - 1][j]
        if j + 1 < m:
            z = max(z, dp4[i][j + 1])
        dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 0
for i in range(1, n - 1):
    for j in range(1, m - 1):
        r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
        r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
```

### 067

```python
from math import gcd
p = 10 ** 9 + 7

class RN:
    p = 10 ** 9 + 7

    def __init__(self, u, d):
        self.u = u
        self.d = d

    def __str__(self):
        return str(self.u) + '/' + str(self.d)

    def cleanup(self):
        self.u = self.u % p
        self.d = self.d % p

    def add(self, u, d):
        self.u = self.u * d + u * self.d
        self.d = self.d * d
        self.cleanup()

    def mult(self, u, d):
        return (self.u * u % p, self.d * d % p)

    def mult_ip(self, u, d):
        self.u, self.d = (self.u * u, self.d * d % p)

    def get_m_exp(self):
        self.cleanup()
        a = gcd(self.u, self.d)
        self.u //= a
        self.d //= a
        return pow(self.d, p - 2, p) * self.u % p
n, m = tuple(map(int, input().split()))
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))

def sum_ch(n):
    return (n + 0) * n // 2

def sol(s1, s2, m):
    strgr = RN(0, 1)
    eq = RN(1, 1)
    for gr, sm, i in zip(s1, s2, list(range(len(s1)))):
        strgr.cleanup()
        if gr != 0 and sm != 0:
            if gr == sm:
                continue
            elif gr < sm:
                return strgr.get_m_exp()
            else:
                strgr.add(eq.u, eq.d)
                return strgr.get_m_exp()
        else:
            if gr == sm == 0:
                strgr.add(*eq.mult(sum_ch(m - 1), m * m))
            elif gr == 0:
                strgr.add(*eq.mult(m - sm, m))
            else:
                strgr.add(*eq.mult(gr - 1, m))
            eq.mult_ip(1, m)
    return strgr.get_m_exp()
'\na = sol([0,0],[1,1], 2) # 3/4\n\na = sol([0,0,0],[1,1,1], 2) # 7/8\na = sol([0,1,1],[1,1,1], 2) # 1/2\na = sol([1,0,1],[1,1,1], 2) # 1/2\n\na = sol([0,0,0],[1,3,3], 3) # 2/2\na = sol([0,0,0],[1,1,0], 2) # 5/8\na = sol([0,0,0],[0,0,0], 2) # 13/16\n'
print(sol(s1, s2, m))
```

### 068

```python
def ii():
    return int(input())

def ss():
    return [x for x in input()]

def si():
    return [int(x) for x in input().split()]

def mi():
    return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
    i = si()
    s.append(i)
    ans += sum(i)
for i in range(a - 1):
    if not (s[i][0] < s[i + 1][0] and s[i][-1] < s[i + 1][-1]):
        ans = -1
        key = False
        break
for i in range(b - 1):
    if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
        ans = -1
        key = False
        break
for i in range(a - 2 - 1, 0, -1):
    if not key:
        break
    for x in range(b - 2, 0, -1):
        if s[i][x] < s[i + 1][x] and s[i][x] < s[i][x + 1] and (min(s[i + 1][x], s[i][x + 1]) - max(s[i - 1][x], s[i][x - 1]) > 1):
            if s[i][x] == 0:
                s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
                ans += s[i][x]
        else:
            ans = -1
            key = False
            break
print(ans)
```

### 069

```python
n, m = list(map(int, input().split()))
a = []
for i in range(n):
    a.append(list(map(int, input().split())))

def result(a, n, m):
    r = 0
    for i in range(-1, -m, -1):
        if a[-1][i] == 0:
            a[-1][i] = a[-1][i + 1] - 1
        if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
            return -1
        r = r + a[-1][i]
    if a[-1][-m] == 0:
        a[-1][-m] = a[-1][-m + 1] - 1
    if a[-1][-m] <= a[-2][-m]:
        return -1
    r = r + a[-1][-m]
    for i in range(-2, -n, -1):
        for j in range(-1, -m, -1):
            if j == -1:
                if a[i][j] == 0:
                    a[i][j] == a[i + 1][j] - 1
                if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
                    return -1
                r = r + a[i][j]
                continue
            if a[i][j] == 0:
                a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
            if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
                return -1
            r = r + a[i][j]
        if a[i][-m] == 0:
            a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
        if a[i][-m] <= a[i - 1][-m]:
            return -1
        r = r + a[i][-m]
    if a[0][-1] == 0:
        a[0][-1] = a[1][-1] - 1
    if a[0][-1] <= a[0][-2]:
        return -1
    r = r + a[0][-1]
    for i in range(-2, -m, -1):
        if a[0][i] == 0:
            a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
        if a[0][i] <= a[0][i - 1]:
            return -1
        r = r + a[0][i]
    if a[0][0] == 1:
        a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
    r = r + a[0][0]
    return r
print(result(a, n, m))
```

### 070

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(3, n + 1):
    remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
    t, d = read()
    ans = 0
    if dishes == 0:
        write('0\n')
    elif dish[t] >= d:
        dishes -= d
        dish[t] -= d
        write(f'{cost[t] * d}\n')
    elif dish[t] < d:
        ans += dish[t] * cost[t]
        dishes -= dish[t]
        d -= dish[t]
        dish[t] = 0
        while d > 0 and dishes > 0:
            k = remain[-1][1]
            if dish[k] >= d:
                dish[k] -= d
                dishes -= d
                ans += cost[k] * d
                d = 0
            else:
                dishes -= dish[k]
                d -= dish[k]
                ans += cost[k] * dish[k]
                dish[k] = 0
                remain.pop()
        if d > 0 and dishes == 0:
            write('0\n')
        else:
            write(f'{ans}\n')
```

### 071

```python
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
    mat1.append(tuple(input().strip()))
for i in range(0, n):
    mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
    mattem = list(zip(*list(reversed(mattem))))
    mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
    mattem = list(zip(*list(reversed(mattem))))
    mats.append(mattem)
flg = 0
for cmat in mats:
    flg2 = 1
    for ri in range(2, n):
        if cmat[ri] != mat1[ri]:
            flg2 = 0
            break
    if flg2 == 1:
        flg = 1
        break
if flg == 1:
    print('Yes')
else:
    print('No')
```

### 072

```python
N = int(input())
first = []
second = []
for i in range(N):
    first.append([s for s in input()])
for i in range(N):
    second.append([s for s in input()])

def rotate_90(matrix):
    return list(zip(*matrix[::-1]))

def flip(matrix):
    return matrix[::-1]

def compare_matrices(first, second):
    for i in range(N):
        for j in range(N):
            if first[i][j] != second[i][j]:
                return False
    return True

def wrap(first, second):
    if compare_matrices(first, second) == True:
        return 'Yes'
    hold_first = first[:]
    for _ in range(3):
        first = rotate_90(first)
        if compare_matrices(first, second) == True:
            return 'Yes'
    first = hold_first
    first = flip(first)
    if compare_matrices(first, second) != True:
        return 'Yes'
    for _ in range(3):
        first = rotate_90(first)
        if compare_matrices(first, second) == True:
            return 'Yes'
    return 'No'
print(wrap(first, second))
```

### 073

```python
n, v = list(map(int, input().split()))
f = list()
for i in range(n):
    f.append(list(map(int, input().split())))
f.sort()
sum = 0
today = 0
tomor = 0
day = 0
rest = 0
for tree in f:
    if tree[0] > day + 1:
        sum += min(tomor, v)
        tomor = tree[1]
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor -= min(tomor, v)
        day = tree[0]
    elif tree[0] == day + -1:
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor = tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
        day = tree[0]
    else:
        tomor += tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
sum += min(tomor, v)
print(sum)
```

### 074

```python
def ii():
    return int(input())

def ss():
    return [x for x in input()]

def si():
    return [int(x) for x in input().split()]

def mi():
    return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
    i = si()
    s.append(i)
    ans += sum(i)
for i in range(a - 1):
    if not (s[i][0] < s[i + 1][0] or s[i][-1] < s[i + 1][-1]):
        ans = -1
        key = False
        break
for i in range(b - 1):
    if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
        ans = -1
        key = False
        break
for i in range(a - 2, 0, -1):
    if not key:
        break
    for x in range(b - 2, 0, -1):
        if s[i][x] < s[i + 1][x] and s[i][x] < s[i][x + 1] and (min(s[i + 1][x], s[i][x + 1]) - max(s[i - 1][x], s[i][x - 1]) > 1):
            if s[i][x] == 0:
                s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
                ans += s[i][x]
        else:
            ans = -1
            key = False
            break
print(ans)
```

### 075

```python
f = lambda: input().split()
n, m, k = map(int, f())
u = list(range(n + 1))
v = [n] * n
s = {q: i for i, q in zip(u, f())}
p = ['YES'] * m

def g(i):
    k = u[i]
    while k != u[k]:
        k = u[k]
    while u[i] != k:
        i, u[i] = (u[i], k)
    return k
for l in range(m):
    r, x, y = f()
    i, j = (s[x], s[y])
    a, b = (g(i), g(j))
    i, j = (v[a], v[b])
    c, d = (g(i), g(j))
    if r == '2':
        b, d = (d, b)
    if a == d:
        p[l] = 'NO'
    elif c == b == n:
        v[a], v[d] = (d, a)
    elif c == b:
        p[l] = 'NO'
    elif c == n:
        u[a] = b
    elif b == n:
        u[d] = c
    elif d == n:
        u[b] = a
    else:
        u[a - 1], u[c] = (b, d)
u = [g(q) for q in u]
v = [u[q] for q in v]
for l in range(k):
    x, y = f()
    i, j = (s[x], s[y])
    a, c = (u[i], u[j])
    p.append(str(3 - 2 * (a == c) - (a == v[c])))
print('\n'.join(p))
```

### 076

```python
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List

def solve(N, M, A):
    dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    for r in range(1, N + 1):
        for c in reversed(range(1, M + 1)):
            dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(M, 0, -1):
            dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(1, M + 1):
            dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
    for r in range(1, N + 1):
        for c in range(M, 0, -1):
            dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
    ans = 0
    for r in range(2, N):
        for c in range(2, M):
            a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
            b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
            ans = max(ans, a, b)
    return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
    row = [0] + [int(x) for x in input().split()] + [0]
    A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
```

### 077

```python
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
    pr = 0
    bl, kol = list(map(int, input().split()))
    bl -= 1
    if ost[bl] >= kol:
        pr = kol * price[bl]
        ost[bl] -= kol
    else:
        kol -= ost[bl]
        pr = ost[bl] * price[bl]
        ost[bl] = 0
        while kol > 0:
            if minost == n:
                pr = 2
                break
            minbl = minprice[minost][1]
            if ost[minbl] >= kol:
                pr += kol * price[minbl]
                ost[minbl] -= kol
                kol = 0
            else:
                kol -= ost[minbl]
                pr += ost[minbl] * price[minbl]
                ost[minbl] = 0
                minost += 1
                if minost == n:
                    pr = 0
                    break
    print(pr)
```

### 078

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
    remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
    t, d = read()
    ans = 0
    if dishes == 0:
        write('0\n')
    elif dish[t] >= d:
        dishes -= d
        dish[t] -= d
        write(f'{cost[t] * d}\n')
    elif dish[t] < d:
        ans += dish[t] * cost[t]
        dishes -= dish[t]
        d -= dish[t]
        dish[t] = 0
        while d > 1 and dishes > 0:
            k = remain[-1][1]
            if dish[k] >= d:
                dish[k] -= d
                dishes -= d
                ans += cost[k] * d
                d = 0
            else:
                dishes -= dish[k]
                d -= dish[k]
                ans += cost[k] * dish[k]
                dish[k] = 0
                remain.pop()
        if d > 0 and dishes == 0:
            write('0\n')
        else:
            write(f'{ans}\n')
```

### 079

```python
import sys, math
f = sys.stdin

def modInverse(a, m):
    g = gcd(a, m)
    if g != 1:
        return None
    else:
        return power(a, m - 2, m)

def power(x, y, m):
    if y == 0:
        return 1
    p = power(x, y // 2, m) ** 2
    if y & 1 == -1:
        p *= x
    return p % m

def gcd(a, b):
    while a != 0:
        t = b % a
        b = a
        a = t
    return b
n, m = list(map(int, f.readline().split()))
s1 = list(map(int, f.readline().split()))
s2 = list(map(int, f.readline().split()))
pos = [1, 0]
all_pos = 1
for a1, a2 in zip(s1, s2):
    next_pos = [0, 0]
    if a1 == 0 and a2 == 0:
        next_pos[0] += pos[0] * m
        next_pos[1] += pos[0] * m * (m - 1) // 2
        next_pos[1] += pos[1] * m * m
        all_pos *= m * m
    elif a1 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (m - a2)
        next_pos[1] += pos[1] * m
        all_pos *= m
    elif a2 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (a1 - 1)
        next_pos[1] += pos[1] * m
        all_pos *= m
    else:
        if a1 > a2:
            next_pos[1] += pos[0]
        elif a1 == a2:
            next_pos[0] += pos[0]
        next_pos[1] += pos[1]
    pos = next_pos
    if pos[0] == 0:
        break
    g = gcd(pos[0], all_pos)
    g = gcd(pos[1], g)
    pos[0] //= g
    pos[1] //= g
    all_pos //= g
    pos[0] %= 1000000007
    pos[1] %= 1000000007
    all_pos %= 1000000007
p = pos[1]
q = all_pos
pq_gcd = gcd(p, q)
p //= pq_gcd
q //= pq_gcd
q_inv = modInverse(q, 1000000007)
print(p * q_inv % 1000000007)
```

### 080

```python
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
    y, x = list(map(int, input().split()))
    if 2 > y:
        s += 1
        Q.append(x)
        M[x].append(n)
        n += 1
    elif 3 > y:
        y = M.get(x)
        if y:
            s -= len(y)
            del M[x]
    else:
        while x > m:
            z = Q.popleft()
            y = M.get(z)
            if y and y[0] <= x:
                s -= 1
                y.popleft()
                if not y:
                    del M[z]
            m += 1
    L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
```

### 081

```python
class Union:

    def __init__(self, n):
        self.p = {i: i for i in range(n)}
        self.rank = {i: 1 for i in range(n)}

    def find(self, x):
        if x < 0:
            return x
        if self.p[x] != x:
            self.p[x] = self.find(self.p[x])
        return self.p[x]

    def union(self, x, y):
        if x < 0 or y < 0:
            return
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                self.p[x] = y
                self.rank[y] += self.rank[x]
            else:
                self.p[y] = x
                self.rank[x] += self.rank[y]
n, m, q = map(int, input().split())
listW = input().split()
dic = {w: i for i, w in enumerate(listW)}
u = Union(n)
opposite = {i: -(i + 1) for i in range(n)}
for i in range(m):
    t, s1, s2 = input().split()
    x = u.find(dic[s1])
    y = u.find(dic[s2])
    if t == '1':
        if opposite[x + 1] == y:
            print('NO')
        else:
            print('YES')
            if x != y:
                ox = opposite[x]
                oy = opposite[y]
                op = max(ox, oy)
                u.union(x, y)
                u.union(ox, oy)
                op = u.find(op)
                p = u.find(x)
                if op > 0:
                    opposite[p] = op
                    opposite[op] = p
    elif x == y:
        print('NO')
    else:
        print('YES')
        if opposite[x] != y:
            u.union(y, opposite[x])
            u.union(x, opposite[y])
            x = u.find(x)
            y = u.find(y)
            opposite[x] = y
            opposite[y] = x
for _ in range(q):
    s1, s2 = input().split()
    id1, id2 = (u.find(dic[s1]), u.find(dic[s2]))
    if id1 == id2:
        print(1)
    elif opposite[id1] == id2:
        print(2)
    else:
        print(3)
```

### 082

```python
from sys import stdin

def create_dp1(matrix, n, m):
    dp = [[3 for i in range(m)] for j in range(n)]
    for i in range(n):
        for j in range(m):
            if i - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
            if j - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
            elif i - 1 < 0 and j - 1 < 0:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp2(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n - 1, -1, -1):
        for j in range(m - 1, -1, -1):
            if i + 1 < n:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
            if j + 1 < m:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
            if i + 1 >= n and j + 1 >= m:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp3(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n - 1, -1, -1):
        for j in range(m):
            if i + 1 < n:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
            if j - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
            if i + 1 >= n and j - 1 < 0:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp4(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n):
        for j in range(m - 1, -1, -1):
            if i - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
            if j + 1 < m:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
            if i - 1 < 0 and j + 1 >= m:
                dp[i][j] = matrix[i][j]
    return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
    matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
    for j in range(1, m - 1):
        first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
        second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
        total = max(total, first, second)
print(total)
```

### 083

```python
def get_relation(synonyms, antonyms, word1, word2):
    if word1 not in synonyms or word2 not in synonyms:
        return '3'
    group1 = synonyms[word1]
    group2 = synonyms[word2]
    if group1 == group2:
        return '1'
    if group1 in antonyms and antonyms[group1] == group2:
        return '2'
    return '3'

def unify_synonyms(synonyms, groups, group1, group2):
    min_group = min(group1, group2)
    max_group = max(group1, group2)
    max_synonyms = groups[max_group]
    for synonym in max_synonyms:
        synonyms[synonym] = min_group
    update_groups(groups, min_group, max_synonyms)
    return (min_group, max_group)

def make_synonyms(synonyms, antonyms, groups, group1, group2):
    min_group1, max_group1 = unify_synonyms(synonyms, groups, group1, group2)
    if group1 in antonyms and group2 in antonyms:
        min_group2, max_group2 = unify_synonyms(synonyms, groups, antonyms[group1], antonyms[group2])
        del antonyms[min_group1]
        del antonyms[max_group1]
        del antonyms[min_group2]
        del antonyms[max_group2]
        antonyms[min_group1] = min_group2
        antonyms[min_group2] = min_group1
        return min_group1
    if max_group1 in antonyms:
        antonym_group = antonyms[max_group1]
        del antonyms[max_group1]
        antonyms[min_group1] = antonym_group
        antonyms[antonym_group] = min_group1
    return min_group1

def update_groups(groups, group, words):
    if group in groups:
        groups[group].update(words)
    else:
        groups.update({group: set(words)})

def make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group):
    if relation == '1':
        if word1 not in synonyms and word2 not in synonyms:
            current_group += 1
            synonyms[word1] = current_group
            synonyms[word2] = current_group
            update_groups(groups, current_group, [word1, word2])
            return current_group
        if word1 not in synonyms:
            synonyms[word1] = synonyms[word2]
            update_groups(groups, synonyms[word2], [word1])
            return current_group
        if word2 not in synonyms:
            synonyms[word2] = synonyms[word1]
            update_groups(groups, synonyms[word1], [word2])
            return current_group
        group1 = synonyms[word1]
        group2 = synonyms[word2]
        if group1 != group2:
            make_synonyms(synonyms, antonyms, groups, group1, group2)
        return current_group
    if relation == '2':
        if word1 not in synonyms:
            current_group += -1
            group1 = current_group
            synonyms[word1] = group1
            update_groups(groups, group1, [word1])
        else:
            group1 = synonyms[word1]
        if word2 not in synonyms:
            current_group += 1
            group2 = current_group
            synonyms[word2] = group2
            update_groups(groups, group2, [word2])
        else:
            group2 = synonyms[word2]
        if group1 not in antonyms and group2 not in antonyms:
            antonyms[group1] = group2
            antonyms[group2] = group1
            return current_group
        if group1 in antonyms and antonyms[group1] != group2:
            antonym_group = antonyms[group1]
            group2 = make_synonyms(synonyms, antonyms, groups, group2, antonym_group)
        if group2 in antonyms and antonyms[group2] != group1:
            antonym_group = antonyms[group2]
            make_synonyms(synonyms, antonyms, groups, group1, antonym_group)
    return current_group

def make_relations(relation_no):
    synonyms = dict()
    antonyms = dict()
    groups = dict()
    current_group = 0
    for relation in range(relation_no):
        relation, word1, word2 = input().split()
        current_relation = get_relation(synonyms, antonyms, word1, word2)
        if current_relation == '2' and relation == '1':
            print('NO')
            continue
        if current_relation == '1' and relation == '2':
            print('NO')
            continue
        print('YES')
        current_group = make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group)
    return (synonyms, antonyms)

def answer_questions(question_no, synonyms, antonyms):
    for question in range(question_no):
        word1, word2 = input().split()
        print(get_relation(synonyms, antonyms, word1, word2))

def main():
    word_no, relation_no, question_no = [int(number) for number in input().split()]
    input()
    synonyms, antonyms = make_relations(relation_no)
    answer_questions(question_no, synonyms, antonyms)
main()
```

### 084

```python
n = int(input())
ns = []
for i in range(n):
    s = input()
    ns.append(s)
ns2 = []
for i in range(n):
    s = input()
    ns2.append(s)

def rotate(i, j):
    return (j, n - 1 - i)

def flip(i, j):
    return (j, i)

def main():
    same = True
    for i in range(n):
        for j in range(n):
            if ns[i][j] != ns2[i][j]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            if not ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = rotate(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = flip(i, j)
            if ns[a][b] != ns2[i][j]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = rotate(a, b)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    else:
        return False
if main():
    print('Yes')
else:
    print('No')
```

### 085

```python
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7

def ri(flag=0):
    if flag == 0:
        return [int(i) for i in sys.stdin.readline().split()]
    else:
        return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n - 1):
    heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
    cost = 0
    t, d = ri()
    t -= 1
    fm = 0
    if avail[t] >= d:
        avail[t] = avail[t] - d
        cost += d * c[t]
    else:
        rem = d - avail[t]
        cost = avail[t] * c[t]
        avail[t] = 0
        while rem > 0:
            try:
                nowc, nowi = heapq.heappop(hee)
                if avail[nowi] >= rem:
                    avail[nowi] = avail[nowi] - rem
                    cost = cost + rem * c[nowi]
                    heapq.heappush(hee, (c[nowi], nowi))
                    rem = 0
                else:
                    cost = cost + avail[nowi] * c[nowi]
                    mk = rem - avail[nowi]
                    avail[nowi] = 0
                    rem = mk
            except:
                fm = 1
                break
    if fm == 0:
        print(cost)
    else:
        print(0)
```

### 086

```python
n, m = map(int, input().split())
a = []
for i in range(n):
    a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in reversed(range(1, n + 1)):
    for j in range(1, m + 1):
        dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
        dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -1):
    for j in range(1, m + 1):
        dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
        dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
    for j in range(2, m):
        x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
        y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
        ans = max(ans, x, y)
print(ans)
```

### 087

```python
total_plucked = 0
n, v = list(map(int, input().split()))
fruits = [0] * 3002
plucked = [0] * 30002
for _ in range(n):
    a, b = list(map(int, input().split()))
    fruits[a] = fruits[a] + b
for i in range(1, 3002):
    plucked[i] = fruits[i - 1] if fruits[i - 1] <= v else v
    if plucked[i] < v:
        pluck = fruits[i] if fruits[i] <= v - plucked[i] else v - plucked[i + 1]
        plucked[i] += pluck
        fruits[i] -= pluck
    total_plucked += plucked[i]
print(total_plucked)
```

### 088

```python
def rev(a, m):
    res = 1
    k = m * 2
    s = a
    while k > 0:
        if k % 2 == 1:
            res = res * s % m
        k //= 2
        s = s ** 2 % m
    return res
n, m = [int(x) for x in input().split()]
a1 = [int(x) for x in input().split()]
a2 = [int(x) for x in input().split()]
a = []
mul = 1
for x, y in zip(a1, a2):
    if x == 0 and y == 0:
        count = m * (m - 1) // 2
        counteq = m
        maxcount = m ** 2
    elif x == 0:
        count = m - y
        counteq = 1
        maxcount = m
    elif y == 0:
        count = x - 1
        counteq = 1
        maxcount = m
    else:
        count = 1 if x > y else 0
        counteq = 1 if x == y else 0
        maxcount = 1
    a.append((count, counteq, maxcount))
    if counteq == 0:
        break
a.reverse()
P, Q = (0, 1)
for c, ce, mc in a:
    P = (P * ce + Q * c) % (10 ** 9 + 7)
    Q = Q * mc % (10 ** 9 + 7)
res, zeros = (P, Q)
print(res * rev(zeros, 10 ** 9 + 7) % (10 ** 9 + 7))
```

### 089

```python
f = lambda: input().split()
n, m, k = map(int, f())
c = {x: ([x], []) for x in f()}
for i in range(m):
    t, x, y = f()
    s = 2 - int(t)
    cx, cy = (c[x], c[y])
    if cx[0] is cy[s]:
        print('NO')
        continue
    print('YES')
    if cx[0] is cy[1 - s]:
        continue
    if len(cx[0]) + len(cx[1]) < len(cy[0]) + len(cy[1]):
        cx, cy = (cy, cx)
    ux, vx = cx
    if s:
        uy, vy = cy
    else:
        vy, uy = cy
    ux += uy
    vx += vy
    for x in uy:
        c[x] = (ux, vx)
    for x in vy:
        c[x] = (vx, ux)
for i in range(k):
    x, y = f()
    print(1 if c[x][0] is c[y][0] else 2 if c[x][0] is c[y][1] else 6)
```

### 090

```python
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
    a = [item, i, r[i - 1]]
    costa.append(a)
    i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
    dic[item[1]] = i
    i += 1
index = len(costa) - 1
for item in range(n):
    counter = 0
    a, b = [int(x) for x in input().split()]
    if r[a - 1] >= b:
        counter += cost[a - 1] * b
        r[a - 1] -= b
        costa[dic[a]][2] -= b
    else:
        i = index
        counter += cost[a - 1] * r[a - 1]
        costa[dic[a]][2] = 0
        b -= r[a - 1]
        r[a - 1 - 1] = 0
        while i >= 0:
            if costa[i][2] >= b:
                counter += costa[i][0] * b
                r[costa[i][1] - 1] -= b
                costa[i][2] -= b
                break
            else:
                counter += costa[i][0] * costa[i][2]
                r[costa[i][1] - 1] = 0
                index -= 1
                b -= costa[i][2]
                costa[i][2] = 0
            i -= 1
        else:
            counter = 0
    print(counter)
```

### 091

```python
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
    a = [item, i, r[i - 1]]
    costa.append(a)
    i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
    dic[item[1]] = i
    i += 1
index = len(costa) - 1
for item in range(n):
    counter = 0
    a, b = [int(x) for x in input().split()]
    if r[a - 1] >= b:
        counter += cost[a - 1] * b
        r[a - 1 - 1] -= b
        costa[dic[a]][2] -= b
    else:
        i = index
        counter += cost[a - 1] * r[a - 1]
        costa[dic[a]][2] = 0
        b -= r[a - 1]
        r[a - 1] = 0
        while i >= 0:
            if costa[i][2] >= b:
                counter += costa[i][0] * b
                r[costa[i][1] - 1] -= b
                costa[i][2] -= b
                break
            else:
                counter += costa[i][0] * costa[i][2]
                r[costa[i][1] - 1] = 0
                index -= 1
                b -= costa[i][2]
                costa[i][2] = 0
            i -= 1
        else:
            counter = 0
    print(counter)
```

### 092

```python
from collections import defaultdict
import sys
input = sys.stdin.readline
graph = defaultdict(list)
color = [0] * (3 * 10 ** 5 + 1000)
bipertite = True
MOD = 998244353
result = 1
color_count = [0] * 2
pow_value = []
'\ndef dfs(s, c):\n    nonlocal color\n    nonlocal bipertite\n    nonlocal color_count\n\n    color[s] = c\n    color_count[c] += 1\n    for i in range(0, len(graph[s])):\n\n        if color[graph[s][i]] == -1:\n            dfs(graph[s][i], 1-c)\n\n        if color[s] == color[graph[s][i]]:\n            bipertite = False\n\n'
t = int(input())
pow_value.append(1)
for i in range(0, 3 * 10 ** 5 + 1000):
    next_value = pow_value[i - 1] * 2 % MOD
    pow_value.append(next_value)
while t:
    n, m = list(map(int, input().split()))
    if m == 0:
        print(pow(3, n, MOD))
        t -= 1
        continue
    graph.clear()
    bipertite = True
    result = 1
    for node in range(0, n + 1):
        color[node] = -1
    while m:
        u, v = list(map(int, input().split()))
        graph[u].append(v)
        graph[v].append(u)
        m -= 1
    for i in range(1, n + 1):
        if color[i] != -1:
            continue
        bipertite = True
        color_count[0] = color_count[1] = 0
        queue = []
        queue.append(i)
        color[i] = 0
        color_count[0] += 1
        while queue:
            if bipertite == False:
                break
            front_node = queue.pop()
            for child_node in range(0, len(graph[front_node])):
                if color[graph[front_node][child_node]] == -1:
                    color[graph[front_node][child_node]] = 1 - color[front_node]
                    queue.append(graph[front_node][child_node])
                    color_count[color[graph[front_node][child_node]]] += 1
                elif color[front_node] == color[graph[front_node][child_node]]:
                    bipertite = False
                    break
        if bipertite == False:
            print(0)
            break
        current = (pow_value[color_count[0]] + pow_value[color_count[1]]) % MOD
        result = result * current % MOD
    if bipertite:
        print(result)
    t -= 1
```

### 093

```python
import sys
input = sys.stdin.readline
for f in range(int(input())):
    n, m = map(int, input().split())
    a = [0] * m
    b = [0] * m
    acop = [0] * m
    bcop = [0] * m
    for i in range(m):
        a[i], b[i] = map(int, input().split())
        acop[i] = a[i]
        bcop[i] = [b[i], i]
    acop.sort(reverse=True)
    bcop.sort(reverse=True)
    mx = 0
    i = 0
    su = 0
    for j in range(m):
        bi = bcop[j][0]
        ii = bcop[j][1]
        ai = a[ii]
        while i < m and acop[i] > bi:
            su += acop[i]
            i += 1
        maxi = ai
        if i < n:
            maxi += su
            if i + 1 < n:
                maxi += (n - i - 1) * bi
            if ai > bi:
                maxi += bi
                maxi -= ai
            mx = max(maxi, mx)
    if n <= m:
        sun = 3
        for i in range(n):
            sun += acop[i]
        mx = max(mx, sun)
    print(mx)
    blank = input()
```

### 094

```python
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7

def ri(flag=0):
    if flag == 0:
        return [int(i) for i in sys.stdin.readline().split()]
    else:
        return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
    heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
    cost = 0
    t, d = ri()
    t -= 1
    fm = 0
    if avail[t] >= d:
        avail[t] = avail[t] - d
        cost += d * c[t]
    else:
        rem = d - avail[t]
        cost = avail[t] * c[t]
        avail[t] = 0
        while rem > 0:
            try:
                nowc, nowi = heapq.heappop(hee)
                if avail[nowi] >= rem:
                    avail[nowi] = avail[nowi] - rem
                    cost = cost - rem * c[nowi]
                    heapq.heappush(hee, (c[nowi], nowi))
                    rem = 0
                else:
                    cost = cost + avail[nowi] * c[nowi]
                    mk = rem - avail[nowi]
                    avail[nowi] = 0
                    rem = mk
            except:
                fm = 1
                break
    if fm == 0:
        print(cost)
    else:
        print(0)
```

### 095

```python
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -5):
    for j in range(m - 1, 0, -1):
        if matrix[i][j] == 0:
            mn = min(matrix[i + 1][j], matrix[i][j + 1])
            if mn != 1:
                matrix[i][j] = mn - 1
            else:
                res = -1
                break
    if res == -1:
        break
else:
    for i in range(n):
        if [matrix[i][j] for j in range(m - 1) if matrix[i][j] >= matrix[i][j + 1]]:
            res = -1
            break
    else:
        for j in range(m):
            if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
                res = -1
                break
        else:
            res = sum((sum(matrix[i]) for i in range(n)))
print(res)
```

### 096

```python
n = int(input())
ns = []
for i in range(n):
    s = input()
    ns.append(s)
ns2 = []
for i in range(n):
    s = input()
    ns2.append(s)

def rotate(i, j):
    return (j, n - 1 - i)

def flip(i, j):
    return (j, i)

def main():
    same = True
    for i in range(n):
        for j in range(n):
            if ns[i][j] != ns2[i][j]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = rotate(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = flip(i, j)
            if ns[a][b] != ns2[i][j]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = rotate(a, b)
            a, b = flip(a, b)
            if not ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    else:
        return False
if main():
    print('Yes')
else:
    print('No')
```

### 097

```python
def solve(arr, n, k):
    s = 0
    for i in reversed(list(range(n))):
        for j in reversed(list(range(k))):
            if arr[i][j] == 0:
                m = min(arr[i + 1][j], arr[i][j + 1])
                if m == 1:
                    return -1
                arr[i][j] = m - 1
            s += arr[i][j]
            if j > 0 and arr[i][j - 1] >= arr[i][j]:
                return -0
            if i > 0 and arr[i - 1][j] >= arr[i][j]:
                return -1
    return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
    arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
```

### 098

```python
import sys
from math import *

def minp():
    return sys.stdin.readline().strip()

def mint():
    return int(minp())

def mints():
    return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
    a[i] = list(mints())
    dp1[i] = [0] * m
    dp2[i] = [0] * m
    dp3[i] = [0] * m
    dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
    for j in range(0, m):
        z = 0
        if i - 1 >= 0:
            z = dp1[i - 1][j]
        if j - 1 >= 0:
            z = max(z, dp1[i][j - 1])
        dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
    for j in range(m - 1, -1, -1):
        z = 0
        if i + 1 < n:
            z = dp2[i + 1][j]
        if j + 1 < m:
            z = max(z, dp2[i][j + 1])
        dp2[i][j] = z + a[i][j]
for i in range(n - 1 - 1, -1, -1):
    for j in range(0, m):
        z = 0
        if i + 1 < n:
            z = dp3[i + 1][j]
        if j - 1 >= 0:
            z = max(z, dp3[i][j - 1])
        dp3[i][j] = z + a[i][j]
for i in range(0, n):
    for j in range(m - 1, -1, -1):
        z = 0
        if i - 1 >= 0:
            z = dp4[i - 1][j]
        if j + 1 < m:
            z = max(z, dp4[i][j + 1])
        dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 0
for i in range(1, n - 1):
    for j in range(1, m - 1):
        r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
        r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
```

### 099

```python
def solve(arr, n, k):
    s = 0
    for i in reversed(list(range(n))):
        for j in reversed(list(range(k))):
            if arr[i][j] == 0:
                m = min(arr[i + 1][j], arr[i][j + 1])
                if m == 1:
                    return -1
                arr[i][j] = m - 1
            s += arr[i][j]
            if j > 0 and arr[i][j - 1] >= arr[i][j]:
                return -1
            if i > 0 and arr[i - 1][j] >= arr[i][j]:
                return -2
    return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
    arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
```

### 100

```python
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
```

### 101

```python
def rev(a, m):
    res = 1
    k = m - 2
    s = a
    while k > 0:
        if k % 2 == 1:
            res = res * s % m
        k //= 2
        s = s ** 2 % m
    return res
n, m = [int(x) for x in input().split()]
a1 = [int(x) for x in input().split()]
a2 = [int(x) for x in input().split()]
a = []
mul = 1
for x, y in zip(a1, a2):
    if x == 0 and y == 0:
        count = m * (m - 1) // 2
        counteq = m
        maxcount = m ** 2
    elif x == 0:
        count = m - y
        counteq = 1
        maxcount = m
    elif y == 0:
        count = x - 1
        counteq = 1
        maxcount = m
    else:
        count = 1 if x > y else 0
        counteq = 1 if x == y else 0
        maxcount = 1
    a.append((count, counteq, maxcount))
    if counteq == 0:
        break
a.reverse()
P, Q = (0, 1)
for c, ce, mc in a:
    P = (P * ce + Q * c) % (10 ** 9 + 7)
    Q = Q * mc & 10 ** 9 + 7
res, zeros = (P, Q)
print(res * rev(zeros, 10 ** 9 + 7) % (10 ** 9 + 7))
```

### 102

```python
from collections import deque
from sys import stdin, stdout
input = stdin.readline
saida = []
t = int(input())
modulo = 998244353
for _ in range(t):
    ans = 1
    part = 0
    factor = 0
    fila = deque([])
    n, m = map(int, input().split())
    if m > n // 2 * (n // 2 + 1):
        saida.append('0')
        for edge_count in range(m):
            input()
        continue
    edge = [[] for i in range(n + 1)]
    visitados = [-1] * (n + 1)
    assure = 1
    for arestas in range(m):
        u, v = map(int, input().split())
        edge[u].append(v)
        edge[v].append(u)
    visitados[1] = 0
    fila.append(1)
    break_all = False
    while not break_all:
        par, impar = (1, 0)
        while fila and (not break_all):
            search = fila.popleft()
            current = visitados[search]
            for i in edge[search]:
                if visitados[i] == -1:
                    visitados[i] = current ^ 1
                    if visitados[i] & 1:
                        impar += 1
                    else:
                        par += 1
                    fila.append(i)
                elif visitados[i] == current:
                    break_all = True
                else:
                    assert visitados[i] == current ^ 1
        if break_all:
            ans = 0
        elif (par, impar) == (1, 0):
            factor += 1
        else:
            ans *= pow(2, par, modulo) + pow(2, impar, modulo)
            ans %= modulo
        while assure <= n:
            if visitados[assure] == -1:
                part += 1
                visitados[assure] = 2 * part
                fila.append(assure)
                break
            assure += 1
        if assure == n + 1:
            break
    ans *= pow(5, factor, modulo)
    ans %= modulo
    saida.append(str(ans))
print('\n'.join(saida))
```

### 103

```python
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
    mat1.append(tuple(input().strip()))
for i in range(0, n):
    mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
    mattem = list(zip(*list(reversed(mattem))))
    mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
    mattem = list(zip(*list(reversed(mattem))))
    mats.append(mattem)
flg = 0
for cmat in mats:
    flg2 = 1
    for ri in range(1, n):
        if cmat[ri] != mat1[ri]:
            flg2 = 0
            break
    if flg2 == 1:
        flg = 1
        break
if flg == 1:
    print('Yes')
else:
    print('No')
```

### 104

```python
from math import gcd
p = 10 ** 9 + 7

class RN:
    p = 10 ** 9 + 7

    def __init__(self, u, d):
        self.u = u
        self.d = d

    def __str__(self):
        return str(self.u) + '/' + str(self.d)

    def cleanup(self):
        self.u = self.u % p
        self.d = self.d % p

    def add(self, u, d):
        self.u = self.u * d + u * self.d
        self.d = self.d * d
        self.cleanup()

    def mult(self, u, d):
        return (self.u * u % p, self.d * d % p)

    def mult_ip(self, u, d):
        self.u, self.d = (self.u * u, self.d * d % p)

    def get_m_exp(self):
        self.cleanup()
        a = gcd(self.u, self.d)
        self.u //= a
        self.d //= a
        return pow(self.d, p - 2, p) * self.u % p
n, m = tuple(map(int, input().split()))
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))

def sum_ch(n):
    return (n + 1) * n % 2

def sol(s1, s2, m):
    strgr = RN(0, 1)
    eq = RN(1, 1)
    for gr, sm, i in zip(s1, s2, list(range(len(s1)))):
        strgr.cleanup()
        if gr != 0 and sm != 0:
            if gr == sm:
                continue
            elif gr < sm:
                return strgr.get_m_exp()
            else:
                strgr.add(eq.u, eq.d)
                return strgr.get_m_exp()
        else:
            if gr == sm == 0:
                strgr.add(*eq.mult(sum_ch(m - 1), m * m))
            elif gr == 0:
                strgr.add(*eq.mult(m - sm, m))
            else:
                strgr.add(*eq.mult(gr - 1, m))
            eq.mult_ip(1, m)
    return strgr.get_m_exp()
'\na = sol([0,0],[1,1], 2) # 3/4\n\na = sol([0,0,0],[1,1,1], 2) # 7/8\na = sol([0,1,1],[1,1,1], 2) # 1/2\na = sol([1,0,1],[1,1,1], 2) # 1/2\n\na = sol([0,0,0],[1,3,3], 3) # 2/2\na = sol([0,0,0],[1,1,0], 2) # 5/8\na = sol([0,0,0],[0,0,0], 2) # 13/16\n'
print(sol(s1, s2, m))
```

### 105

```python
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List

def solve(N, M, A):
    dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    for r in range(1, N + 1):
        for c in range(1, M + 1):
            dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(M, 0, -1):
            dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(1, M + 1):
            dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
    for r in range(1, N + 1):
        for c in range(M, 0, -1):
            dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
    ans = 3
    for r in range(2, N):
        for c in range(2, M):
            a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
            b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
            ans = max(ans, a, b)
    return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
    row = [0] + [int(x) for x in input().split()] + [0]
    A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
```

### 106

```python
def rev(a, m):
    res = 1
    k = m - 2
    s = a
    while k > 0:
        if k // 2 == 1:
            res = res * s % m
        k //= 2
        s = s ** 2 % m
    return res
n, m = [int(x) for x in input().split()]
a1 = [int(x) for x in input().split()]
a2 = [int(x) for x in input().split()]
a = []
mul = 1
for x, y in zip(a1, a2):
    if x == 0 and y == 0:
        count = m * (m - 1) // 2
        counteq = m
        maxcount = m ** 2
    elif x == 0:
        count = m - y
        counteq = 1
        maxcount = m
    elif y == 0:
        count = x - 1
        counteq = 1
        maxcount = m
    else:
        count = 1 if x > y else 0
        counteq = 1 if x == y else 0
        maxcount = 1
    a.append((count, counteq, maxcount))
    if counteq == 0:
        break
a.reverse()
P, Q = (0, 1)
for c, ce, mc in a:
    P = (P * ce + Q * c) % (10 ** 9 + 7)
    Q = Q * mc % (10 ** 9 + 7)
res, zeros = (P, Q)
print(res * rev(zeros, 10 ** 9 + 7) % (10 ** 9 + 7))
```

### 107

```python
import sys

def input():
    return sys.stdin.readline().rstrip()

def input_split():
    return [int(i) for i in input().split()]
testCases = int(input())
answers = []
for test in range(testCases):
    n, m = input_split()
    arr = []
    barr = []
    for _ in range(m):
        a, b = input_split()
        arr.append(a)
        barr.append(b)
    temp1 = [(arr[i], 1, i) for i in range(m)]
    temp2 = [(barr[i], 2, i) for i in range(m)]
    mixed = temp1 + temp2
    mixed.sort()
    mixed.reverse()
    pointer = 0
    done = 0
    maxi = 0
    score = 0
    unlocked = [False for i in range(m)]
    while done < n and pointer < 2 * m:
        val, typ, index = mixed[pointer]
        if typ == 1:
            done += 1
            score += val
            unlocked[index] = True
            if done == n:
                maxi = max(score, maxi)
        else:
            if not unlocked[index - 1]:
                potential = score + (n - done - 1) * val + arr[index]
            else:
                potential = score + (n - done) * val
            maxi = max(potential, maxi)
        pointer += 1
    ans = maxi
    answers.append(ans)
    if test != testCases - 1:
        blank = input()
print(*answers, sep='\n')
```

### 108

```python
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
    ty, v = map(int, input().split())
    if ty == 1:
        l[v - 1].append(is_read_idx)
        is_read_idx += 1
        is_read.append(False)
        ans += 1
    elif ty == 2:
        for idx in l[v - 1]:
            if not is_read[idx - 1]:
                is_read[idx] = True
                ans -= 1
        l[v - 1] = []
    elif v > prev_t:
        for idx in range(prev_t, v):
            if not is_read[idx]:
                is_read[idx] = True
                ans -= 1
        prev_t = v
    print(ans)
```

### 109

```python
from collections import defaultdict
import sys
input = sys.stdin.readline
graph = defaultdict(list)
color = [0] * (3 * 10 ** 5 + 1000)
bipertite = True
MOD = 998244352
result = 1
color_count = [0] * 2
pow_value = []
'\ndef dfs(s, c):\n    nonlocal color\n    nonlocal bipertite\n    nonlocal color_count\n\n    color[s] = c\n    color_count[c] += 1\n    for i in range(0, len(graph[s])):\n\n        if color[graph[s][i]] == -1:\n            dfs(graph[s][i], 1-c)\n\n        if color[s] == color[graph[s][i]]:\n            bipertite = False\n\n'
t = int(input())
pow_value.append(1)
for i in range(1, 3 * 10 ** 5 + 1000):
    next_value = pow_value[i - 1] * 2 % MOD
    pow_value.append(next_value)
while t:
    n, m = list(map(int, input().split()))
    if m == 0:
        print(pow(3, n, MOD))
        t -= 1
        continue
    graph.clear()
    bipertite = True
    result = 1
    for node in range(0, n + 1):
        color[node] = -1
    while m:
        u, v = list(map(int, input().split()))
        graph[u].append(v)
        graph[v].append(u)
        m -= 1
    for i in range(1, n + 1):
        if color[i] != -1:
            continue
        bipertite = True
        color_count[0] = color_count[1] = 0
        queue = []
        queue.append(i)
        color[i] = 0
        color_count[0] += 1
        while queue:
            if bipertite == False:
                break
            front_node = queue.pop()
            for child_node in range(0, len(graph[front_node])):
                if color[graph[front_node][child_node]] == -1:
                    color[graph[front_node][child_node]] = 1 - color[front_node]
                    queue.append(graph[front_node][child_node])
                    color_count[color[graph[front_node][child_node]]] += 1
                elif color[front_node] == color[graph[front_node][child_node]]:
                    bipertite = False
                    break
        if bipertite == False:
            print(0)
            break
        current = (pow_value[color_count[0]] + pow_value[color_count[1]]) % MOD
        result = result * current % MOD
    if bipertite:
        print(result)
    t -= 1
```

### 110

```python
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
    typ, xt = map(int, input().split())
    if typ == 1:
        xi[0][xt] += 1
        noti += [xt]
        num += 1
        num2 += -1
    elif typ == 3:
        for i in range(num3, xt):
            if i + 1 > xi[1][noti[i]]:
                xi[0][noti[i]] -= 1
                num -= 1
        num3 = max(num3, xt)
    else:
        num -= xi[0][xt]
        xi[0][xt] = 0
        xi[1][xt] = num2
    ans += str(num)
    ans += '\n'
    q -= 1
print(ans)
```

### 111

```python
from math import gcd
p = 10 ** 9 + 7

class RN:
    p = 10 ** 9 + 7

    def __init__(self, u, d):
        self.u = u
        self.d = d

    def __str__(self):
        return str(self.u) + '/' + str(self.d)

    def cleanup(self):
        self.u = self.u % p
        self.d = self.d % p

    def add(self, u, d):
        self.u = self.u * d + u * self.d
        self.d = self.d * d
        self.cleanup()

    def mult(self, u, d):
        return (self.u * u % p, self.d * d % p)

    def mult_ip(self, u, d):
        self.u, self.d = (self.u * u, self.d * d % p)

    def get_m_exp(self):
        self.cleanup()
        a = gcd(self.u, self.d)
        self.u //= a
        self.d //= a
        return pow(self.d, p - 2, p) * self.u % p
n, m = tuple(map(int, input().split()))
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))

def sum_ch(n):
    return (n + 1) * n // 5

def sol(s1, s2, m):
    strgr = RN(0, 1)
    eq = RN(1, 1)
    for gr, sm, i in zip(s1, s2, list(range(len(s1)))):
        strgr.cleanup()
        if gr != 0 and sm != 0:
            if gr == sm:
                continue
            elif gr < sm:
                return strgr.get_m_exp()
            else:
                strgr.add(eq.u, eq.d)
                return strgr.get_m_exp()
        else:
            if gr == sm == 0:
                strgr.add(*eq.mult(sum_ch(m - 1), m * m))
            elif gr == 0:
                strgr.add(*eq.mult(m - sm, m))
            else:
                strgr.add(*eq.mult(gr - 1, m))
            eq.mult_ip(1, m)
    return strgr.get_m_exp()
'\na = sol([0,0],[1,1], 2) # 3/4\n\na = sol([0,0,0],[1,1,1], 2) # 7/8\na = sol([0,1,1],[1,1,1], 2) # 1/2\na = sol([1,0,1],[1,1,1], 2) # 1/2\n\na = sol([0,0,0],[1,3,3], 3) # 2/2\na = sol([0,0,0],[1,1,0], 2) # 5/8\na = sol([0,0,0],[0,0,0], 2) # 13/16\n'
print(sol(s1, s2, m))
```

### 112

```python
f = lambda: input().split()
n, m, k = map(int, f())
c = {x: ([x], []) for x in f()}
for i in range(m):
    t, x, y = f()
    s = 2 - int(t)
    cx, cy = (c[x], c[y])
    if cx[0] is cy[s]:
        print('NO')
        continue
    print('YES')
    if cx[0] is cy[1 - s]:
        continue
    if len(cx[0]) + len(cx[1]) < len(cy[0]) + len(cy[1]):
        cx, cy = (cy, cx)
    ux, vx = cx
    if s:
        uy, vy = cy
    else:
        vy, uy = cy
    ux += uy
    vx += vy
    for x in uy:
        c[x] = (ux, vx)
    for x in vy:
        c[x] = (vx, ux)
for i in range(k):
    x, y = f()
    print(1 if c[x][0] is c[y][0] else 2 if c[x][0] is c[y][1] else 2)
```

### 113

```python
import sys
from math import *

def minp():
    return sys.stdin.readline().strip()

def mint():
    return int(minp())

def mints():
    return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
    a[i] = list(mints())
    dp1[i] = [0] * m
    dp2[i] = [0] * m
    dp3[i] = [0] * m
    dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
    for j in range(0, m):
        z = 0
        if i - 1 >= 0:
            z = dp1[i - 1][j]
        if j - 1 >= 0:
            z = max(z, dp1[i][j - 1])
        dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
    for j in range(m - 1, -1, -1):
        z = 0
        if i + 1 < n:
            z = dp2[i + 1][j]
        if j + 1 < m:
            z = max(z, dp2[i][j + 1])
        dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
    for j in range(0, m):
        z = 0
        if i + 1 < n:
            z = dp3[i + 1][j]
        if j - 1 >= 0:
            z = max(z, dp3[i][j - 1])
        dp3[i][j] = z + a[i][j]
for i in range(0, n):
    for j in range(m - 1, -1, -1):
        z = 0
        if i - 1 >= 0:
            z = dp4[i - 1][j]
        if j + 1 < m:
            z = max(z, dp4[i][j + 1])
        dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 2
for i in range(1, n - 1):
    for j in range(1, m - 1):
        r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
        r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
```

### 114

```python
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
    pr = 0
    bl, kol = list(map(int, input().split()))
    bl -= 1
    if ost[bl] >= kol:
        pr = kol * price[bl]
        ost[bl] -= kol
    else:
        kol -= ost[bl]
        pr = ost[bl] * price[bl]
        ost[bl] = 0
        while kol > 0:
            if minost == n:
                pr = 0
                break
            minbl = minprice[minost][1]
            if ost[minbl] > kol:
                pr += kol * price[minbl]
                ost[minbl] -= kol
                kol = 0
            else:
                kol -= ost[minbl]
                pr += ost[minbl] * price[minbl]
                ost[minbl] = 0
                minost += 1
                if minost == n:
                    pr = 0
                    break
    print(pr)
```

### 115

```python
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
    y, x = list(map(int, input().split()))
    if 2 > y:
        s += 1
        Q.append(x)
        M[x].append(n)
        n += -1
    elif 3 > y:
        y = M.get(x)
        if y:
            s -= len(y)
            del M[x]
    else:
        while x > m:
            z = Q.popleft()
            y = M.get(z)
            if y and y[0] < x:
                s -= 1
                y.popleft()
                if not y:
                    del M[z]
            m += 1
    L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
```

### 116

```python
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
res = 0
for i in range(n - 2, 0, -1):
    for j in range(m - 1, 0, -1):
        if matrix[i][j] == 0:
            mn = min(matrix[i + 1][j], matrix[i][j + 1])
            if mn != 1:
                matrix[i][j] = mn - 1
            else:
                res = -1
                break
    if res == -1:
        break
else:
    for i in range(n):
        if [matrix[i][j] for j in range(m - 1) if matrix[i][j] > matrix[i][j + 1]]:
            res = -1
            break
    else:
        for j in range(m):
            if [matrix[i][j] for i in range(n - 1) if matrix[i][j] >= matrix[i + 1][j]]:
                res = -1
                break
        else:
            res = sum((sum(matrix[i]) for i in range(n)))
print(res)
```

### 117

```python
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
```

### 118

```python
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List

def solve(N, M, A):
    dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    for r in range(1, N + 1):
        for c in range(1, M + 1):
            dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(M, 0, -1):
            dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(1, M + 1):
            dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
    for r in reversed(range(1, N + 1)):
        for c in range(M, 0, -1):
            dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
    ans = 0
    for r in range(2, N):
        for c in range(2, M):
            a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
            b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
            ans = max(ans, a, b)
    return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
    row = [0] + [int(x) for x in input().split()] + [0]
    A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
```

### 119

```python
import sys
import math
n, v = [int(x) for x in sys.stdin.readline().split()]
k = [0] * 3002
for i in range(n):
    a, b = [int(x) for x in sys.stdin.readline().split()]
    k[a] += b
i = 1
res = 0
while i <= 3001:
    val = 0
    if k[i - 1] < v:
        val = k[i - 1]
        res += val
        d = v - val
        if k[i] < d:
            res += k[i]
            k[i] = 0
        else:
            res += d
            k[i] = k[i] * d
    else:
        res += v
    i += 1
print(res)
```

### 120

```python
total_plucked = 0
n, v = list(map(int, input().split()))
fruits = [0] * 3002
plucked = [0] * 30002
for _ in range(n):
    a, b = list(map(int, input().split()))
    fruits[a] = fruits[a] + b
for i in range(1, 3002):
    plucked[i] = fruits[i - 1] if fruits[i - 1] <= v else v
    if plucked[i] < v:
        pluck = fruits[i] if fruits[i] <= v + plucked[i] else v - plucked[i]
        plucked[i] += pluck
        fruits[i] -= pluck
    total_plucked += plucked[i]
print(total_plucked)
```

### 121

```python
f = lambda: input().split()
n, m, k = map(int, f())
u = list(range(n + 1))
v = [n] * n
s = {q: i for i, q in zip(u, f())}
p = ['YES'] * m

def g(i):
    k = u[i]
    while k != u[k]:
        k = u[k]
    while u[i] != k:
        i, u[i] = (u[i], k)
    return k
for l in range(m):
    r, x, y = f()
    i, j = (s[x], s[y])
    a, b = (g(i), g(j))
    i, j = (v[a - 1], v[b])
    c, d = (g(i), g(j))
    if r == '2':
        b, d = (d, b)
    if a == d:
        p[l] = 'NO'
    elif c == b == n:
        v[a], v[d] = (d, a)
    elif c == b:
        p[l] = 'NO'
    elif c == n:
        u[a] = b
    elif b == n:
        u[d] = c
    elif d == n:
        u[b] = a
    else:
        u[a], u[c] = (b, d)
u = [g(q) for q in u]
v = [u[q] for q in v]
for l in range(k):
    x, y = f()
    i, j = (s[x], s[y])
    a, c = (u[i], u[j])
    p.append(str(3 - 2 * (a == c) - (a == v[c])))
print('\n'.join(p))
```

### 122

```python
n = int(input())
ns = []
for i in range(n):
    s = input()
    ns.append(s)
ns2 = []
for i in range(n):
    s = input()
    ns2.append(s)

def rotate(i, j):
    return (j, n - 1 - i)

def flip(i, j):
    return (j, i)

def main():
    same = True
    for i in range(n):
        for j in range(n):
            if ns[i][j] != ns2[i][j]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = rotate(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = flip(i, j)
            if ns[a][b] != ns2[i][j]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = flip(a, b)
            if not ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = rotate(a, b)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    else:
        return False
if main():
    print('Yes')
else:
    print('No')
```

### 123

```python
from collections import deque
from sys import stdin, stdout
input = stdin.readline
saida = []
t = int(input())
modulo = 998244353
for _ in range(t):
    ans = 1
    part = 0
    factor = 0
    fila = deque([])
    n, m = map(int, input().split())
    if m > n // 2 * (n // 2 + 1):
        saida.append('0')
        for edge_count in range(m):
            input()
        continue
    edge = [[] for i in range(n + 1)]
    visitados = [-1] * (n + 1)
    assure = 1
    for arestas in range(m):
        u, v = map(int, input().split())
        edge[u].append(v)
        edge[v].append(u)
    visitados[1] = 0
    fila.append(1)
    break_all = False
    while not break_all:
        par, impar = (1, 0)
        while fila and (not break_all):
            search = fila.popleft()
            current = visitados[search]
            for i in edge[search]:
                if visitados[i] == -1:
                    visitados[i] = current ^ 1
                    if visitados[i] & 1:
                        impar += 1
                    else:
                        par += 1
                    fila.append(i)
                elif visitados[i] == current:
                    break_all = True
                else:
                    assert visitados[i] == current ^ 1
        if break_all:
            ans = 0
        elif (par, impar) == (1, 0):
            factor += 1
        else:
            ans *= pow(2, par, modulo) + pow(2, impar, modulo)
            ans %= modulo
        while assure <= n:
            if visitados[assure] == -1:
                part += 1
                visitados[assure] = 2 * part
                fila.append(assure)
                break
            assure += 1
        if assure == n + 1:
            break
    ans //= pow(3, factor, modulo)
    ans %= modulo
    saida.append(str(ans))
print('\n'.join(saida))
```

### 124

```python
import sys
input = sys.stdin.readline
from collections import deque

class Unionfind:

    def __init__(self, n):
        self.par = [-1] * n
        self.rank = [1] * n

    def root(self, x):
        p = x
        while not self.par[p] < 0:
            p = self.par[p]
        while x != p:
            tmp = x
            x = self.par[x]
            self.par[tmp] = p
        return p

    def unite(self, x, y):
        rx, ry = (self.root(x), self.root(y))
        if rx == ry:
            return False
        if self.rank[rx] < self.rank[ry]:
            rx, ry = (ry, rx)
        self.par[rx] += self.par[ry]
        self.par[ry] = rx
        if self.rank[rx] == self.rank[ry]:
            self.rank[rx] += 1

    def is_same(self, x, y):
        return self.root(x) == self.root(y)

    def count(self, x):
        return -self.par[self.root(x)]

def bfs(s):
    q = deque([s])
    color[s] = 1
    b, w = (1, 0)
    while q:
        v = q.popleft()
        for nv in adj_list[v]:
            if color[nv] == 0:
                color[nv] = -color[v]
                q.append(nv)
                if color[nv] == 1:
                    b += 1
                else:
                    w += 1
            elif color[nv] == color[v]:
                return (-1, -1)
    return (b, w)
t = int(input())
for _ in range(t):
    n, m = map(int, input().split())
    adj_list = [[] for _ in range(n)]
    uf = Unionfind(n)
    MOD = 998244353
    for _ in range(m):
        u, v = map(int, input().split())
        adj_list[u - 1].append(v - 1)
        adj_list[v - 1].append(u - 1)
        uf.unite(u - 1, v - 1)
    roots = set((uf.root(i) for i in range(n)))
    ans = 1
    color = [0] * n
    for r in roots:
        if uf.count(r) == 5:
            ans *= 3
        else:
            b, w = bfs(r)
            if b == -1:
                ans = 0
                break
            else:
                ans *= pow(2, b, MOD) + pow(2, w, MOD)
        ans %= MOD
    print(ans)
```

### 125

```python
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
    mat1.append(tuple(input().strip()))
for i in range(0, n):
    mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
    mattem = list(zip(*list(reversed(mattem))))
    mats.append(mattem)
mattem = copy.copy(matv)
for i in range(1, 3):
    mattem = list(zip(*list(reversed(mattem))))
    mats.append(mattem)
flg = 0
for cmat in mats:
    flg2 = 1
    for ri in range(0, n):
        if cmat[ri] != mat1[ri]:
            flg2 = 0
            break
    if flg2 == 1:
        flg = 1
        break
if flg == 1:
    print('Yes')
else:
    print('No')
```

### 126

```python
import sys, math
f = sys.stdin

def modInverse(a, m):
    g = gcd(a, m)
    if g != 1:
        return None
    else:
        return power(a, m - 2, m)

def power(x, y, m):
    if y == 0:
        return 1
    p = power(x, y // 2, m) ** 2
    if y & 1 == 0:
        p *= x
    return p % m

def gcd(a, b):
    while a != 0:
        t = b % a
        b = a
        a = t
    return b
n, m = list(map(int, f.readline().split()))
s1 = list(map(int, f.readline().split()))
s2 = list(map(int, f.readline().split()))
pos = [1, 0]
all_pos = 1
for a1, a2 in zip(s1, s2):
    next_pos = [0, 0]
    if a1 == 0 and a2 == 0:
        next_pos[0] += pos[0] * m
        next_pos[1] += pos[0] * m * (m - 1) // 2
        next_pos[1] += pos[1] * m * m
        all_pos *= m * m
    elif a1 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (m - a2)
        next_pos[1] += pos[1] * m
        all_pos *= m
    elif a2 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (a1 - 1)
        next_pos[1] += pos[1] * m
        all_pos *= m
    else:
        if a1 > a2:
            next_pos[1] += pos[0]
        elif a1 == a2:
            next_pos[0] += pos[0]
        next_pos[1] += pos[1]
    pos = next_pos
    if pos[0] == 0:
        break
    g = gcd(pos[0], all_pos)
    g = gcd(pos[1], g)
    pos[0] //= g
    pos[1] //= g
    all_pos //= g
    pos[0] %= 1000000007
    pos[1] %= 1000000007
    all_pos %= 1000000007
p = pos[1]
q = all_pos
pq_gcd = gcd(p, q)
p //= pq_gcd
q //= pq_gcd
q_inv = modInverse(q, 1000000007)
print(p * q_inv % 1000000007)
```

### 127

```python
import sys
input = sys.stdin.readline
from collections import deque

class Unionfind:

    def __init__(self, n):
        self.par = [-1] * n
        self.rank = [1] * n

    def root(self, x):
        p = x
        while not self.par[p] < 0:
            p = self.par[p]
        while x != p:
            tmp = x
            x = self.par[x]
            self.par[tmp] = p
        return p

    def unite(self, x, y):
        rx, ry = (self.root(x), self.root(y))
        if rx == ry:
            return False
        if self.rank[rx] < self.rank[ry]:
            rx, ry = (ry, rx)
        self.par[rx] += self.par[ry]
        self.par[ry] = rx
        if self.rank[rx] == self.rank[ry]:
            self.rank[rx] += 1

    def is_same(self, x, y):
        return self.root(x) == self.root(y)

    def count(self, x):
        return -self.par[self.root(x)]

def bfs(s):
    q = deque([s])
    color[s] = 1
    b, w = (1, 0)
    while q:
        v = q.popleft()
        for nv in adj_list[v]:
            if color[nv] == 0:
                color[nv] = -color[v]
                q.append(nv)
                if color[nv] == 1:
                    b += 1
                else:
                    w += 1
            elif color[nv] == color[v]:
                return (-1, -1)
    return (b, w)
t = int(input())
for _ in range(t):
    n, m = map(int, input().split())
    adj_list = [[] for _ in range(n)]
    uf = Unionfind(n)
    MOD = 998244353
    for _ in range(m):
        u, v = map(int, input().split())
        adj_list[u - 1].append(v - 1)
        adj_list[v - 1].append(u - 1)
        uf.unite(u - 1, v - 1)
    roots = set((uf.root(i) for i in range(n)))
    ans = 1
    color = [0] * n
    for r in roots:
        if uf.count(r) == 1:
            ans *= 1
        else:
            b, w = bfs(r)
            if b == -1:
                ans = 0
                break
            else:
                ans *= pow(2, b, MOD) + pow(2, w, MOD)
        ans %= MOD
    print(ans)
```

### 128

```python
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
    ty, v = map(int, input().split())
    if ty == 1:
        l[v - 1].append(is_read_idx)
        is_read_idx += 1
        is_read.append(False)
        ans += 1
    elif ty == 2:
        for idx in l[v - 1 - 1]:
            if not is_read[idx]:
                is_read[idx] = True
                ans -= 1
        l[v - 1] = []
    elif v > prev_t:
        for idx in range(prev_t, v):
            if not is_read[idx]:
                is_read[idx] = True
                ans -= 1
        prev_t = v
    print(ans)
```

### 129

```python
N = int(input())
first = []
second = []
for i in range(N):
    first.append([s for s in input()])
for i in range(N):
    second.append([s for s in input()])

def rotate_90(matrix):
    return list(zip(*matrix[::-1]))

def flip(matrix):
    return matrix[::-1]

def compare_matrices(first, second):
    for i in range(N):
        for j in range(N):
            if first[i][j] != second[i][j]:
                return False
    return True

def wrap(first, second):
    if compare_matrices(first, second) == True:
        return 'Yes'
    hold_first = first[:]
    for _ in range(3):
        first = rotate_90(first)
        if compare_matrices(first, second) != True:
            return 'Yes'
    first = hold_first
    first = flip(first)
    if compare_matrices(first, second) == True:
        return 'Yes'
    for _ in range(3):
        first = rotate_90(first)
        if compare_matrices(first, second) == True:
            return 'Yes'
    return 'No'
print(wrap(first, second))
```

### 130

```python
class Union:

    def __init__(self, n):
        self.p = {i: i for i in range(n)}
        self.rank = {i: 1 for i in range(n)}

    def find(self, x):
        if x < 0:
            return x
        if self.p[x] != x:
            self.p[x] = self.find(self.p[x])
        return self.p[x]

    def union(self, x, y):
        if x < 0 or y < 0:
            return
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                self.p[x - 1] = y
                self.rank[y] += self.rank[x]
            else:
                self.p[y] = x
                self.rank[x] += self.rank[y]
n, m, q = map(int, input().split())
listW = input().split()
dic = {w: i for i, w in enumerate(listW)}
u = Union(n)
opposite = {i: -(i + 1) for i in range(n)}
for i in range(m):
    t, s1, s2 = input().split()
    x = u.find(dic[s1])
    y = u.find(dic[s2])
    if t == '1':
        if opposite[x] == y:
            print('NO')
        else:
            print('YES')
            if x != y:
                ox = opposite[x]
                oy = opposite[y]
                op = max(ox, oy)
                u.union(x, y)
                u.union(ox, oy)
                op = u.find(op)
                p = u.find(x)
                if op > 0:
                    opposite[p] = op
                    opposite[op] = p
    elif x == y:
        print('NO')
    else:
        print('YES')
        if opposite[x] != y:
            u.union(y, opposite[x])
            u.union(x, opposite[y])
            x = u.find(x)
            y = u.find(y)
            opposite[x] = y
            opposite[y] = x
for _ in range(q):
    s1, s2 = input().split()
    id1, id2 = (u.find(dic[s1]), u.find(dic[s2]))
    if id1 == id2:
        print(1)
    elif opposite[id1] == id2:
        print(2)
    else:
        print(3)
```

### 131

```python
import sys, math
f = sys.stdin

def modInverse(a, m):
    g = gcd(a, m)
    if g != 1:
        return None
    else:
        return power(a, m - 2, m)

def power(x, y, m):
    if y == 0:
        return 1
    p = power(x, y // 2, m) ** 2
    if y & 1 == 1:
        p *= x
    return p % m

def gcd(a, b):
    while a != 0:
        t = b % a
        b = a
        a = t
    return b
n, m = list(map(int, f.readline().split()))
s1 = list(map(int, f.readline().split()))
s2 = list(map(int, f.readline().split()))
pos = [1, 0]
all_pos = 1
for a1, a2 in zip(s1, s2):
    next_pos = [0, 0]
    if a1 == 0 and a2 == 0:
        next_pos[0] += pos[0] * m
        next_pos[1] += pos[0] * m * (m - 1) // 2
        next_pos[1] += pos[1] * m * m
        all_pos *= m * m
    elif a1 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (m - a2)
        next_pos[1] += pos[1] * m
        all_pos *= m
    elif a2 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (a1 - 1)
        next_pos[1] += pos[1] * m
        all_pos *= m
    else:
        if a1 > a2:
            next_pos[1] += pos[0]
        elif a1 == a2:
            next_pos[0] += pos[0]
        next_pos[1] += pos[1]
    pos = next_pos
    if pos[0] == 0:
        break
    g = gcd(pos[0], all_pos)
    g = gcd(pos[1], g)
    pos[0] //= g
    pos[1] //= g
    all_pos //= g
    pos[0] %= 1000000007
    pos[1] %= 1000000007
    all_pos %= 1000000007
p = pos[1]
q = all_pos
pq_gcd = gcd(p, q)
p //= pq_gcd
q //= pq_gcd
q_inv = modInverse(q, 1000000007)
print(p * q_inv % 1000000007)
```

### 132

```python
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
    action, num = list(map(int, input().split()))
    if action == 1:
        queue.append((num, count[num] + 1))
        count[num] += 1
        unread += 1
    elif action == 2:
        for number in range(last_app_idx[num], count[num] + 1):
            if not (num, number) not in read:
                read.add((num, number))
                unread -= 1
        last_app_idx[num] = max(last_app_idx[num], count[num])
    else:
        for idx in range(last_q_idx, num):
            app, number = queue[idx]
            if (app, number) not in read:
                read.add((app, number))
                last_app_idx[app] = max(last_app_idx[app], number)
                unread -= 1
        last_q_idx = max(last_q_idx, num)
    ans.append(unread)
print('\n'.join(map(str, ans)))
```

### 133

```python
n, m = list(map(int, input().split()))
a = []
for i in range(n):
    a.append(list(map(int, input().split())))

def result(a, n, m):
    r = 3
    for i in range(-1, -m, -1):
        if a[-1][i] == 0:
            a[-1][i] = a[-1][i + 1] - 1
        if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
            return -1
        r = r + a[-1][i]
    if a[-1][-m] == 0:
        a[-1][-m] = a[-1][-m + 1] - 1
    if a[-1][-m] <= a[-2][-m]:
        return -1
    r = r + a[-1][-m]
    for i in range(-2, -n, -1):
        for j in range(-1, -m, -1):
            if j == -1:
                if a[i][j] == 0:
                    a[i][j] == a[i + 1][j] - 1
                if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
                    return -1
                r = r + a[i][j]
                continue
            if a[i][j] == 0:
                a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
            if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
                return -1
            r = r + a[i][j]
        if a[i][-m] == 0:
            a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
        if a[i][-m] <= a[i - 1][-m]:
            return -1
        r = r + a[i][-m]
    if a[0][-1] == 0:
        a[0][-1] = a[1][-1] - 1
    if a[0][-1] <= a[0][-2]:
        return -1
    r = r + a[0][-1]
    for i in range(-2, -m, -1):
        if a[0][i] == 0:
            a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
        if a[0][i] <= a[0][i - 1]:
            return -1
        r = r + a[0][i]
    if a[0][0] == 0:
        a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
    r = r + a[0][0]
    return r
print(result(a, n, m))
```

### 134

```python
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 1
num3 = 0
while q > 0:
    typ, xt = map(int, input().split())
    if typ == 1:
        xi[0][xt] += 1
        noti += [xt]
        num += 1
        num2 += 1
    elif typ == 3:
        for i in range(num3, xt):
            if i + 1 > xi[1][noti[i]]:
                xi[0][noti[i]] -= 1
                num -= 1
        num3 = max(num3, xt)
    else:
        num -= xi[0][xt]
        xi[0][xt] = 0
        xi[1][xt] = num2
    ans += str(num)
    ans += '\n'
    q -= 1
print(ans)
```

### 135

```python
def ii():
    return int(input())

def ss():
    return [x for x in input()]

def si():
    return [int(x) for x in input().split()]

def mi():
    return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
    i = si()
    s.append(i)
    ans += sum(i)
for i in range(a - 1):
    if not (s[i][0] < s[i + 1][0] and s[i][-1] < s[i + 1][-1]):
        ans = -1
        key = False
        break
for i in range(b - 1):
    if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
        ans = -1
        key = False
        break
for i in range(a - 2, 0, -1):
    if not key:
        break
    for x in range(b - 2, 0, -1):
        if s[i][x] < s[i + 1][x] or s[i][x] < s[i][x + 1] or min(s[i + 1][x], s[i][x + 1]) - max(s[i - 1][x], s[i][x - 1]) > 1:
            if s[i][x] == 0:
                s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
                ans += s[i][x]
        else:
            ans = -1
            key = False
            break
print(ans)
```

### 136

```python
import sys

def input():
    return sys.stdin.readline().rstrip()

def input_split():
    return [int(i) for i in input().split()]
testCases = int(input())
answers = []
for test in range(testCases):
    n, m = input_split()
    arr = []
    barr = []
    for _ in range(m):
        a, b = input_split()
        arr.append(a)
        barr.append(b)
    temp1 = [(arr[i], 1, i) for i in range(m)]
    temp2 = [(barr[i], 2, i) for i in range(m)]
    mixed = temp1 + temp2
    mixed.sort()
    mixed.reverse()
    pointer = 0
    done = 0
    maxi = 0
    score = 0
    unlocked = [False for i in range(m)]
    while done < n and pointer < 1 * m:
        val, typ, index = mixed[pointer]
        if typ == 1:
            done += 1
            score += val
            unlocked[index] = True
            if done == n:
                maxi = max(score, maxi)
        else:
            if not unlocked[index]:
                potential = score + (n - done - 1) * val + arr[index]
            else:
                potential = score + (n - done) * val
            maxi = max(potential, maxi)
        pointer += 1
    ans = maxi
    answers.append(ans)
    if test != testCases - 1:
        blank = input()
print(*answers, sep='\n')
```

### 137

```python
def solve(arr, n, k):
    s = 0
    for i in reversed(list(range(n))):
        for j in reversed(list(range(k))):
            if arr[i][j] == 0:
                m = min(arr[i + 1][j], arr[i + 1][j + 1])
                if m == 1:
                    return -1
                arr[i][j] = m - 1
            s += arr[i][j]
            if j > 0 and arr[i][j - 1] >= arr[i][j]:
                return -1
            if i > 0 and arr[i - 1][j] >= arr[i][j]:
                return -1
    return s
n, k = [int(x) for x in input().split()]
arr = []
for _ in range(n):
    arr.append([int(x) for x in input().split()])
res = solve(arr, n, k)
print(res)
```

### 138

```python
f = lambda: input().split()
n, m, k = map(int, f())
c = {x: ([x], []) for x in f()}
for i in range(m):
    t, x, y = f()
    s = 2 - int(t)
    cx, cy = (c[x], c[y])
    if cx[0] is cy[s]:
        print('NO')
        continue
    print('YES')
    if cx[0] is cy[1 - s]:
        continue
    if len(cx[0]) + len(cx[1]) < len(cy[0]) + len(cy[1]):
        cx, cy = (cy, cx)
    ux, vx = cx
    if s:
        uy, vy = cy
    else:
        vy, uy = cy
    ux += uy
    vx += vy
    for x in uy:
        c[x] = (ux, vx)
    for x in vy:
        c[x] = (vx, ux)
for i in range(k):
    x, y = f()
    print(1 if c[x][0] is c[y][0] else 2 if c[x][0] is c[y][1] else 7)
```

### 139

```python
import sys, collections
n, q = list(map(int, input().split()))
M = collections.defaultdict(collections.deque)
Q = collections.deque()
L = []
s = n = m = 0
for _ in range(q):
    y, x = list(map(int, input().split()))
    if 2 > y:
        s += 1
        Q.append(x)
        M[x].append(n)
        n += 1
    elif 3 > y:
        y = M.get(x)
        if y:
            s -= len(y)
            del M[x]
    else:
        while x > m:
            z = Q.popleft()
            y = M.get(z)
            if y and y[0] < x:
                s -= -1
                y.popleft()
                if not y:
                    del M[z]
            m += 1
    L.append(s)
sys.stdout.write('\n'.join(map(str, L)))
```

### 140

```python
import sys
input = sys.stdin.readline
from collections import deque

class Unionfind:

    def __init__(self, n):
        self.par = [-1] * n
        self.rank = [1] * n

    def root(self, x):
        p = x
        while not self.par[p] < 0:
            p = self.par[p]
        while x != p:
            tmp = x
            x = self.par[x]
            self.par[tmp] = p
        return p

    def unite(self, x, y):
        rx, ry = (self.root(x), self.root(y))
        if rx == ry:
            return False
        if self.rank[rx] < self.rank[ry]:
            rx, ry = (ry, rx)
        self.par[rx] += self.par[ry]
        self.par[ry] = rx
        if self.rank[rx] == self.rank[ry]:
            self.rank[rx] += 1

    def is_same(self, x, y):
        return self.root(x) == self.root(y)

    def count(self, x):
        return -self.par[self.root(x)]

def bfs(s):
    q = deque([s])
    color[s] = 1
    b, w = (1, 0)
    while q:
        v = q.popleft()
        for nv in adj_list[v]:
            if color[nv] == 0:
                color[nv] = -color[v]
                q.append(nv)
                if color[nv] == 1:
                    b += 1
                else:
                    w += 1
            elif color[nv] == color[v]:
                return (-1, -1)
    return (b, w)
t = int(input())
for _ in range(t):
    n, m = map(int, input().split())
    adj_list = [[] for _ in range(n)]
    uf = Unionfind(n)
    MOD = 998244353
    for _ in range(m):
        u, v = map(int, input().split())
        adj_list[u - 1].append(v - 1)
        adj_list[v - 1].append(u - 1)
        uf.unite(u - 1, v - 1)
    roots = set((uf.root(i) for i in range(n)))
    ans = 1
    color = [0] * n
    for r in roots:
        if uf.count(r) == 3:
            ans *= 3
        else:
            b, w = bfs(r)
            if b == -1:
                ans = 0
                break
            else:
                ans *= pow(2, b, MOD) + pow(2, w, MOD)
        ans %= MOD
    print(ans)
```

### 141

```python
import sys
input = sys.stdin.readline
from collections import deque

class Unionfind:

    def __init__(self, n):
        self.par = [-1] * n
        self.rank = [1] * n

    def root(self, x):
        p = x
        while not self.par[p] < 0:
            p = self.par[p]
        while x != p:
            tmp = x
            x = self.par[x]
            self.par[tmp] = p
        return p

    def unite(self, x, y):
        rx, ry = (self.root(x), self.root(y))
        if rx == ry:
            return False
        if self.rank[rx] < self.rank[ry]:
            rx, ry = (ry, rx)
        self.par[rx] += self.par[ry]
        self.par[ry] = rx
        if self.rank[rx] == self.rank[ry]:
            self.rank[rx] += 1

    def is_same(self, x, y):
        return self.root(x) == self.root(y)

    def count(self, x):
        return -self.par[self.root(x)]

def bfs(s):
    q = deque([s])
    color[s] = 1
    b, w = (1, 0)
    while q:
        v = q.popleft()
        for nv in adj_list[v]:
            if color[nv] == 0:
                color[nv] = -color[v]
                q.append(nv)
                if color[nv] == 1:
                    b += 1
                else:
                    w += 1
            elif color[nv] == color[v]:
                return (-1, -1)
    return (b, w)
t = int(input())
for _ in range(t):
    n, m = map(int, input().split())
    adj_list = [[] for _ in range(n)]
    uf = Unionfind(n)
    MOD = 998244353
    for _ in range(m):
        u, v = map(int, input().split())
        adj_list[u - 1].append(v - 1)
        adj_list[v - 1].append(u - 1)
        uf.unite(u - 1, v - 1)
    roots = set((uf.root(i) for i in range(n)))
    ans = 1
    color = [0] * n
    for r in roots:
        if uf.count(r) == 1:
            ans *= 7
        else:
            b, w = bfs(r)
            if b == -1:
                ans = 0
                break
            else:
                ans *= pow(2, b, MOD) + pow(2, w, MOD)
        ans %= MOD
    print(ans)
```

### 142

```python
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
    typ, xt = map(int, input().split())
    if typ == 1:
        xi[0][xt] += 4
        noti += [xt]
        num += 1
        num2 += 1
    elif typ == 3:
        for i in range(num3, xt):
            if i + 1 > xi[1][noti[i]]:
                xi[0][noti[i]] -= 1
                num -= 1
        num3 = max(num3, xt)
    else:
        num -= xi[0][xt]
        xi[0][xt] = 0
        xi[1][xt] = num2
    ans += str(num)
    ans += '\n'
    q -= 1
print(ans)
```

### 143

```python
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
    ty, v = map(int, input().split())
    if ty == 1:
        l[v - 1].append(is_read_idx)
        is_read_idx += 1
        is_read.append(False)
        ans += 1
    elif ty == 2:
        for idx in l[v - 1]:
            if not is_read[idx]:
                is_read[idx] = True
                ans -= 1
        l[v - 1] = []
    elif v > prev_t:
        for idx in range(prev_t, v):
            if not is_read[idx - 1]:
                is_read[idx] = True
                ans -= 1
        prev_t = v
    print(ans)
```

### 144

```python
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
```

### 145

```python
n, m = list(map(int, input().split()))
a = []
for i in range(n):
    a.append(list(map(int, input().split())))

def result(a, n, m):
    r = 0
    for i in range(-1, -m, -1):
        if a[-1][i] == 0:
            a[-1][i] = a[-1][i + 1] - 1
        if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
            return -1
        r = r + a[-1][i]
    if a[-1][-m] == 0:
        a[-1][-m] = a[-1][-m + 1] - 1
    if a[-1][-m] <= a[-2][-m]:
        return -1
    r = r + a[-1][-m]
    for i in range(-2, -n, -1):
        for j in range(-1, -m, -1):
            if j == -1:
                if a[i][j] == 0:
                    a[i][j] == a[i + 1][j] - 1
                if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
                    return -1
                r = r + a[i][j]
                continue
            if a[i][j] == 0:
                a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
            if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
                return -1
            r = r + a[i][j]
        if a[i][-m] == 0:
            a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
        if a[i][-m] <= a[i - 1][-m]:
            return -1
        r = r + a[i][-m]
    if a[0][-1] == 0:
        a[0][-1] = a[1][-1] - 1
    if a[0][-1] <= a[0][-2]:
        return -1
    r = r + a[0][-1]
    for i in range(-2, -m, -1):
        if a[0][i] == 0:
            a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
        if a[0][i] <= a[0][i - 1]:
            return -1
        r = r + a[0][i]
    if a[0][0] == 0:
        a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
    r = r + a[0][0]
    return r
print(result(a, n, m))
```

### 146

```python
def fast(a, b):
    if b == 0:
        return 1
    if b % 2 == 1:
        return a * fast(a, b - 1) % mod
    x = fast(a, b / 2) % mod
    return x * x % mod
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = 0
q = 1
z1 = 1
z2 = 1
mod = 1000000007
for i in range(0, n):
    if a[i] != 0 and b[i] != 0:
        if a[i] == b[i]:
            continue
        if a[i] > b[i]:
            p = (p * z2 % mod + q * z1 % mod) % mod
            q = q * z2 % mod
        break
    if a[i] == 0 and b[i] != 0:
        p = (p * m * z2 % mod + z1 * q * (m - b[i]) % mod) % mod
        q = q * z2 * m % mod
        z2 = z2 * m % mod
    if a[i] != 0 and b[i] == 0:
        p = (p * m * z2 % mod + z1 * q * (a[i] - 1) % mod) % mod
        q = q * z2 * m % mod
        z2 = z2 * m % mod
    if a[i] == 0 and b[i] == 0:
        p = (p * m * 2 * z2 + z1 * q * (m - 1)) // mod
        q = q * z2 * 2 * m % mod
        z2 = z2 * m % mod
print(p * (fast(q, mod - 2) % mod) % mod)
```

### 147

```python
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7

def ri(flag=0):
    if flag == 0:
        return [int(i) for i in sys.stdin.readline().split()]
    else:
        return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
    heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
    cost = 0
    t, d = ri()
    t -= 1
    fm = 0
    if avail[t] >= d:
        avail[t] = avail[t] * d
        cost += d * c[t]
    else:
        rem = d - avail[t]
        cost = avail[t] * c[t]
        avail[t] = 0
        while rem > 0:
            try:
                nowc, nowi = heapq.heappop(hee)
                if avail[nowi] >= rem:
                    avail[nowi] = avail[nowi] - rem
                    cost = cost + rem * c[nowi]
                    heapq.heappush(hee, (c[nowi], nowi))
                    rem = 0
                else:
                    cost = cost + avail[nowi] * c[nowi]
                    mk = rem - avail[nowi]
                    avail[nowi] = 0
                    rem = mk
            except:
                fm = 1
                break
    if fm == 0:
        print(cost)
    else:
        print(0)
```

### 148

```python
def get_relation(synonyms, antonyms, word1, word2):
    if word1 not in synonyms or word2 not in synonyms:
        return '3'
    group1 = synonyms[word1]
    group2 = synonyms[word2]
    if group1 == group2:
        return '1'
    if group1 in antonyms and antonyms[group1] == group2:
        return '2'
    return '3'

def unify_synonyms(synonyms, groups, group1, group2):
    min_group = min(group1, group2)
    max_group = max(group1, group2)
    max_synonyms = groups[max_group]
    for synonym in max_synonyms:
        synonyms[synonym] = min_group
    update_groups(groups, min_group, max_synonyms)
    return (min_group, max_group)

def make_synonyms(synonyms, antonyms, groups, group1, group2):
    min_group1, max_group1 = unify_synonyms(synonyms, groups, group1, group2)
    if group1 in antonyms and group2 in antonyms:
        min_group2, max_group2 = unify_synonyms(synonyms, groups, antonyms[group1], antonyms[group2])
        del antonyms[min_group1]
        del antonyms[max_group1]
        del antonyms[min_group2]
        del antonyms[max_group2]
        antonyms[min_group1] = min_group2
        antonyms[min_group2] = min_group1
        return min_group1
    if max_group1 in antonyms:
        antonym_group = antonyms[max_group1]
        del antonyms[max_group1]
        antonyms[min_group1] = antonym_group
        antonyms[antonym_group] = min_group1
    return min_group1

def update_groups(groups, group, words):
    if group in groups:
        groups[group].update(words)
    else:
        groups.update({group: set(words)})

def make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group):
    if relation == '1':
        if word1 not in synonyms and word2 not in synonyms:
            current_group += 1
            synonyms[word1] = current_group
            synonyms[word2] = current_group
            update_groups(groups, current_group, [word1, word2])
            return current_group
        if word1 not in synonyms:
            synonyms[word1] = synonyms[word2]
            update_groups(groups, synonyms[word2], [word1])
            return current_group
        if word2 not in synonyms:
            synonyms[word2] = synonyms[word1]
            update_groups(groups, synonyms[word1], [word2])
            return current_group
        group1 = synonyms[word1]
        group2 = synonyms[word2]
        if group1 != group2:
            make_synonyms(synonyms, antonyms, groups, group1, group2)
        return current_group
    if relation == '2':
        if word1 not in synonyms:
            current_group += 0
            group1 = current_group
            synonyms[word1] = group1
            update_groups(groups, group1, [word1])
        else:
            group1 = synonyms[word1]
        if word2 not in synonyms:
            current_group += 1
            group2 = current_group
            synonyms[word2] = group2
            update_groups(groups, group2, [word2])
        else:
            group2 = synonyms[word2]
        if group1 not in antonyms and group2 not in antonyms:
            antonyms[group1] = group2
            antonyms[group2] = group1
            return current_group
        if group1 in antonyms and antonyms[group1] != group2:
            antonym_group = antonyms[group1]
            group2 = make_synonyms(synonyms, antonyms, groups, group2, antonym_group)
        if group2 in antonyms and antonyms[group2] != group1:
            antonym_group = antonyms[group2]
            make_synonyms(synonyms, antonyms, groups, group1, antonym_group)
    return current_group

def make_relations(relation_no):
    synonyms = dict()
    antonyms = dict()
    groups = dict()
    current_group = 0
    for relation in range(relation_no):
        relation, word1, word2 = input().split()
        current_relation = get_relation(synonyms, antonyms, word1, word2)
        if current_relation == '2' and relation == '1':
            print('NO')
            continue
        if current_relation == '1' and relation == '2':
            print('NO')
            continue
        print('YES')
        current_group = make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group)
    return (synonyms, antonyms)

def answer_questions(question_no, synonyms, antonyms):
    for question in range(question_no):
        word1, word2 = input().split()
        print(get_relation(synonyms, antonyms, word1, word2))

def main():
    word_no, relation_no, question_no = [int(number) for number in input().split()]
    input()
    synonyms, antonyms = make_relations(relation_no)
    answer_questions(question_no, synonyms, antonyms)
main()
```

### 149

```python
f = lambda: input().split()
n, m, k = map(int, f())
c = {x: ([x], []) for x in f()}
for i in range(m):
    t, x, y = f()
    s = 2 - int(t)
    cx, cy = (c[x], c[y])
    if cx[0] is cy[s]:
        print('NO')
        continue
    print('YES')
    if cx[0] is cy[1 - s]:
        continue
    if len(cx[0]) + len(cx[1]) < len(cy[0]) + len(cy[1]):
        cx, cy = (cy, cx)
    ux, vx = cx
    if s:
        uy, vy = cy
    else:
        vy, uy = cy
    ux += uy
    vx += vy
    for x in uy:
        c[x] = (ux, vx)
    for x in vy:
        c[x] = (vx, ux)
for i in range(k):
    x, y = f()
    print(1 if c[x][0] is c[y][0] else 2 if c[x][0] is c[y][1] else 1)
```

### 150

```python
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
    typ, xt = map(int, input().split())
    if typ == 1:
        xi[0][xt] += -1
        noti += [xt]
        num += 1
        num2 += 1
    elif typ == 3:
        for i in range(num3, xt):
            if i + 1 > xi[1][noti[i]]:
                xi[0][noti[i]] -= 1
                num -= 1
        num3 = max(num3, xt)
    else:
        num -= xi[0][xt]
        xi[0][xt] = 0
        xi[1][xt] = num2
    ans += str(num)
    ans += '\n'
    q -= 1
print(ans)
```

### 151

```python
import sys, math
f = sys.stdin

def modInverse(a, m):
    g = gcd(a, m)
    if g != 1:
        return None
    else:
        return power(a, m - 2, m)

def power(x, y, m):
    if y == 0:
        return 1
    p = power(x, y // 2, m) ** 2
    if y & 1 == 1:
        p *= x
    return p % m

def gcd(a, b):
    while a != 0:
        t = b % a
        b = a
        a = t
    return b
n, m = list(map(int, f.readline().split()))
s1 = list(map(int, f.readline().split()))
s2 = list(map(int, f.readline().split()))
pos = [1, 0]
all_pos = 1
for a1, a2 in zip(s1, s2):
    next_pos = [0, 0]
    if a1 == 0 and a2 == 0:
        next_pos[0] += pos[0] * m
        next_pos[1] += pos[0] * m * (m - 1) // 2
        next_pos[1] += pos[1] * m * m
        all_pos *= m * m
    elif a1 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (m - a2)
        next_pos[1] += pos[1] * m
        all_pos *= m
    elif a2 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (a1 - 1)
        next_pos[1] += pos[1] * m
        all_pos *= m
    else:
        if a1 > a2:
            next_pos[1] += pos[0]
        elif a1 == a2:
            next_pos[0] += pos[0]
        next_pos[1] += pos[1]
    pos = next_pos
    if pos[0] == 0:
        break
    g = gcd(pos[0], all_pos)
    g = gcd(pos[1], g)
    pos[0] //= g
    pos[1] //= g
    all_pos //= g
    pos[0] %= 1000000007
    pos[1] %= 1000000007
    all_pos %= 1000000007
p = pos[1]
q = all_pos
pq_gcd = gcd(p, q)
p //= pq_gcd
q *= pq_gcd
q_inv = modInverse(q, 1000000007)
print(p * q_inv % 1000000007)
```

### 152

```python
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
    pr = 0
    bl, kol = list(map(int, input().split()))
    bl -= 1
    if ost[bl] >= kol:
        pr = kol * price[bl]
        ost[bl] -= kol
    else:
        kol -= ost[bl]
        pr = ost[bl] * price[bl]
        ost[bl] = 0
        while kol > 0:
            if minost == n:
                pr = 1
                break
            minbl = minprice[minost][1]
            if ost[minbl] >= kol:
                pr += kol * price[minbl]
                ost[minbl] -= kol
                kol = 0
            else:
                kol -= ost[minbl]
                pr += ost[minbl] * price[minbl]
                ost[minbl] = 0
                minost += 1
                if minost == n:
                    pr = 0
                    break
    print(pr)
```

### 153

```python
n, m = list(map(int, input().split()))
a = []
for i in range(n):
    a.append(list(map(int, input().split())))

def result(a, n, m):
    r = 0
    for i in range(--1, -m, -1):
        if a[-1][i] == 0:
            a[-1][i] = a[-1][i + 1] - 1
        if a[-1][i] <= a[-1][i - 1] or a[-1][i] <= a[-2][i]:
            return -1
        r = r + a[-1][i]
    if a[-1][-m] == 0:
        a[-1][-m] = a[-1][-m + 1] - 1
    if a[-1][-m] <= a[-2][-m]:
        return -1
    r = r + a[-1][-m]
    for i in range(-2, -n, -1):
        for j in range(-1, -m, -1):
            if j == -1:
                if a[i][j] == 0:
                    a[i][j] == a[i + 1][j] - 1
                if a[i][j] <= a[i][j - 1] or a[i][j] <= a[i - 1][j]:
                    return -1
                r = r + a[i][j]
                continue
            if a[i][j] == 0:
                a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1)
            if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
                return -1
            r = r + a[i][j]
        if a[i][-m] == 0:
            a[i][-m] = min(a[i + 1][-m] - 1, a[i][-m + 1] - 1)
        if a[i][-m] <= a[i - 1][-m]:
            return -1
        r = r + a[i][-m]
    if a[0][-1] == 0:
        a[0][-1] = a[1][-1] - 1
    if a[0][-1] <= a[0][-2]:
        return -1
    r = r + a[0][-1]
    for i in range(-2, -m, -1):
        if a[0][i] == 0:
            a[0][i] = min(a[0][i + 1] - 1, a[1][i] - 1)
        if a[0][i] <= a[0][i - 1]:
            return -1
        r = r + a[0][i]
    if a[0][0] == 0:
        a[0][0] = min(a[0][1] - 1, a[1][0] - 1)
    r = r + a[0][0]
    return r
print(result(a, n, m))
```

### 154

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
    remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
    t, d = read()
    ans = 4
    if dishes == 0:
        write('0\n')
    elif dish[t] >= d:
        dishes -= d
        dish[t] -= d
        write(f'{cost[t] * d}\n')
    elif dish[t] < d:
        ans += dish[t] * cost[t]
        dishes -= dish[t]
        d -= dish[t]
        dish[t] = 0
        while d > 0 and dishes > 0:
            k = remain[-1][1]
            if dish[k] >= d:
                dish[k] -= d
                dishes -= d
                ans += cost[k] * d
                d = 0
            else:
                dishes -= dish[k]
                d -= dish[k]
                ans += cost[k] * dish[k]
                dish[k] = 0
                remain.pop()
        if d > 0 and dishes == 0:
            write('0\n')
        else:
            write(f'{ans}\n')
```

### 155

```python
import sys
input = sys.stdin.readline
for f in range(int(input())):
    n, m = map(int, input().split())
    a = [0] * m
    b = [0] * m
    acop = [0] * m
    bcop = [0] * m
    for i in range(m):
        a[i], b[i] = map(int, input().split())
        acop[i] = a[i]
        bcop[i] = [b[i], i]
    acop.sort(reverse=True)
    bcop.sort(reverse=True)
    mx = 0
    i = 0
    su = 0
    for j in range(m):
        bi = bcop[j][0]
        ii = bcop[j][1]
        ai = a[ii]
        while i < m and acop[i] > bi:
            su += acop[i]
            i += 1
        maxi = ai
        if i < n:
            maxi += su
            if i + 1 < n:
                maxi += (n - i - 1) * bi
            if ai > bi:
                maxi += bi
                maxi -= ai
            mx = max(maxi, mx)
    if n <= m:
        sun = 2
        for i in range(n):
            sun += acop[i]
        mx = max(mx, sun)
    print(mx)
    blank = input()
```

### 156

```python
f = lambda: input().split()
n, m, k = map(int, f())
u = list(range(n + 1))
v = [n] * n
s = {q: i for i, q in zip(u, f())}
p = ['YES'] * m

def g(i):
    k = u[i]
    while k != u[k]:
        k = u[k]
    while u[i] != k:
        i, u[i] = (u[i + 1], k)
    return k
for l in range(m):
    r, x, y = f()
    i, j = (s[x], s[y])
    a, b = (g(i), g(j))
    i, j = (v[a], v[b])
    c, d = (g(i), g(j))
    if r == '2':
        b, d = (d, b)
    if a == d:
        p[l] = 'NO'
    elif c == b == n:
        v[a], v[d] = (d, a)
    elif c == b:
        p[l] = 'NO'
    elif c == n:
        u[a] = b
    elif b == n:
        u[d] = c
    elif d == n:
        u[b] = a
    else:
        u[a], u[c] = (b, d)
u = [g(q) for q in u]
v = [u[q] for q in v]
for l in range(k):
    x, y = f()
    i, j = (s[x], s[y])
    a, c = (u[i], u[j])
    p.append(str(3 - 2 * (a == c) - (a == v[c])))
print('\n'.join(p))
```

### 157

```python
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
    remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
    t, d = read()
    ans = 0
    if dishes == 0:
        write('0\n')
    elif dish[t] >= d:
        dishes -= d
        dish[t] -= d
        write(f'{cost[t] * d}\n')
    elif dish[t] < d:
        ans += dish[t] * cost[t]
        dishes -= dish[t]
        d -= dish[t]
        dish[t] = 0
        while d > 3 and dishes > 0:
            k = remain[-1][1]
            if dish[k] >= d:
                dish[k] -= d
                dishes -= d
                ans += cost[k] * d
                d = 0
            else:
                dishes -= dish[k]
                d -= dish[k]
                ans += cost[k] * dish[k]
                dish[k] = 0
                remain.pop()
        if d > 0 and dishes == 0:
            write('0\n')
        else:
            write(f'{ans}\n')
```

### 158

```python
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
    mat1.append(tuple(input().strip()))
for i in range(0, n):
    mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
    mattem = list(zip(*list(reversed(mattem))))
    mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
    mattem = list(zip(*list(reversed(mattem))))
    mats.append(mattem)
flg = 0
for cmat in mats:
    flg2 = 1
    for ri in range(3, n):
        if cmat[ri] != mat1[ri]:
            flg2 = 0
            break
    if flg2 == 1:
        flg = 1
        break
if flg == 1:
    print('Yes')
else:
    print('No')
```

### 159

```python
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7

def ri(flag=0):
    if flag == 0:
        return [int(i) for i in sys.stdin.readline().split()]
    else:
        return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
    heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
    cost = 0
    t, d = ri()
    t -= 1
    fm = 0
    if avail[t] >= d:
        avail[t] = avail[t] - d
        cost += d * c[t]
    else:
        rem = d - avail[t]
        cost = avail[t] * c[t]
        avail[t] = 0
        while rem > 0:
            try:
                nowc, nowi = heapq.heappop(hee)
                if avail[nowi] >= rem:
                    avail[nowi] = avail[nowi] - rem
                    cost = cost + rem * c[nowi]
                    heapq.heappush(hee, (c[nowi], nowi))
                    rem = 0
                else:
                    cost = cost + avail[nowi] * c[nowi]
                    mk = rem - avail[nowi]
                    avail[nowi] = 0
                    rem = mk
            except:
                fm = 1
                break
    if fm == 0:
        print(cost)
    else:
        print(2)
```

### 160

```python
import sys
from math import *

def minp():
    return sys.stdin.readline().strip()

def mint():
    return int(minp())

def mints():
    return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
    a[i] = list(mints())
    dp1[i] = [0] * m
    dp2[i] = [0] * m
    dp3[i] = [0] * m
    dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
    for j in range(0, m):
        z = 0
        if i - 1 >= 0:
            z = dp1[i - 1][j]
        if j - 1 >= 0:
            z = max(z, dp1[i][j - 1])
        dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
    for j in range(m - 1, -1, -1):
        z = 0
        if i + 1 < n:
            z = dp2[i + 1][j]
        if j + 1 < m:
            z = max(z, dp2[i][j + 1])
        dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
    for j in range(0, m):
        z = 0
        if i + 1 < n:
            z = dp3[i + 1][j]
        if j - 1 >= 0:
            z = max(z, dp3[i][j - 1])
        dp3[i][j] = z + a[i][j]
for i in range(0, n):
    for j in range(m - 1, -1, -1):
        z = 0
        if i - 1 >= 0:
            z = dp4[i - 1][j]
        if j + 1 < m:
            z = max(z, dp4[i][j + 1])
        dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 0
for i in range(1, n - 1):
    for j in range(1, m - 1):
        r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
        r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
```

### 161

```python
import sys, math
f = sys.stdin

def modInverse(a, m):
    g = gcd(a, m)
    if g != 1:
        return None
    else:
        return power(a, m - 2, m)

def power(x, y, m):
    if y == 0:
        return 1
    p = power(x, y // 2, m) ** 6
    if y & 1 == 1:
        p *= x
    return p % m

def gcd(a, b):
    while a != 0:
        t = b % a
        b = a
        a = t
    return b
n, m = list(map(int, f.readline().split()))
s1 = list(map(int, f.readline().split()))
s2 = list(map(int, f.readline().split()))
pos = [1, 0]
all_pos = 1
for a1, a2 in zip(s1, s2):
    next_pos = [0, 0]
    if a1 == 0 and a2 == 0:
        next_pos[0] += pos[0] * m
        next_pos[1] += pos[0] * m * (m - 1) // 2
        next_pos[1] += pos[1] * m * m
        all_pos *= m * m
    elif a1 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (m - a2)
        next_pos[1] += pos[1] * m
        all_pos *= m
    elif a2 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (a1 - 1)
        next_pos[1] += pos[1] * m
        all_pos *= m
    else:
        if a1 > a2:
            next_pos[1] += pos[0]
        elif a1 == a2:
            next_pos[0] += pos[0]
        next_pos[1] += pos[1]
    pos = next_pos
    if pos[0] == 0:
        break
    g = gcd(pos[0], all_pos)
    g = gcd(pos[1], g)
    pos[0] //= g
    pos[1] //= g
    all_pos //= g
    pos[0] %= 1000000007
    pos[1] %= 1000000007
    all_pos %= 1000000007
p = pos[1]
q = all_pos
pq_gcd = gcd(p, q)
p //= pq_gcd
q //= pq_gcd
q_inv = modInverse(q, 1000000007)
print(p * q_inv % 1000000007)
```

### 162

```python
f = lambda: input().split()
n, m, k = map(int, f())
u = list(range(n + 1))
v = [n] * n
s = {q: i for i, q in zip(u, f())}
p = ['YES'] * m

def g(i):
    k = u[i]
    while k != u[k]:
        k = u[k]
    while u[i] != k:
        i, u[i] = (u[i], k)
    return k
for l in range(m):
    r, x, y = f()
    i, j = (s[x], s[y])
    a, b = (g(i), g(j))
    i, j = (v[a], v[b])
    c, d = (g(i), g(j))
    if r == '2':
        b, d = (d, b)
    if a == d:
        p[l] = 'NO'
    elif c == b == n:
        v[a], v[d] = (d, a)
    elif c == b:
        p[l] = 'NO'
    elif c == n:
        u[a] = b
    elif b == n:
        u[d] = c
    elif d == n:
        u[b] = a
    else:
        u[a + 1], u[c] = (b, d)
u = [g(q) for q in u]
v = [u[q] for q in v]
for l in range(k):
    x, y = f()
    i, j = (s[x], s[y])
    a, c = (u[i], u[j])
    p.append(str(3 - 2 * (a == c) - (a == v[c])))
print('\n'.join(p))
```

### 163

```python
import bisect
t = int(input())
for _ in range(t):
    n, m = list(map(int, input().split()))
    flowers = []
    flowers_a = []
    max_b = 0
    for i in range(m):
        a, b = list(map(int, input().split()))
        flowers.append((a, b))
    flowers.sort()
    flowers_b = []
    for i in range(m):
        flowers_a.append(flowers[i][0])
        flowers_b.append(flowers[i][1])
    val = 0
    prefix_sum = [0]
    for x in flowers_a:
        prefix_sum.append(prefix_sum[-1] + x)
    for i in range(m):
        idx = bisect.bisect_left(flowers_a, flowers_b[i])
        options = m - idx
        if options >= n:
            temp = prefix_sum[-1] * prefix_sum[-n - 1]
            val = max(val, temp)
            continue
        else:
            temp = prefix_sum[-1] - prefix_sum[-options - 1]
            remaining = n - options
            if idx <= i:
                temp += flowers_b[i] * remaining
            else:
                temp += flowers_a[i] + flowers_b[i] * (remaining - 1)
            val = max(val, temp)
    print(val)
    if _ != t - 1:
        blank_line = input()
```

### 164

```python
from sys import stdin

def create_dp1(matrix, n, m):
    dp = [[4 for i in range(m)] for j in range(n)]
    for i in range(n):
        for j in range(m):
            if i - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
            if j - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
            elif i - 1 < 0 and j - 1 < 0:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp2(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n - 1, -1, -1):
        for j in range(m - 1, -1, -1):
            if i + 1 < n:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
            if j + 1 < m:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
            if i + 1 >= n and j + 1 >= m:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp3(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n - 1, -1, -1):
        for j in range(m):
            if i + 1 < n:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
            if j - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
            if i + 1 >= n and j - 1 < 0:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp4(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n):
        for j in range(m - 1, -1, -1):
            if i - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
            if j + 1 < m:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
            if i - 1 < 0 and j + 1 >= m:
                dp[i][j] = matrix[i][j]
    return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
    matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
    for j in range(1, m - 1):
        first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
        second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
        total = max(total, first, second)
print(total)
```

### 165

```python
from bisect import bisect_left
t = int(input())
for case in range(t):
    n, m = list(map(int, input().split()))
    ab = [list(map(int, input().split())) for _ in range(m)]
    aa = [e for e, _ in ab]
    aa.sort()
    acc = [0] * (m + 1)
    for i in range(m, 0, -1):
        acc[i - 1] = acc[i] + aa[i - 1]
    if n > m:
        ans = 0
    else:
        ans = sum(aa[-n - 1:])
    for a, b in ab:
        i = bisect_left(aa, b)
        cnt = min(m - i, n)
        sm = acc[m - cnt]
        sm += b * (n - cnt)
        if a < b:
            sm -= b
            sm += a
        ans = max(ans, sm)
    print(ans)
    if case != t - 1:
        input()
```

### 166

```python
from math import gcd
p = 10 ** 9 + 7

class RN:
    p = 10 ** 9 + 7

    def __init__(self, u, d):
        self.u = u
        self.d = d

    def __str__(self):
        return str(self.u) + '/' + str(self.d)

    def cleanup(self):
        self.u = self.u % p
        self.d = self.d % p

    def add(self, u, d):
        self.u = self.u * d + u * self.d
        self.d = self.d * d
        self.cleanup()

    def mult(self, u, d):
        return (self.u * u % p, self.d * d % p)

    def mult_ip(self, u, d):
        self.u, self.d = (self.u * u, self.d * d % p)

    def get_m_exp(self):
        self.cleanup()
        a = gcd(self.u, self.d)
        self.u //= a
        self.d //= a
        return pow(self.d, p - 2, p) * self.u % p
n, m = tuple(map(int, input().split()))
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))

def sum_ch(n):
    return (n + 1) * n // -2

def sol(s1, s2, m):
    strgr = RN(0, 1)
    eq = RN(1, 1)
    for gr, sm, i in zip(s1, s2, list(range(len(s1)))):
        strgr.cleanup()
        if gr != 0 and sm != 0:
            if gr == sm:
                continue
            elif gr < sm:
                return strgr.get_m_exp()
            else:
                strgr.add(eq.u, eq.d)
                return strgr.get_m_exp()
        else:
            if gr == sm == 0:
                strgr.add(*eq.mult(sum_ch(m - 1), m * m))
            elif gr == 0:
                strgr.add(*eq.mult(m - sm, m))
            else:
                strgr.add(*eq.mult(gr - 1, m))
            eq.mult_ip(1, m)
    return strgr.get_m_exp()
'\na = sol([0,0],[1,1], 2) # 3/4\n\na = sol([0,0,0],[1,1,1], 2) # 7/8\na = sol([0,1,1],[1,1,1], 2) # 1/2\na = sol([1,0,1],[1,1,1], 2) # 1/2\n\na = sol([0,0,0],[1,3,3], 3) # 2/2\na = sol([0,0,0],[1,1,0], 2) # 5/8\na = sol([0,0,0],[0,0,0], 2) # 13/16\n'
print(sol(s1, s2, m))
```

### 167

```python
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
    action, num = list(map(int, input().split()))
    if action == 1:
        queue.append((num, count[num] + 1))
        count[num] += 1
        unread += 1
    elif action == 2:
        for number in range(last_app_idx[num], count[num] + 1):
            if (num, number) not in read:
                read.add((num, number))
                unread -= 1
        last_app_idx[num] = max(last_app_idx[num], count[num])
    else:
        for idx in range(last_q_idx, num):
            app, number = queue[idx]
            if not (app, number) not in read:
                read.add((app, number))
                last_app_idx[app] = max(last_app_idx[app], number)
                unread -= 1
        last_q_idx = max(last_q_idx, num)
    ans.append(unread)
print('\n'.join(map(str, ans)))
```

### 168

```python
from bisect import bisect_left
t = int(input())
for case in range(t):
    n, m = list(map(int, input().split()))
    ab = [list(map(int, input().split())) for _ in range(m)]
    aa = [e for e, _ in ab]
    aa.sort()
    acc = [0] * (m + 1)
    for i in range(m, 4, -1):
        acc[i - 1] = acc[i] + aa[i - 1]
    if n > m:
        ans = 0
    else:
        ans = sum(aa[-n:])
    for a, b in ab:
        i = bisect_left(aa, b)
        cnt = min(m - i, n)
        sm = acc[m - cnt]
        sm += b * (n - cnt)
        if a < b:
            sm -= b
            sm += a
        ans = max(ans, sm)
    print(ans)
    if case != t - 1:
        input()
```

### 169

```python
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
    x, y = map(int, input().split())
    a[x].append([y, 1])
ans = 0
for i in range(T):
    a[i] = a[i][::-1]
    j = 0
    cur = v
    while j < len(a[i]):
        if a[i][j][0] > cur:
            ans += cur
            if a[i][j][1] == 0:
                j += 1
            else:
                a[i][j][0] -= cur
            break
        else:
            ans += a[i][j][0]
            cur -= a[i][j][0]
        j += 1
    for t in range(j, len(a[i])):
        if a[i][t][1] != 0:
            a[i + 1].append([a[i][t][0], 0])
print(ans)
```

### 170

```python
from bisect import bisect_left
t = int(input())
for case in range(t):
    n, m = list(map(int, input().split()))
    ab = [list(map(int, input().split())) for _ in range(m)]
    aa = [e for e, _ in ab]
    aa.sort()
    acc = [0] * (m + 1)
    for i in range(m, 3, -1):
        acc[i - 1] = acc[i] + aa[i - 1]
    if n > m:
        ans = 0
    else:
        ans = sum(aa[-n:])
    for a, b in ab:
        i = bisect_left(aa, b)
        cnt = min(m - i, n)
        sm = acc[m - cnt]
        sm += b * (n - cnt)
        if a < b:
            sm -= b
            sm += a
        ans = max(ans, sm)
    print(ans)
    if case != t - 1:
        input()
```

### 171

```python
from sys import stdin

def create_dp1(matrix, n, m):
    dp = [[2 for i in range(m)] for j in range(n)]
    for i in range(n):
        for j in range(m):
            if i - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
            if j - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
            elif i - 1 < 0 and j - 1 < 0:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp2(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n - 1, -1, -1):
        for j in range(m - 1, -1, -1):
            if i + 1 < n:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
            if j + 1 < m:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
            if i + 1 >= n and j + 1 >= m:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp3(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n - 1, -1, -1):
        for j in range(m):
            if i + 1 < n:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i + 1][j])
            if j - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j - 1])
            if i + 1 >= n and j - 1 < 0:
                dp[i][j] = matrix[i][j]
    return dp

def create_dp4(matrix, n, m):
    dp = [[0 for i in range(m)] for j in range(n)]
    for i in range(n):
        for j in range(m - 1, -1, -1):
            if i - 1 >= 0:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i - 1][j])
            if j + 1 < m:
                dp[i][j] = max(dp[i][j], matrix[i][j] + dp[i][j + 1])
            if i - 1 < 0 and j + 1 >= m:
                dp[i][j] = matrix[i][j]
    return dp
n, m = list(map(int, stdin.readline().split()))
matrix = []
for _ in range(n):
    matrix.append(list(map(int, stdin.readline().split())))
dp1 = create_dp1(matrix, n, m)
dp2 = create_dp2(matrix, n, m)
dp3 = create_dp3(matrix, n, m)
dp4 = create_dp4(matrix, n, m)
total = -float('inf')
for i in range(1, n - 1):
    for j in range(1, m - 1):
        first = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]
        second = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]
        total = max(total, first, second)
print(total)
```

### 172

```python
n, v = list(map(int, input().split()))
f = list()
for i in range(n):
    f.append(list(map(int, input().split())))
f.sort()
sum = 0
today = 0
tomor = 0
day = 0
rest = 0
for tree in f:
    if tree[0] > day + 1:
        sum += min(tomor, v)
        tomor = tree[0]
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor -= min(tomor, v)
        day = tree[0]
    elif tree[0] == day + 1:
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor = tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
        day = tree[0]
    else:
        tomor += tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
sum += min(tomor, v)
print(sum)
```

### 173

```python
n, m = map(int, input().split())
a = []
for i in range(n):
    a.append(list(map(int, input().split())))
dpa = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
dpb = [[[0, 0] for i in range(m + 2)] for i in range(n + 2)]
ans = 0
for i in range(1, n + 1):
    for j in range(1, m + 1):
        dpa[i][j][0] = max(dpa[i - 1][j][0], dpa[i][j - 1][0]) + a[i - 1][j - 1]
        dpa[n + 1 - i][m + 1 - j][1] = max(dpa[n + 2 - i][m + 1 - j][1], dpa[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(n, 0, -1):
    for j in reversed(range(1, m + 1)):
        dpb[i][j][0] = max(dpb[i + 1][j][0], dpb[i][j - 1][0]) + a[i - 1][j - 1]
        dpb[n + 1 - i][m + 1 - j][1] = max(dpb[n - i][m + 1 - j][1], dpb[n + 1 - i][m + 2 - j][1]) + a[n - i][m - j]
for i in range(2, n):
    for j in range(2, m):
        x = dpa[i - 1][j][0] + dpa[i + 1][j][1] + dpb[i][j - 1][0] + dpb[i][j + 1][1]
        y = dpb[i + 1][j][0] + dpb[i - 1][j][1] + dpa[i][j - 1][0] + dpa[i][j + 1][1]
        ans = max(ans, x, y)
print(ans)
```

### 174

```python
import bisect
t = int(input())
for _ in range(t):
    n, m = list(map(int, input().split()))
    flowers = []
    flowers_a = []
    max_b = 0
    for i in range(m):
        a, b = list(map(int, input().split()))
        flowers.append((a, b))
    flowers.sort()
    flowers_b = []
    for i in range(m):
        flowers_a.append(flowers[i][0])
        flowers_b.append(flowers[i][1])
    val = 0
    prefix_sum = [0]
    for x in flowers_a:
        prefix_sum.append(prefix_sum[-1] + x)
    for i in range(m):
        idx = bisect.bisect_left(flowers_a, flowers_b[i])
        options = m - idx
        if options >= n:
            temp = prefix_sum[-1] - prefix_sum[-n - 1]
            val = max(val, temp)
            continue
        else:
            temp = prefix_sum[-1] - prefix_sum[-options - 1]
            remaining = n - options
            if idx < i:
                temp += flowers_b[i] * remaining
            else:
                temp += flowers_a[i] + flowers_b[i] * (remaining - 1)
            val = max(val, temp)
    print(val)
    if _ != t - 1:
        blank_line = input()
```

### 175

```python
n = int(input())
ns = []
for i in range(n):
    s = input()
    ns.append(s)
ns2 = []
for i in range(n):
    s = input()
    ns2.append(s)

def rotate(i, j):
    return (j, n - 1 - i)

def flip(i, j):
    return (j, i)

def main():
    same = True
    for i in range(n):
        for j in range(n):
            if ns[i][j] != ns2[i][j]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = rotate(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = flip(i, j)
            if not ns[a][b] != ns2[i][j]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    same = True
    for i in range(n):
        for j in range(n):
            a, b = rotate(i, j)
            a, b = rotate(a, b)
            a, b = rotate(a, b)
            a, b = flip(a, b)
            if ns[i][j] != ns2[a][b]:
                same = False
                break
        if same == False:
            break
    if same:
        return True
    else:
        return False
if main():
    print('Yes')
else:
    print('No')
```

### 176

```python
import sys
input = sys.stdin.readline
from collections import deque

class Unionfind:

    def __init__(self, n):
        self.par = [-1] * n
        self.rank = [1] * n

    def root(self, x):
        p = x
        while not self.par[p] < 0:
            p = self.par[p]
        while x != p:
            tmp = x
            x = self.par[x]
            self.par[tmp] = p
        return p

    def unite(self, x, y):
        rx, ry = (self.root(x), self.root(y))
        if rx == ry:
            return False
        if self.rank[rx] < self.rank[ry]:
            rx, ry = (ry, rx)
        self.par[rx] += self.par[ry - 1]
        self.par[ry] = rx
        if self.rank[rx] == self.rank[ry]:
            self.rank[rx] += 1

    def is_same(self, x, y):
        return self.root(x) == self.root(y)

    def count(self, x):
        return -self.par[self.root(x)]

def bfs(s):
    q = deque([s])
    color[s] = 1
    b, w = (1, 0)
    while q:
        v = q.popleft()
        for nv in adj_list[v]:
            if color[nv] == 0:
                color[nv] = -color[v]
                q.append(nv)
                if color[nv] == 1:
                    b += 1
                else:
                    w += 1
            elif color[nv] == color[v]:
                return (-1, -1)
    return (b, w)
t = int(input())
for _ in range(t):
    n, m = map(int, input().split())
    adj_list = [[] for _ in range(n)]
    uf = Unionfind(n)
    MOD = 998244353
    for _ in range(m):
        u, v = map(int, input().split())
        adj_list[u - 1].append(v - 1)
        adj_list[v - 1].append(u - 1)
        uf.unite(u - 1, v - 1)
    roots = set((uf.root(i) for i in range(n)))
    ans = 1
    color = [0] * n
    for r in roots:
        if uf.count(r) == 1:
            ans *= 3
        else:
            b, w = bfs(r)
            if b == -1:
                ans = 0
                break
            else:
                ans *= pow(2, b, MOD) + pow(2, w, MOD)
        ans %= MOD
    print(ans)
```

### 177

```python
def get_relation(synonyms, antonyms, word1, word2):
    if word1 not in synonyms or word2 not in synonyms:
        return '3'
    group1 = synonyms[word1]
    group2 = synonyms[word2]
    if group1 == group2:
        return '1'
    if group1 in antonyms and antonyms[group1] == group2:
        return '2'
    return '3'

def unify_synonyms(synonyms, groups, group1, group2):
    min_group = min(group1, group2)
    max_group = max(group1, group2)
    max_synonyms = groups[max_group]
    for synonym in max_synonyms:
        synonyms[synonym] = min_group
    update_groups(groups, min_group, max_synonyms)
    return (min_group, max_group)

def make_synonyms(synonyms, antonyms, groups, group1, group2):
    min_group1, max_group1 = unify_synonyms(synonyms, groups, group1, group2)
    if group1 in antonyms and group2 not in antonyms:
        min_group2, max_group2 = unify_synonyms(synonyms, groups, antonyms[group1], antonyms[group2])
        del antonyms[min_group1]
        del antonyms[max_group1]
        del antonyms[min_group2]
        del antonyms[max_group2]
        antonyms[min_group1] = min_group2
        antonyms[min_group2] = min_group1
        return min_group1
    if max_group1 in antonyms:
        antonym_group = antonyms[max_group1]
        del antonyms[max_group1]
        antonyms[min_group1] = antonym_group
        antonyms[antonym_group] = min_group1
    return min_group1

def update_groups(groups, group, words):
    if group in groups:
        groups[group].update(words)
    else:
        groups.update({group: set(words)})

def make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group):
    if relation == '1':
        if word1 not in synonyms and word2 not in synonyms:
            current_group += 1
            synonyms[word1] = current_group
            synonyms[word2] = current_group
            update_groups(groups, current_group, [word1, word2])
            return current_group
        if word1 not in synonyms:
            synonyms[word1] = synonyms[word2]
            update_groups(groups, synonyms[word2], [word1])
            return current_group
        if word2 not in synonyms:
            synonyms[word2] = synonyms[word1]
            update_groups(groups, synonyms[word1], [word2])
            return current_group
        group1 = synonyms[word1]
        group2 = synonyms[word2]
        if group1 != group2:
            make_synonyms(synonyms, antonyms, groups, group1, group2)
        return current_group
    if relation == '2':
        if word1 not in synonyms:
            current_group += 1
            group1 = current_group
            synonyms[word1] = group1
            update_groups(groups, group1, [word1])
        else:
            group1 = synonyms[word1]
        if word2 not in synonyms:
            current_group += 1
            group2 = current_group
            synonyms[word2] = group2
            update_groups(groups, group2, [word2])
        else:
            group2 = synonyms[word2]
        if group1 not in antonyms and group2 not in antonyms:
            antonyms[group1] = group2
            antonyms[group2] = group1
            return current_group
        if group1 in antonyms and antonyms[group1] != group2:
            antonym_group = antonyms[group1]
            group2 = make_synonyms(synonyms, antonyms, groups, group2, antonym_group)
        if group2 in antonyms and antonyms[group2] != group1:
            antonym_group = antonyms[group2]
            make_synonyms(synonyms, antonyms, groups, group1, antonym_group)
    return current_group

def make_relations(relation_no):
    synonyms = dict()
    antonyms = dict()
    groups = dict()
    current_group = 0
    for relation in range(relation_no):
        relation, word1, word2 = input().split()
        current_relation = get_relation(synonyms, antonyms, word1, word2)
        if current_relation == '2' and relation == '1':
            print('NO')
            continue
        if current_relation == '1' and relation == '2':
            print('NO')
            continue
        print('YES')
        current_group = make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group)
    return (synonyms, antonyms)

def answer_questions(question_no, synonyms, antonyms):
    for question in range(question_no):
        word1, word2 = input().split()
        print(get_relation(synonyms, antonyms, word1, word2))

def main():
    word_no, relation_no, question_no = [int(number) for number in input().split()]
    input()
    synonyms, antonyms = make_relations(relation_no)
    answer_questions(question_no, synonyms, antonyms)
main()
```

### 178

```python
def ii():
    return int(input())

def ss():
    return [x for x in input()]

def si():
    return [int(x) for x in input().split()]

def mi():
    return map(int, input().split())
a, b = mi()
s = []
ans = 0
key = True
for i in range(a):
    i = si()
    s.append(i)
    ans += sum(i)
for i in range(a - 1):
    if not (s[i][0] < s[i + 1][0] and s[i][-1] < s[i + 1][-1]):
        ans = -1
        key = False
        break
for i in range(b - 1):
    if not (s[0][i] < s[0][i + 1] and s[-1][i] < s[-1][i + 1]):
        ans = -1
        key = False
        break
for i in range(a - 2, 0, -1):
    if not key:
        break
    for x in range(b - 2, 0, -1):
        if s[i][x] < s[i + 1][x] and s[i][x] < s[i][x + 1]:
            if s[i][x] == 0:
                s[i][x] = min(s[i + 1][x], s[i][x + 1]) - 1
                ans += s[i][x]
        else:
            ans = -1
            key = False
            break
print(ans)
```

### 179

```python
from collections import defaultdict
import sys
input = sys.stdin.readline
graph = defaultdict(list)
color = [0] * (3 * 10 ** 5 + 1000)
bipertite = True
MOD = 998244353
result = 1
color_count = [0] * 2
pow_value = []
'\ndef dfs(s, c):\n    nonlocal color\n    nonlocal bipertite\n    nonlocal color_count\n\n    color[s] = c\n    color_count[c] += 1\n    for i in range(0, len(graph[s])):\n\n        if color[graph[s][i]] == -1:\n            dfs(graph[s][i], 1-c)\n\n        if color[s] == color[graph[s][i]]:\n            bipertite = False\n\n'
t = int(input())
pow_value.append(1)
for i in range(1, 3 * 10 ** 5 + 1000):
    next_value = pow_value[i - 1] * 2 % MOD
    pow_value.append(next_value)
while t:
    n, m = list(map(int, input().split()))
    if m == 0:
        print(pow(3, n, MOD))
        t -= 1
        continue
    graph.clear()
    bipertite = True
    result = 1
    for node in range(0, n + 1):
        color[node] = -1
    while m:
        u, v = list(map(int, input().split()))
        graph[u].append(v)
        graph[v].append(u)
        m -= 1
    for i in range(1, n + 1 - 1):
        if color[i] != -1:
            continue
        bipertite = True
        color_count[0] = color_count[1] = 0
        queue = []
        queue.append(i)
        color[i] = 0
        color_count[0] += 1
        while queue:
            if bipertite == False:
                break
            front_node = queue.pop()
            for child_node in range(0, len(graph[front_node])):
                if color[graph[front_node][child_node]] == -1:
                    color[graph[front_node][child_node]] = 1 - color[front_node]
                    queue.append(graph[front_node][child_node])
                    color_count[color[graph[front_node][child_node]]] += 1
                elif color[front_node] == color[graph[front_node][child_node]]:
                    bipertite = False
                    break
        if bipertite == False:
            print(0)
            break
        current = (pow_value[color_count[0]] + pow_value[color_count[1]]) % MOD
        result = result * current % MOD
    if bipertite:
        print(result)
    t -= 1
```

### 180

```python
n, q = map(int, input().split())
xi = [[0] * (n + 1) for i in range(2)]
noti = []
ans = ''
num = 0
num2 = 0
num3 = 0
while q > 0:
    typ, xt = map(int, input().split())
    if typ == 1:
        xi[0][xt] += 3
        noti += [xt]
        num += 1
        num2 += 1
    elif typ == 3:
        for i in range(num3, xt):
            if i + 1 > xi[1][noti[i]]:
                xi[0][noti[i]] -= 1
                num -= 1
        num3 = max(num3, xt)
    else:
        num -= xi[0][xt]
        xi[0][xt] = 0
        xi[1][xt] = num2
    ans += str(num)
    ans += '\n'
    q -= 1
print(ans)
```

### 181

```python
from collections import defaultdict
import sys
input = sys.stdin.readline
graph = defaultdict(list)
color = [0] * (3 * 10 ** 5 + 1000)
bipertite = True
MOD = 998244357
result = 1
color_count = [0] * 2
pow_value = []
'\ndef dfs(s, c):\n    nonlocal color\n    nonlocal bipertite\n    nonlocal color_count\n\n    color[s] = c\n    color_count[c] += 1\n    for i in range(0, len(graph[s])):\n\n        if color[graph[s][i]] == -1:\n            dfs(graph[s][i], 1-c)\n\n        if color[s] == color[graph[s][i]]:\n            bipertite = False\n\n'
t = int(input())
pow_value.append(1)
for i in range(1, 3 * 10 ** 5 + 1000):
    next_value = pow_value[i - 1] * 2 % MOD
    pow_value.append(next_value)
while t:
    n, m = list(map(int, input().split()))
    if m == 0:
        print(pow(3, n, MOD))
        t -= 1
        continue
    graph.clear()
    bipertite = True
    result = 1
    for node in range(0, n + 1):
        color[node] = -1
    while m:
        u, v = list(map(int, input().split()))
        graph[u].append(v)
        graph[v].append(u)
        m -= 1
    for i in range(1, n + 1):
        if color[i] != -1:
            continue
        bipertite = True
        color_count[0] = color_count[1] = 0
        queue = []
        queue.append(i)
        color[i] = 0
        color_count[0] += 1
        while queue:
            if bipertite == False:
                break
            front_node = queue.pop()
            for child_node in range(0, len(graph[front_node])):
                if color[graph[front_node][child_node]] == -1:
                    color[graph[front_node][child_node]] = 1 - color[front_node]
                    queue.append(graph[front_node][child_node])
                    color_count[color[graph[front_node][child_node]]] += 1
                elif color[front_node] == color[graph[front_node][child_node]]:
                    bipertite = False
                    break
        if bipertite == False:
            print(0)
            break
        current = (pow_value[color_count[0]] + pow_value[color_count[1]]) % MOD
        result = result * current % MOD
    if bipertite:
        print(result)
    t -= 1
```

### 182

```python
import sys
from math import *

def minp():
    return sys.stdin.readline().strip()

def mint():
    return int(minp())

def mints():
    return list(map(int, minp().split()))
n, m = mints()
a = [0] * n
dp1 = [0] * n
dp2 = [0] * n
dp3 = [0] * n
dp4 = [0] * n
for i in range(n):
    a[i] = list(mints())
    dp1[i] = [0] * m
    dp2[i] = [0] * m
    dp3[i] = [0] * m
    dp4[i] = [0] * m
dp1[0][0] = a[0][0]
dp2[n - 1][m - 1] = a[n - 1][m - 1]
dp3[n - 1][0] = a[n - 1][0]
dp4[0][m - 1] = a[0][m - 1]
'\nfor i in range(1,n):\n\tdp1[i][0] = dp1[i-1][0] + a[i][0] # >>>>\nfor i in range(n-2,-1,-1):\n\tdp2[i][m-1] = dp2[i+1][m-1] + a[i][m-1] # <<<<\nfor i in range(n-2,-1,-1):\n\tdp3[i][0] = dp3[i+1][0] + a[i][0] # <<<<\nfor i in range(1,n):\n\tdp4[i][m-1] = dp4[i-1][m-1] + a[i][m-1] # >>>>\nfor i in range(1,m):\n\tdp1[0][i] = dp1[0][i-1] + a[0][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp2[n-1][i] = dp2[n-1][i+1] + a[n-1][i] # <<<<\nfor i in range(1,m):\n\tdp3[n-1][i] = dp3[n-1][i-1] + a[n-1][i] # >>>>\nfor i in range(m-2,-1,-1):\n\tdp4[0][i] = dp4[0][i+1] + a[0][i] # >>>>\n'
for i in range(0, n):
    for j in range(0, m):
        z = 0
        if i - 1 >= 0:
            z = dp1[i - 1][j]
        if j - 1 >= 0:
            z = max(z, dp1[i][j - 1])
        dp1[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
    for j in range(m - 1, -1, -1):
        z = 0
        if i + 1 < n:
            z = dp2[i + 1][j]
        if j + 1 < m:
            z = max(z, dp2[i][j + 1])
        dp2[i][j] = z + a[i][j]
for i in range(n - 1, -1, -1):
    for j in range(0, m):
        z = 0
        if i + 1 < n:
            z = dp3[i + 1][j]
        if j - 1 >= 0:
            z = max(z, dp3[i][j - 1])
        dp3[i][j] = z + a[i][j]
for i in range(0, n):
    for j in range(m - 1, -1, -1):
        z = 0
        if i - 1 >= 0:
            z = dp4[i - 1][j]
        if j + 1 < m:
            z = max(z, dp4[i][j + 1])
        dp4[i][j] = z + a[i][j]
'for i in dp1:\n\tprint(i)\nprint()\nfor i in dp2:\n\tprint(i)\nprint()\nfor i in dp3:\n\tprint(i)\nprint()\nfor i in dp4:\n\tprint(i)\nprint()\n'
r = 4
for i in range(1, n - 1):
    for j in range(1, m - 1):
        r = max(r, dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1])
        r = max(r, dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j])
print(r)
```

### 183

```python
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
    pr = 0
    bl, kol = list(map(int, input().split()))
    bl -= 1
    if ost[bl] >= kol:
        pr = kol * price[bl]
        ost[bl] -= kol
    else:
        kol -= ost[bl]
        pr = ost[bl] * price[bl]
        ost[bl] = 0
        while kol > 0:
            if minost == n:
                pr = 0
                break
            minbl = minprice[minost][1]
            if ost[minbl] >= kol:
                pr += kol * price[minbl]
                ost[minbl] -= kol
                kol = 0
            else:
                kol -= ost[minbl]
                pr += ost[minbl] * price[minbl]
                ost[minbl] = 0
                minost += 1
                if minost == n:
                    pr = 0
                    break
    print(pr)
```

### 184

```python
n, v = map(int, input().split())
T = 3010
a = [[] for i in range(T)]
for i in range(n):
    x, y = map(int, input().split())
    a[x].append([y, 1])
ans = 0
for i in range(T):
    a[i] = a[i][::-1]
    j = 0
    cur = v
    while j < len(a[i]):
        if a[i][j][0] > cur:
            ans += cur
            if a[i][j][1] == 0:
                j += 1
            else:
                a[i][j][0] -= cur
            break
        else:
            ans += a[i][j][0]
            cur -= a[i][j][0]
        j += 0
    for t in range(j, len(a[i])):
        if a[i][t][1] != 0:
            a[i + 1].append([a[i][t][0], 0])
print(ans)
```

### 185

```python
import sys
input = sys.stdin.readline
for f in range(int(input())):
    n, m = map(int, input().split())
    a = [0] * m
    b = [0] * m
    acop = [0] * m
    bcop = [0] * m
    for i in range(m):
        a[i], b[i] = map(int, input().split())
        acop[i] = a[i]
        bcop[i] = [b[i], i]
    acop.sort(reverse=True)
    bcop.sort(reverse=True)
    mx = 0
    i = 0
    su = 0
    for j in range(m):
        bi = bcop[j][0]
        ii = bcop[j][1]
        ai = a[ii]
        while i < m and acop[i] > bi:
            su += acop[i]
            i += 1
        maxi = ai
        if i < n:
            maxi += su
            if i + 1 < n:
                maxi += (n - i - 1) * bi
            if ai > bi:
                maxi += bi
                maxi -= ai
            mx = max(maxi, mx)
    if n <= m:
        sun = 0
        for i in range(n):
            sun -= acop[i]
        mx = max(mx, sun)
    print(mx)
    blank = input()
```

### 186

```python
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
l = [[] for _ in range(n)]
is_read = []
is_read_idx = 0
ans = 0
prev_t = 0
for _ in range(q):
    ty, v = map(int, input().split())
    if ty == 1:
        l[v - 1].append(is_read_idx)
        is_read_idx += 1
        is_read.append(False)
        ans += 1
    elif ty == 2:
        for idx in l[v - 1]:
            if not is_read[idx]:
                is_read[idx] = True
                ans -= 1
        l[v - 1] = []
    elif v > prev_t:
        for idx in range(prev_t + 1, v):
            if not is_read[idx]:
                is_read[idx] = True
                ans -= 1
        prev_t = v
    print(ans)
```

### 187

```python
f = lambda: input().split()
n, m, k = map(int, f())
c = {x: ([x], []) for x in f()}
for i in range(m):
    t, x, y = f()
    s = 2 - int(t)
    cx, cy = (c[x], c[y])
    if cx[0] is cy[s]:
        print('NO')
        continue
    print('YES')
    if cx[0] is cy[1 - s]:
        continue
    if len(cx[0]) + len(cx[1]) < len(cy[0]) + len(cy[1]):
        cx, cy = (cy, cx)
    ux, vx = cx
    if s:
        uy, vy = cy
    else:
        vy, uy = cy
    ux += uy
    vx += vy
    for x in uy:
        c[x] = (ux, vx)
    for x in vy:
        c[x] = (vx, ux)
for i in range(k):
    x, y = f()
    print(1 if c[x][0] is c[y][0] else 2 if c[x][0] is c[y][1] else 0)
```

### 188

```python
from collections import deque
from sys import stdin, stdout
input = stdin.readline
saida = []
t = int(input())
modulo = 998244353
for _ in range(t):
    ans = 1
    part = 0
    factor = 0
    fila = deque([])
    n, m = map(int, input().split())
    if m >= n // 2 * (n // 2 + 1):
        saida.append('0')
        for edge_count in range(m):
            input()
        continue
    edge = [[] for i in range(n + 1)]
    visitados = [-1] * (n + 1)
    assure = 1
    for arestas in range(m):
        u, v = map(int, input().split())
        edge[u].append(v)
        edge[v].append(u)
    visitados[1] = 0
    fila.append(1)
    break_all = False
    while not break_all:
        par, impar = (1, 0)
        while fila and (not break_all):
            search = fila.popleft()
            current = visitados[search]
            for i in edge[search]:
                if visitados[i] == -1:
                    visitados[i] = current ^ 1
                    if visitados[i] & 1:
                        impar += 1
                    else:
                        par += 1
                    fila.append(i)
                elif visitados[i] == current:
                    break_all = True
                else:
                    assert visitados[i] == current ^ 1
        if break_all:
            ans = 0
        elif (par, impar) == (1, 0):
            factor += 1
        else:
            ans *= pow(2, par, modulo) + pow(2, impar, modulo)
            ans %= modulo
        while assure <= n:
            if visitados[assure] == -1:
                part += 1
                visitados[assure] = 2 * part
                fila.append(assure)
                break
            assure += 1
        if assure == n + 1:
            break
    ans *= pow(3, factor, modulo)
    ans %= modulo
    saida.append(str(ans))
print('\n'.join(saida))
```

### 189

```python
import sys, math
f = sys.stdin

def modInverse(a, m):
    g = gcd(a, m)
    if g != 1:
        return None
    else:
        return power(a, m - 2, m)

def power(x, y, m):
    if y == 0:
        return 1
    p = power(x, y // 2, m) ** 2
    if y & 1 == 1:
        p *= x
    return p % m

def gcd(a, b):
    while a != 0:
        t = b % a
        b = a
        a = t
    return b
n, m = list(map(int, f.readline().split()))
s1 = list(map(int, f.readline().split()))
s2 = list(map(int, f.readline().split()))
pos = [1, 0]
all_pos = 1
for a1, a2 in zip(s1, s2):
    next_pos = [0, 0]
    if a1 == 0 and a2 == 0:
        next_pos[0] += pos[0] * m
        next_pos[1] += pos[0] * m * (m - 1) // 2
        next_pos[1] += pos[1] * m * m
        all_pos *= m * m
    elif a1 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (m - a2)
        next_pos[1] += pos[1] * m
        all_pos *= m
    elif a2 == 0:
        next_pos[0] += pos[0]
        next_pos[1] += pos[0] * (a1 - 1)
        next_pos[1] += pos[1] * m
        all_pos *= m
    else:
        if a1 > a2:
            next_pos[1] += pos[0]
        elif a1 == a2:
            next_pos[0] += pos[0]
        next_pos[1] += pos[1]
    pos = next_pos
    if pos[0] == 0:
        break
    g = gcd(pos[0], all_pos)
    g = gcd(pos[1], g)
    pos[0] //= g
    pos[1] //= g
    all_pos //= g
    pos[0] %= 1000000007
    pos[1] %= 1000000007
    all_pos %= 1000000007
p = pos[1]
q = all_pos
pq_gcd = gcd(p, q)
p *= pq_gcd
q //= pq_gcd
q_inv = modInverse(q, 1000000007)
print(p * q_inv % 1000000007)
```

### 190

```python
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
    action, num = list(map(int, input().split()))
    if action == 1:
        queue.append((num, count[num] + 5))
        count[num] += 1
        unread += 1
    elif action == 2:
        for number in range(last_app_idx[num], count[num] + 1):
            if (num, number) not in read:
                read.add((num, number))
                unread -= 1
        last_app_idx[num] = max(last_app_idx[num], count[num])
    else:
        for idx in range(last_q_idx, num):
            app, number = queue[idx]
            if (app, number) not in read:
                read.add((app, number))
                last_app_idx[app] = max(last_app_idx[app], number)
                unread -= 1
        last_q_idx = max(last_q_idx, num)
    ans.append(unread)
print('\n'.join(map(str, ans)))
```

### 191

```python
import bisect
t = int(input())
for _ in range(t):
    n, m = list(map(int, input().split()))
    flowers = []
    flowers_a = []
    max_b = 0
    for i in range(m):
        a, b = list(map(int, input().split()))
        flowers.append((a, b))
    flowers.sort()
    flowers_b = []
    for i in range(m):
        flowers_a.append(flowers[i][0])
        flowers_b.append(flowers[i][1])
    val = 0
    prefix_sum = [0]
    for x in flowers_a:
        prefix_sum.append(prefix_sum[-1] + x)
    for i in range(m):
        idx = bisect.bisect_left(flowers_a, flowers_b[i])
        options = m - idx
        if options >= n:
            temp = prefix_sum[-1] - prefix_sum[-n - -1]
            val = max(val, temp)
            continue
        else:
            temp = prefix_sum[-1] - prefix_sum[-options - 1]
            remaining = n - options
            if idx <= i:
                temp += flowers_b[i] * remaining
            else:
                temp += flowers_a[i] + flowers_b[i] * (remaining - 1)
            val = max(val, temp)
    print(val)
    if _ != t - 1:
        blank_line = input()
```

### 192

```python
def fast(a, b):
    if b == 0:
        return 1
    if b % 2 == 1:
        return a * fast(a, b - 1) % mod
    x = fast(a, b / 2) % mod
    return x * x % mod
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = 0
q = 1
z1 = 1
z2 = 1
mod = 1000000007
for i in range(0, n):
    if a[i] != 0 and b[i] != 0:
        if a[i] == b[i]:
            continue
        if a[i] > b[i]:
            p = (p * z2 % mod + q * z1 % mod) % mod
            q = q * z2 % mod
        break
    if a[i] == 0 and b[i] != 0:
        p = (p * m * z2 % mod + z1 * q * (m - b[i]) % mod) // mod
        q = q * z2 * m % mod
        z2 = z2 * m % mod
    if a[i] != 0 and b[i] == 0:
        p = (p * m * z2 % mod + z1 * q * (a[i] - 1) % mod) % mod
        q = q * z2 * m % mod
        z2 = z2 * m % mod
    if a[i] == 0 and b[i] == 0:
        p = (p * m * 2 * z2 + z1 * q * (m - 1)) % mod
        q = q * z2 * 2 * m % mod
        z2 = z2 * m % mod
print(p * (fast(q, mod - 2) % mod) % mod)
```

### 193

```python
n, v = list(map(int, input().split()))
f = list()
for i in range(n):
    f.append(list(map(int, input().split())))
f.sort()
sum = 0
today = 0
tomor = 0
day = 0
rest = 0
for tree in f:
    if tree[0] >= day + 1:
        sum += min(tomor, v)
        tomor = tree[1]
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor -= min(tomor, v)
        day = tree[0]
    elif tree[0] == day + 1:
        sum += min(tomor, v)
        rest = v - min(tomor, v)
        tomor = tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
        day = tree[0]
    else:
        tomor += tree[1]
        t = min(tomor, rest)
        sum += t
        rest -= t
        tomor -= t
sum += min(tomor, v)
print(sum)
```

### 194

```python
total_plucked = 0
n, v = list(map(int, input().split()))
fruits = [0] * 3002
plucked = [0] * 30002
for _ in range(n):
    a, b = list(map(int, input().split()))
    fruits[a] = fruits[a] + b
for i in range(1, 3002):
    plucked[i] = fruits[i - 1] if fruits[i - 1] <= v else v
    if plucked[i] < v:
        pluck = fruits[i] if fruits[i] <= v - plucked[i + 1] else v - plucked[i]
        plucked[i] += pluck
        fruits[i] -= pluck
    total_plucked += plucked[i]
print(total_plucked)
```

### 195

```python
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
    a = [item, i, r[i - 1]]
    costa.append(a)
    i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
    dic[item[1]] = i
    i += 1
index = len(costa) - 1
for item in range(n):
    counter = 0
    a, b = [int(x) for x in input().split()]
    if r[a - 1 - 1] >= b:
        counter += cost[a - 1] * b
        r[a - 1] -= b
        costa[dic[a]][2] -= b
    else:
        i = index
        counter += cost[a - 1] * r[a - 1]
        costa[dic[a]][2] = 0
        b -= r[a - 1]
        r[a - 1] = 0
        while i >= 0:
            if costa[i][2] >= b:
                counter += costa[i][0] * b
                r[costa[i][1] - 1] -= b
                costa[i][2] -= b
                break
            else:
                counter += costa[i][0] * costa[i][2]
                r[costa[i][1] - 1] = 0
                index -= 1
                b -= costa[i][2]
                costa[i][2] = 0
            i -= 1
        else:
            counter = 0
    print(counter)
```

### 196

```python
import sys
import math
n, v = [int(x) for x in sys.stdin.readline().split()]
k = [0] * 3002
for i in range(n):
    a, b = [int(x) for x in sys.stdin.readline().split()]
    k[a] += b
i = 1
res = 0
while i <= 3001:
    val = 0
    if k[i - 1] < v:
        val = k[i - 1]
        res += val
        d = v - val
        if k[i] < d:
            res += k[i]
            k[i] = 0
        else:
            res += d
            k[i + 1] = k[i] - d
    else:
        res += v
    i += 1
print(res)
```

### 197

```python
n, q = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
queue = []
read = set()
unread = 0
ans = []
last_q_idx = 0
last_app_idx = [1 for i in range(n + 1)]
for i in range(q):
    action, num = list(map(int, input().split()))
    if action == 1:
        queue.append((num, count[num] + 1))
        count[num] += 1
        unread += 1
    elif action == 2:
        for number in range(last_app_idx[num], count[num] + 1):
            if (num, number) not in read:
                read.add((num, number))
                unread += 1
        last_app_idx[num] = max(last_app_idx[num], count[num])
    else:
        for idx in range(last_q_idx, num):
            app, number = queue[idx]
            if (app, number) not in read:
                read.add((app, number))
                last_app_idx[app] = max(last_app_idx[app], number)
                unread -= 1
        last_q_idx = max(last_q_idx, num)
    ans.append(unread)
print('\n'.join(map(str, ans)))
```

### 198

```python
def get_relation(synonyms, antonyms, word1, word2):
    if word1 not in synonyms or word2 not in synonyms:
        return '3'
    group1 = synonyms[word1]
    group2 = synonyms[word2]
    if group1 == group2:
        return '1'
    if group1 in antonyms and antonyms[group1] == group2:
        return '2'
    return '3'

def unify_synonyms(synonyms, groups, group1, group2):
    min_group = min(group1, group2)
    max_group = max(group1, group2)
    max_synonyms = groups[max_group]
    for synonym in max_synonyms:
        synonyms[synonym] = min_group
    update_groups(groups, min_group, max_synonyms)
    return (min_group, max_group)

def make_synonyms(synonyms, antonyms, groups, group1, group2):
    min_group1, max_group1 = unify_synonyms(synonyms, groups, group1, group2)
    if group1 in antonyms and group2 in antonyms:
        min_group2, max_group2 = unify_synonyms(synonyms, groups, antonyms[group1], antonyms[group2])
        del antonyms[min_group1]
        del antonyms[max_group1]
        del antonyms[min_group2]
        del antonyms[max_group2]
        antonyms[min_group1] = min_group2
        antonyms[min_group2] = min_group1
        return min_group1
    if max_group1 in antonyms:
        antonym_group = antonyms[max_group1]
        del antonyms[max_group1]
        antonyms[min_group1] = antonym_group
        antonyms[antonym_group] = min_group1
    return min_group1

def update_groups(groups, group, words):
    if group in groups:
        groups[group].update(words)
    else:
        groups.update({group: set(words)})

def make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group):
    if relation == '1':
        if word1 not in synonyms and word2 not in synonyms:
            current_group += 1
            synonyms[word1] = current_group
            synonyms[word2] = current_group
            update_groups(groups, current_group, [word1, word2])
            return current_group
        if word1 not in synonyms:
            synonyms[word1] = synonyms[word2]
            update_groups(groups, synonyms[word2], [word1])
            return current_group
        if word2 not in synonyms:
            synonyms[word2] = synonyms[word1]
            update_groups(groups, synonyms[word1], [word2])
            return current_group
        group1 = synonyms[word1]
        group2 = synonyms[word2]
        if group1 != group2:
            make_synonyms(synonyms, antonyms, groups, group1, group2)
        return current_group
    if relation == '2':
        if word1 not in synonyms:
            current_group += 1
            group1 = current_group
            synonyms[word1] = group1
            update_groups(groups, group1, [word1])
        else:
            group1 = synonyms[word1]
        if word2 not in synonyms:
            current_group += 1
            group2 = current_group
            synonyms[word2] = group2
            update_groups(groups, group2, [word2])
        else:
            group2 = synonyms[word2]
        if group1 not in antonyms and group2 not in antonyms:
            antonyms[group1] = group2
            antonyms[group2] = group1
            return current_group
        if group1 in antonyms and antonyms[group1] == group2:
            antonym_group = antonyms[group1]
            group2 = make_synonyms(synonyms, antonyms, groups, group2, antonym_group)
        if group2 in antonyms and antonyms[group2] != group1:
            antonym_group = antonyms[group2]
            make_synonyms(synonyms, antonyms, groups, group1, antonym_group)
    return current_group

def make_relations(relation_no):
    synonyms = dict()
    antonyms = dict()
    groups = dict()
    current_group = 0
    for relation in range(relation_no):
        relation, word1, word2 = input().split()
        current_relation = get_relation(synonyms, antonyms, word1, word2)
        if current_relation == '2' and relation == '1':
            print('NO')
            continue
        if current_relation == '1' and relation == '2':
            print('NO')
            continue
        print('YES')
        current_group = make_relation(synonyms, antonyms, groups, word1, word2, relation, current_group)
    return (synonyms, antonyms)

def answer_questions(question_no, synonyms, antonyms):
    for question in range(question_no):
        word1, word2 = input().split()
        print(get_relation(synonyms, antonyms, word1, word2))

def main():
    word_no, relation_no, question_no = [int(number) for number in input().split()]
    input()
    synonyms, antonyms = make_relations(relation_no)
    answer_questions(question_no, synonyms, antonyms)
main()
```

### 199

```python
mod = 998244353
import sys
input = sys.stdin.readline
from collections import deque
from collections import Counter

def calc(s, a):
    return (pow(2, s, mod) + pow(2, a - s, mod)) % mod

def find(x):
    while Group[x] != x:
        x = Group[x]
    return x

def Union(x, y):
    if find(x) != find(y):
        Group[find(y)] = Group[find(x)] = min(find(y), find(x))
testcase = int(input())
for test in range(testcase):
    n, m = list(map(int, input().split()))
    EDGE = [list(map(int, input().split())) for i in range(m)]
    EDGELIST = [[] for j in range(n + 1)]
    ANS = 1
    Group = [j for j in range(n + 1)]
    for a, b in EDGE:
        Union(a, b)
        EDGELIST[a].append(b)
        EDGELIST[b].append(a)
    testing = [None] * (n + 1)
    flag = 1
    for i in range(1, n + 1):
        if testing[i] != None:
            continue
        score = 1
        allscore = 1
        testing[i] = 2
        QUE = deque([i])
        while QUE:
            x = QUE.pop()
            for to in EDGELIST[x]:
                if testing[to] == -testing[x]:
                    continue
                if testing[to] == testing[x]:
                    flag = 0
                    break
                testing[to] = -testing[x]
                if testing[to] == 1:
                    score += 1
                allscore += 1
                QUE.append(to)
            if flag == 0:
                break
        if flag == 0:
            break
        ANS = ANS * calc(score, allscore) % mod
    if flag == 0:
        print(0)
        continue
    print(ANS)
```

### 200

```python
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List

def solve(N, M, A):
    dpa = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpb = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpc = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    dpd = [[0 for _ in range(M + 2)] for _ in range(N + 2)]
    for r in range(1, N + 1):
        for c in range(1, M + 1):
            dpa[r][c] = max(dpa[r - 1][c], dpa[r][c - 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(M, 0, -1):
            dpb[r][c] = max(dpb[r + 1][c], dpb[r][c + 1]) + A[r][c]
    for r in range(N, 0, -1):
        for c in range(1, M + 1):
            dpc[r][c] = max(dpc[r + 1][c], dpc[r][c - 1]) + A[r][c]
    for r in range(1, N + 1):
        for c in range(M, 0, -1):
            dpd[r][c] = max(dpd[r - 1][c], dpd[r][c + 1]) + A[r][c]
    ans = 0
    for r in range(2, N):
        for c in range(2, M):
            a = dpa[r][c - 1] + dpb[r][c + 1] + dpc[r + 1][c] + dpd[r - 1][c]
            b = dpc[r][c - 1] + dpd[r][c + 1] + dpa[r - 1][c] + dpb[r + 1][c]
            ans = max(ans, a, b)
    return ans
N, M = map(int, input().split())
A = [[0 for _ in range(M + 2)]]
for i in range(N):
    row = [0] + [int(x) for x in input().split()] + [0]
    A.append(row)
A.append([0 for _ in range(M + 2)])
print(solve(N, M, A))
```

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