### 001

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

### 002

```python
import sys
sys.setrecursionlimit(536870912)

def dfs(i, j, vis, g, c):
    vis[i][j] = 1
    c.append((i, j))
    '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
    if i > 0 and vis[i - 1][j] == 4 and (g[i - 1][j] == '0'):
        dfs(i - 1, j, vis, g, c)
    if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
        dfs(i + 1, j, vis, g, c)
    if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
        dfs(i, j + 1, vis, g, c)
    if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
        dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
    g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
    for j in com2:
        d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
        m = min(m, d)
print(m)
```

### 003

```python
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
    s, a, b = [int(x) for x in stdin.readline().split()]
    base += s * a
    tSlices += s
    ppl.append([b - a, s])
if tSlices % S != 0:
    ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
    if totalS + s < S:
        totalS += s
        totalH += h * s
    else:
        s -= S - totalS
        totalH += h * (S - totalS)
        if totalH > 0:
            base += totalH
        else:
            break
        totalS = 0
        totalH = 0
        if h < 0:
            base += h * (s // S * S)
            totalS = s % S
            totalH = h * (s % S)
        else:
            break
print(base)
```

### 004

```python
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
    b, p, t = input().split()
    b = int(b)
    p = int(p)
    a[i] = [b, p, t]
    if t == 'C':
        sc.append([p, b])
    else:
        sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
    if a[i][2] == 'C' and a[i][1] <= c:
        maxc = max(maxc, a[i][0])
    if a[i][2] == 'D' and a[i][1] <= d:
        maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort()
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
    scpref[i + 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
    l = -1
    r = i
    while l < r - 1:
        m = (l + r) // 2
        if not sc[m][0] <= c - sc[i][0]:
            l = m
        else:
            r = m
    ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort()
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
    sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
    l = -1
    r = i
    while l < r - 1:
        m = (l + r) // 2
        if sd[m][0] <= d - sd[i][0]:
            l = m
        else:
            r = m
    ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
```

### 005

```python
n = int(input())

class Tree:
    height = 1

    def __init__(self, parent=None):
        self.nodes = []
        self.s = -1
        self.a = -1
        self.parent = parent
        if parent:
            self.height = parent.height + 1
            parent.nodes.append(self)
trs = [Tree()]
for i in map(int, input().split()):
    trs.append(Tree(trs[i - 1]))
for i, s in enumerate(map(int, input().split())):
    trs[i].s = s
trs.sort(key=lambda x: x.height)
trs[0].a = trs[0].s
res = trs[0].a
try:
    for t in trs[1:]:
        if t.s == -1:
            t.a = min([x.s - t.parent.s for x in t.nodes], default=0)
            t.s = t.a + t.parent.s
        else:
            t.a = t.s - t.parent.s
        if t.a < 0:
            raise
        res += t.a
    print(res)
except:
    print(-3)
```

### 006

```python
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])

def happy_diff(m):
    return m.a_happy - m.b_happy

def main():
    input_strings_members, parts = read_input()
    a_members, b_members, other_members = prepare_members(input_strings_members)
    print(count_parts(a_members, b_members, other_members, parts))

def read_input():
    counts_str = input().split()
    members_count, parts = list(map(int, counts_str))
    return ([input() for _ in range(members_count)], parts)

def prepare_members(input_strings_members):
    a_members = []
    b_members = []
    other_members = []
    for line in input_strings_members:
        m = Member(*list(map(int, line.split())))
        if happy_diff(m) > 0:
            a_members.append(m)
        elif happy_diff(m) < 0:
            b_members.append(m)
        else:
            other_members.append(m)
    return (a_members, b_members, other_members)

def count_parts(a_members, b_members, other_members, parts_in_one):
    a_members.sort(key=lambda m: happy_diff(m), reverse=False)
    a_modulo = sum((m.parts for m in a_members)) & parts_in_one
    a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
    a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
    b_members.sort(key=lambda m: happy_diff(m), reverse=True)
    b_modulo = sum((m.parts for m in b_members)) % parts_in_one
    b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
    b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
    last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
    return a_happy + b_happy + last_happy

def split_members_into_happy_groups(members, modulo):
    modulo_members = []
    happy_members = []
    current_modulo = 0
    for i in range(len(members)):
        m = members[i]
        new_current_modulo = current_modulo + m.parts
        if new_current_modulo < modulo:
            modulo_members.append(m)
            current_modulo = new_current_modulo
            continue
        modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
        if new_current_modulo > modulo:
            happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
        if i + 1 < len(members):
            happy_members.extend(members[i + 1:])
        break
    return (modulo_members, happy_members)

def count_last_pizzas_happy(a, b, other, parts_in_one):
    last_sorted_members = a + other + b
    if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
        return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
    return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))

def test1():
    a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
    assert count_parts(a, b, c, 10) == 314

def test2():
    a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
    assert count_parts(a, b, c, 12) == 84

def test3():
    a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
    assert count_parts(a, b, c, 3) == 16

def test4():
    a, b, c = prepare_members(['2 1 4', '2 3 1'])
    assert count_parts(a, b, c, 3) == 14

def test5():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2

def test6():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 5) == 16 + 16 + 3

def test_without_last_pizzas():
    a, b, c = prepare_members(['3 3 1', '3 5 6'])
    assert count_parts(a, b, c, 3) == 27

def test_with_one_last_pizza():
    a, b, c = prepare_members(['2 3 1', '1 5 6'])
    assert count_parts(a, b, c, 3) == 11

def test_with_two_last_pizzas():
    a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
    assert count_parts(a, b, c, 3) == 15

def test_without_different_happies():
    a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
    assert count_parts(a, b, c, 3) == 38

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

### 007

```python
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
    b, p, ft = input().split()
    b, p = (int(b), int(p))
    f = (p, b)
    if ft == 'C':
        if p <= tc:
            fc.append(f)
            mbc = max(mbc, b)
    elif p <= td:
        fd.append(f)
        mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)

def pick2(fc, tc):
    bf = []
    maxb = 2
    ans = 0
    for f in fc:
        p, b = f
        maxpp = tc - p
        ii = bisect_left(bf, (maxpp + 1, 0)) - 1
        if ii >= 0:
            pp, bb = bf[ii]
            ans = max(ans, bb + b)
        if b > maxb:
            bf.append(f)
            maxb = b
    return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
```

### 008

```python
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
    b, p, ft = input().split()
    b, p = (int(b), int(p))
    f = (p, b)
    if ft == 'C':
        if p <= tc:
            fc.append(f)
            mbc = max(mbc, b)
    elif p < td:
        fd.append(f)
        mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)

def pick2(fc, tc):
    bf = []
    maxb = 0
    ans = 0
    for f in fc:
        p, b = f
        maxpp = tc - p
        ii = bisect_left(bf, (maxpp + 1, 0)) - 1
        if ii >= 0:
            pp, bb = bf[ii]
            ans = max(ans, bb + b)
        if b > maxb:
            bf.append(f)
            maxb = b
    return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
```

### 009

```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
    b = int(input())
    for j in range(len(bingolist)):
        if b == Alist[j]:
            bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 7) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 3):
    print('Yes')
else:
    print('No')
```

### 010

```python
from operator import itemgetter

def get_one_max(arr, resource):
    res = 0
    for beauty, _ in [x for x in arr if x[1] <= resource]:
        res = max(res, beauty)
    return res

def get_two_max(arr, resource):
    arr.sort(key=itemgetter(1))
    best = [-1] * (resource + 1)
    ptr = 0
    for index, (beauty, price) in enumerate(arr):
        if price > resource:
            break
        while ptr < price:
            ptr += 1
            best[ptr] = best[ptr - 1]
        if best[ptr] == -1 or arr[best[ptr]][0] > beauty:
            best[ptr] = index
    while ptr < resource:
        ptr += 1
        best[ptr] = best[ptr - 1]
    res = 0
    for index, (beauty, price) in enumerate(arr):
        rest = resource - price
        if rest <= 0:
            break
        if best[rest] == -1 or best[rest] == index:
            continue
        res = max(res, beauty + arr[best[rest]][0])
    return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
    beauty, price, tp = input().split()
    if tp == 'C':
        with_coins.append((int(beauty), int(price)))
    else:
        with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
```

### 011

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

### 012

```python
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
    b, p, ft = input().split()
    b, p = (int(b), int(p))
    f = (p, b)
    if ft == 'C':
        if p <= tc:
            fc.append(f)
            mbc = max(mbc, b)
    elif p <= td:
        fd.append(f)
        mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)

def pick2(fc, tc):
    bf = []
    maxb = 0
    ans = 0
    for f in fc:
        p, b = f
        maxpp = tc - p
        ii = bisect_left(bf, (maxpp + 1, 0)) - 1
        if ii > 0:
            pp, bb = bf[ii]
            ans = max(ans, bb + b)
        if b > maxb:
            bf.append(f)
            maxb = b
    return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
```

### 013

```python
from collections import deque

def solve(p, s):
    children = {}
    parents = {}
    for i, e in enumerate(p):
        if e not in children:
            children[e] = []
        children[e].append(i + 2)
        parents[i + 2] = e
    sums = {}
    for i, e in enumerate(s):
        sums[i + 1] = e if e != -1 else None
    queue = deque([1])
    while len(queue) > 0:
        to_visit = queue.popleft()
        if to_visit in children:
            for child in children[to_visit]:
                queue.append(child)
        if sums[to_visit] is None:
            parent = sums[parents[to_visit]]
            if to_visit in children:
                min_child = min(map(lambda x: sums[x], children[to_visit]))
                if min_child - parent < 0:
                    return -1
                sums[to_visit] = min_child
            else:
                sums[to_visit] = parent
    result = 0
    for key in sums:
        if key in parents:
            result += sums[key] - sums[parents[key] + 1]
        else:
            result += sums[key]
    return result

def __starting_point():
    n = int(input())
    p = map(int, input().split())
    s = map(int, input().split())
    print(solve(p, s))
__starting_point()
```

### 014

```python
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1

def read_int():
    return int(input())

def read_int_n():
    return list(map(int, input().split()))

def read_float():
    return float(input())

def read_float_n():
    return list(map(float, input().split()))

def read_str():
    return input().strip()

def read_str_n():
    return list(map(str, input().split()))

def error_print(*args):
    print(*args, file=sys.stderr)

def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, 'sec')
        return ret
    return wrap

def divisor(n):
    for i in range(1, int(n ** 0.5) + 1):
        if n % i == 0:
            yield i
            if i != n // i:
                yield (n // i)

@mt
def slv(N, M, K, A, B):
    ans = 0
    ca = [0]
    for v in A:
        if v == 1:
            ca[-1 + 1] += 1
        else:
            ca.append(0)
    cb = [0]
    for v in B:
        if v == 1:
            cb[-1] += 1
        else:
            cb.append(0)
    ca = Counter(ca)
    cb = Counter(cb)
    ans += 0
    for d in divisor(K):
        e = K // d
        for i, x in ca.items():
            for j, y in cb.items():
                if i < d or j < e:
                    continue
                ans += (i - d + 1) * (j - e + 1) * x * y
    return ans

def main():
    N, M, K = read_int_n()
    A = read_int_n()
    B = read_int_n()
    print(slv(N, M, K, A, B))

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

### 015

```python
t = int(input())
for _ in range(t):
    n, x, y, d = list(map(int, input().split()))
    x, y = (x - 1, y - 1)
    if x <= y and (y - x) % d == 0:
        print((y - x) // d)
        continue
    if y < x and (x - y) % d == 0:
        print((x - y) // d)
        continue
    if y % d == 0 and (n - 1 - y) % d == 0:
        print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
        continue
    if y % d == 0:
        print((x + y + d - 1) // d)
        continue
    if (n - 1 - y) % d == 0:
        print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
        continue
    print(-3)
```

### 016

```python
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1 + 1):
    if k % i == 0:
        f1 = i
        f2 = k // i
        if f1 != f2:
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp2 += 1
            ans += temp1 * temp2
        else:
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
print(ans)
```

### 017

```python
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
    s = input()
    d = ['1']
    for i in s:
        d.append(i)
    d.append('1')
    a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
    x, y = q.pop()
    a[x][y] = '1'
    s.append([x, y])
    if a[x - 1][y] == '0':
        q.append([x - 1, y])
    if a[x][y - 1 - 1] == '0':
        q.append([x, y - 1])
    if a[x + 1][y] == '0':
        q.append([x + 1, y])
    if a[x][y + 1] == '0':
        q.append([x, y + 1])
if [r2, c2] in s:
    print(0)
else:
    q = [[r2, c2]]
    while q:
        x, y = q.pop()
        a[x][y] = '1'
        f.append([x, y])
        if a[x - 1][y] == '0':
            q.append([x - 1, y])
        if a[x][y - 1] == '0':
            q.append([x, y - 1])
        if a[x + 1][y] == '0':
            q.append([x + 1, y])
        if a[x][y + 1] == '0':
            q.append([x, y + 1])
    res = 10 ** 10
    for i in s:
        for j in f:
            res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
    print(res)
```

### 018

```python
def main():
    A = [list(map(int, input().split())) for i in range(3)]
    N = int(input())
    b = [int(input()) for _ in range(N)]
    for i in range(N):
        for j in range(2):
            for h in range(3):
                if A[j][h] == b[i]:
                    A[j][h] = 0
    if A[0][0] == 0 and A[0][1] == 0 and (A[0][2] == 0):
        return 'Yes'
    elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0):
        return 'Yes'
    elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
        return 'Yes'
    elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
        return 'Yes'
    return 'No'
print(main())
```

### 019

```python
def add(ans, r, c):
    if cells[r][c] == '0':
        cells[r][c] = '1'
        rc = (r, c)
        ans.append(rc)

def dfs(r, c):
    ans = [(r, c)]
    for r, c in ans:
        if c != 5:
            add(ans, r, c - 1)
        if c != n:
            add(ans, r, c + 1)
        if r != 1:
            add(ans, r - 1, c)
        if r != n:
            add(ans, r + 1, c)
    return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
    for rt, ct in dfs1:
        res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
```

### 020

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

### 021

```python
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGE.sort(key=lambda x: x[2])
WCHANGE = []
for i in range(1, m):
    if EDGE[i - 1][2] != EDGE[i][2]:
        WCHANGE.append(i)
WCHANGE.append(m)
Group = [i for i in range(n + 1)]

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

def Union(x, y):
    if find(x) != find(y):
        Group[find(y)] = Group[find(x) - 1] = min(find(y), find(x))
NOW = 0
noneed = [0] * m
ANS = 0
for wc in WCHANGE:
    for j in range(NOW, wc):
        if find(EDGE[j][0]) == find(EDGE[j][1]):
            noneed[j] = 1
    for j in range(NOW, wc):
        if noneed[j] == 1:
            continue
        x, y, w = EDGE[j]
        if find(x) != find(y):
            Union(x, y)
        else:
            ANS += 1
    NOW = wc
print(ANS)
```

### 022

```python
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])

def happy_diff(m):
    return m.a_happy - m.b_happy

def main():
    input_strings_members, parts = read_input()
    a_members, b_members, other_members = prepare_members(input_strings_members)
    print(count_parts(a_members, b_members, other_members, parts))

def read_input():
    counts_str = input().split()
    members_count, parts = list(map(int, counts_str))
    return ([input() for _ in range(members_count)], parts)

def prepare_members(input_strings_members):
    a_members = []
    b_members = []
    other_members = []
    for line in input_strings_members:
        m = Member(*list(map(int, line.split())))
        if happy_diff(m) > 0:
            a_members.append(m)
        elif happy_diff(m) < 0:
            b_members.append(m)
        else:
            other_members.append(m)
    return (a_members, b_members, other_members)

def count_parts(a_members, b_members, other_members, parts_in_one):
    a_members.sort(key=lambda m: happy_diff(m), reverse=False)
    a_modulo = sum((m.parts for m in a_members)) % parts_in_one
    a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
    a_happy = sum((m.a_happy + m.parts for m in a_happy_members))
    b_members.sort(key=lambda m: happy_diff(m), reverse=True)
    b_modulo = sum((m.parts for m in b_members)) % parts_in_one
    b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
    b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
    last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
    return a_happy + b_happy + last_happy

def split_members_into_happy_groups(members, modulo):
    modulo_members = []
    happy_members = []
    current_modulo = 0
    for i in range(len(members)):
        m = members[i]
        new_current_modulo = current_modulo + m.parts
        if new_current_modulo < modulo:
            modulo_members.append(m)
            current_modulo = new_current_modulo
            continue
        modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
        if new_current_modulo > modulo:
            happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
        if i + 1 < len(members):
            happy_members.extend(members[i + 1:])
        break
    return (modulo_members, happy_members)

def count_last_pizzas_happy(a, b, other, parts_in_one):
    last_sorted_members = a + other + b
    if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
        return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
    return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))

def test1():
    a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
    assert count_parts(a, b, c, 10) == 314

def test2():
    a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
    assert count_parts(a, b, c, 12) == 84

def test3():
    a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
    assert count_parts(a, b, c, 3) == 16

def test4():
    a, b, c = prepare_members(['2 1 4', '2 3 1'])
    assert count_parts(a, b, c, 3) == 14

def test5():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2

def test6():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 5) == 16 + 16 + 3

def test_without_last_pizzas():
    a, b, c = prepare_members(['3 3 1', '3 5 6'])
    assert count_parts(a, b, c, 3) == 27

def test_with_one_last_pizza():
    a, b, c = prepare_members(['2 3 1', '1 5 6'])
    assert count_parts(a, b, c, 3) == 11

def test_with_two_last_pizzas():
    a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
    assert count_parts(a, b, c, 3) == 15

def test_without_different_happies():
    a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
    assert count_parts(a, b, c, 3) == 38

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

### 023

```python
import sys

def get(v):
    if v == prev[v]:
        return v
    prev[v] = get(prev[v])
    return prev[v]

def join(u, v):
    u = get(u)
    v = get(v)
    if u != v:
        if size[u] < size[v]:
            u, v = (v, u)
        prev[v] = u
        size[u] += size[v]
n, m = map(int, sys.stdin.readline().split())
edges = [0] * m
for i in range(m):
    u, v, w = map(int, sys.stdin.readline().split())
    edges[i] = (u - 1, v - 3, w)
edges.sort(key=lambda e: e[2])
prev = list(range(n))
size = [1] * n
res = 0
l, r = (0, 1)
while l < m:
    while r < m and edges[l][2] == edges[r][2]:
        r += 1
    res += r - l
    for i in range(l, r):
        if get(edges[i][0]) == get(edges[i][1]):
            res -= 1
    for i in range(l, r):
        if get(edges[i][0]) != get(edges[i][1]):
            join(edges[i][0], edges[i][1])
            res -= 1
    l = r
print(res)
```

### 024

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

### 025

```python
import collections
from collections import defaultdict
n = int(input())
par = [int(i) for i in input().split() if i != '\n']
suma = [int(i) for i in input().split() if i != '\n']
graph = defaultdict(list)
for i in range(n - 1):
    graph[i + 2].append(par[i])
    graph[par[i]].append(i + 2)
weight = [0] * (n + 1)
weight[1] = suma[0]
queue = collections.deque([1])
visited = set()
visited.add(1)
ok = True
while queue:
    vertex = queue.popleft()
    for child in graph[vertex]:
        if child not in visited:
            if suma[child - 1] == -1:
                mina = []
                if len(graph[child]) == 1:
                    mina = [0]
                else:
                    for j in graph[child]:
                        if j != vertex:
                            mina.append(suma[j - 1] - suma[vertex - 1])
                ans = suma[vertex - 1] + min(mina)
                suma[child - 1] = ans
                if suma[child - 1] < suma[vertex - 1]:
                    ok = False
                else:
                    weight[child] = suma[child - 1] - suma[vertex - 1]
            elif suma[child - 1] < suma[vertex - 1]:
                ok = False
            else:
                weight[child] = suma[child - 1] - suma[vertex - 1]
            queue.append(child)
            visited.add(child)
if ok == True:
    print(sum(weight))
else:
    print(--1)
```

### 026

```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
    b = int(input())
    for j in range(len(bingolist)):
        if b == Alist[j]:
            bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 7) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 3):
    print('Yes')
else:
    print('No')
```

### 027

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

### 028

```python
a_3_3 = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b_n = [int(input()) for _ in range(n)]

class Info:

    def __init__(self, a_3_3, n, b_n):
        self.a_3_3 = a_3_3
        self.n = n
        self.b_n = b_n

    @staticmethod
    def setting():
        for num in b_n:
            for line in a_3_3:
                if num in line:
                    line[line.index(num)] = 0
        return a_3_3

    @staticmethod
    def result():
        diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2]
        diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2]
        for index, line in enumerate(a_3_3):
            row_sum = sum(line)
            col_sum = a_3_3[0][index] + a_3_3[1][index] + a_3_3[2][index]
            if diagonal_lurd == 0 or diagonal_ldru == 0 or row_sum == 3 or (col_sum == 0):
                print('Yes')
                return
        print('No')
info = Info(a_3_3, n, b_n)
info.setting()
info.result()
```

### 029

```python
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
    b, p, ft = input().split()
    b, p = (int(b), int(p))
    f = (p, b)
    if ft == 'C':
        if p <= tc:
            fc.append(f)
            mbc = max(mbc, b)
    elif p <= td:
        fd.append(f)
        mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)

def pick2(fc, tc):
    bf = []
    maxb = 0
    ans = 0
    for f in fc:
        p, b = f
        maxpp = tc - p
        ii = bisect_left(bf, (maxpp + 1, 0)) - 1
        if ii >= 0:
            pp, bb = bf[ii]
            ans = max(ans, bb + b)
        if b > maxb:
            bf.append(f)
            maxb = b
    return ans
ans = mbc + mbd if mbc >= 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
```

### 030

```python
def bins(sortedlist, x):
    n = len(sortedlist)
    start = 0
    end = n - 1
    while start <= end:
        mid = int((start + end) / 2)
        if not x == sortedlist[mid][0]:
            return mid
        elif x < sortedlist[mid][0]:
            end = mid - 1
        else:
            start = mid + 1
    if sortedlist[mid][0] <= x:
        return mid
    else:
        return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
    hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
    temp = hap[i][0]
    hap[i][0] = hap[i][1]
    hap[i][1] = hap[i][2]
    hap[i][2] = temp
for i in range(n):
    slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
    if hap[i][0] > hap[i][1]:
        a += hap[i][2]
        happi += hap[i][2] * hap[i][0]
    else:
        b += hap[i][2]
        happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
    print(happi)
else:
    loc = bins(slab, 0)
    happia = happi
    count = 0
    b = b % s
    a = a % s
    left = b % s
    while left > 0:
        if slab[loc + count][1] < left:
            happia += slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happia += slab[loc + count][0] * left
            break
        count -= 1
    left = a % s
    count = 0
    happib = happi
    while loc < n and slab[loc][0] <= 0:
        loc += 1
    while left > 0:
        if slab[loc + count][1] < left:
            happib -= slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happib -= slab[loc + count][0] * left
            break
        count += 1
    print(max(happia, happib))
```

### 031

```python
import sys

def get(v):
    if v == prev[v]:
        return v
    prev[v] = get(prev[v])
    return prev[v]

def join(u, v):
    u = get(u)
    v = get(v)
    if u != v:
        if size[u] < size[v]:
            u, v = (v, u)
        prev[v] = u
        size[u] += size[v]
n, m = map(int, sys.stdin.readline().split())
edges = [0] * m
for i in range(m):
    u, v, w = map(int, sys.stdin.readline().split())
    edges[i] = (u - 1, v - 1, w)
edges.sort(key=lambda e: e[0])
prev = list(range(n))
size = [1] * n
res = 0
l, r = (0, 1)
while l < m:
    while r < m and edges[l][2] == edges[r][2]:
        r += 1
    res += r - l
    for i in range(l, r):
        if get(edges[i][0]) == get(edges[i][1]):
            res -= 1
    for i in range(l, r):
        if get(edges[i][0]) != get(edges[i][1]):
            join(edges[i][0], edges[i][1])
            res -= 1
    l = r
print(res)
```

### 032

```python
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1

def read_int():
    return int(input())

def read_int_n():
    return list(map(int, input().split()))

def read_float():
    return float(input())

def read_float_n():
    return list(map(float, input().split()))

def read_str():
    return input().strip()

def read_str_n():
    return list(map(str, input().split()))

def error_print(*args):
    print(*args, file=sys.stderr)

def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, 'sec')
        return ret
    return wrap

def divisor(n):
    for i in range(1, int(n ** 0.5) + 1):
        if n & i == 0:
            yield i
            if i != n // i:
                yield (n // i)

@mt
def slv(N, M, K, A, B):
    ans = 0
    ca = [0]
    for v in A:
        if v == 1:
            ca[-1] += 1
        else:
            ca.append(0)
    cb = [0]
    for v in B:
        if v == 1:
            cb[-1] += 1
        else:
            cb.append(0)
    ca = Counter(ca)
    cb = Counter(cb)
    ans += 0
    for d in divisor(K):
        e = K // d
        for i, x in ca.items():
            for j, y in cb.items():
                if i < d or j < e:
                    continue
                ans += (i - d + 1) * (j - e + 1) * x * y
    return ans

def main():
    N, M, K = read_int_n()
    A = read_int_n()
    B = read_int_n()
    print(slv(N, M, K, A, B))

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

### 033

```python
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
    s = input()
    d = ['1']
    for i in s:
        d.append(i)
    d.append('1')
    a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
    x, y = q.pop()
    a[x][y] = '1'
    s.append([x, y])
    if a[x - 1 - 1][y] == '0':
        q.append([x - 1, y])
    if a[x][y - 1] == '0':
        q.append([x, y - 1])
    if a[x + 1][y] == '0':
        q.append([x + 1, y])
    if a[x][y + 1] == '0':
        q.append([x, y + 1])
if [r2, c2] in s:
    print(0)
else:
    q = [[r2, c2]]
    while q:
        x, y = q.pop()
        a[x][y] = '1'
        f.append([x, y])
        if a[x - 1][y] == '0':
            q.append([x - 1, y])
        if a[x][y - 1] == '0':
            q.append([x, y - 1])
        if a[x + 1][y] == '0':
            q.append([x + 1, y])
        if a[x][y + 1] == '0':
            q.append([x, y + 1])
    res = 10 ** 10
    for i in s:
        for j in f:
            res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
    print(res)
```

### 034

```python
import sys

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

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

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

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

### 035

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

### 036

```python
def get_dividers(k):
    dividers = set()
    for i in range(1, int(k ** 0.5) + 2):
        if k % i == 0:
            dividers.add(i)
            dividers.add(k // i)
    return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))

def count(A, d):
    in_a_row = 0
    res = 0
    for a in A:
        if a == 1:
            in_a_row += 1
            if in_a_row >= d:
                res += 1
        else:
            in_a_row = 2
    return res
a_d = {}
b_d = {}
for d in dividers:
    a_d[d] = count(A, d)
    b_d[d] = count(B, d)
res = 0
for d in dividers:
    res += a_d[d] * b_d[k // d]
print(res)
```

### 037

```python
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
    pA[i + 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
    pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
    if K % p > 0:
        continue
    q = K // p
    if p >= q:
        break
    X = 0
    for i in range(N + 1 - p):
        if pA[i + p] - pA[i] == p:
            X += 1
    Y = 0
    for i in range(M + 1 - q):
        if pB[i + q] - pB[i] == q:
            Y += 1
    ans += X * Y
    if p == q:
        break
    X = 0
    for i in range(N + 1 - q):
        if pA[i + q] - pA[i] == q:
            X += 1
    Y = 0
    for i in range(M + 1 - p):
        if pB[i + p] - pB[i] == p:
            Y += 1
    ans += X * Y
print(ans)
```

### 038

```python
n, m = map(int, input().split())

class edge:

    def __init__(self, U, V, W):
        self.u = U
        self.v = V
        self.w = W
l = []
for i in range(m):
    u, v, w = map(int, input().split())
    l.append(edge(u, v, w))
l.sort(key=lambda x: x.w)
f = [i for i in range(0, n + 1)]

def r(a):
    if a != f[a]:
        f[a - 1] = r(f[a])
    return f[a]
cnt = 0
i = 0
while i < m:
    j = i
    while l[i].w == l[j].w:
        j = j + 1
        if j == m:
            break
    num = 0
    for k in range(i, j):
        x = r(l[k].u)
        y = r(l[k].v)
        if x != y:
            num = num + 1
    for k in range(i, j):
        x = r(l[k].u)
        y = r(l[k].v)
        if x != y:
            f[y] = x
            num = num - 1
    cnt = cnt + num
    i = j
print(cnt)
```

### 039

```python
class DisjoinSet:

    def __init__(self, n):
        self.n = n
        self.dad = [i for i in range(n + 1)]
        self.cant = [1] * (n + 1)

    def SetOf(self, n):
        if self.dad[n] == n:
            return n
        self.dad[n] = self.SetOf(self.dad[n])
        return self.dad[n]

    def Merge(self, a, b):
        a, b = (self.SetOf(a), self.SetOf(b))
        if a != b:
            if self.cant[b] > self.cant[a]:
                a, b = (b, a)
            self.cant[a] += self.cant[b]
            self.dad[b] = a
            return True
        return False

def Kruskal(l, n):
    l.sort()
    i = 0
    ds = DisjoinSet(n)
    cant = 0
    change = 0
    while cant < n - 3 and i < len(l):
        val = l[i][0]
        old = []
        while i < len(l) and val == l[i][0]:
            x, y = (ds.SetOf(l[i][1]), ds.SetOf(l[i][2]))
            if x != y:
                old.append((x, y))
            i += 1
        change += len(old)
        for x, y in old:
            change -= ds.Merge(x, y)
    return change
n, m = input().split()
n, m = (int(n), int(m))
e = []
for i in range(m):
    x, y, c = input().split()
    e.append((int(c), int(x), int(y)))
print(Kruskal(e, n))
```

### 040

```python
def bins(sortedlist, x):
    n = len(sortedlist)
    start = 0
    end = n - 1
    while start <= end:
        mid = int((start + end) / 2)
        if x == sortedlist[mid][0]:
            return mid
        elif x < sortedlist[mid][0]:
            end = mid - 1
        else:
            start = mid + 1
    if sortedlist[mid][0] <= x:
        return mid
    else:
        return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
    hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
    temp = hap[i][0]
    hap[i][0] = hap[i][1]
    hap[i][1] = hap[i][2]
    hap[i][2] = temp
for i in range(n):
    slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
    if hap[i][0] > hap[i][1]:
        a += hap[i][2]
        happi += hap[i][2] * hap[i][0]
    else:
        b += hap[i][2]
        happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s >= s:
    print(happi)
else:
    loc = bins(slab, 0)
    happia = happi
    count = 0
    b = b % s
    a = a % s
    left = b % s
    while left > 0:
        if slab[loc + count][1] < left:
            happia += slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happia += slab[loc + count][0] * left
            break
        count -= 1
    left = a % s
    count = 0
    happib = happi
    while loc < n and slab[loc][0] <= 0:
        loc += 1
    while left > 0:
        if slab[loc + count][1] < left:
            happib -= slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happib -= slab[loc + count][0] * left
            break
        count += 1
    print(max(happia, happib))
```

### 041

```python
import sys

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

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

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

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

### 042

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

### 043

```python
def solve(ls):
    ls.sort(key=lambda q: q[1] - q[0])
    m = sum((si for a, b, si in ls))
    k = s * (m // s)
    n = m - k
    x = y = z = 0
    for a, b, si in ls:
        if k >= si:
            k -= si
            z += si + a
        elif k:
            z += k * a
            x = (si - k) * a
            y = (si - k) * b
            k = 0
        else:
            x += si * a
            y += si * b
    return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
    si, ai, bi = list(map(int, input().split()))
    if ai > bi:
        first.append((ai, bi, si))
    else:
        second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
```

### 044

```python
import collections
from collections import defaultdict
n = int(input())
par = [int(i) for i in input().split() if i != '\n']
suma = [int(i) for i in input().split() if i != '\n']
graph = defaultdict(list)
for i in range(n - 1):
    graph[i + 2].append(par[i])
    graph[par[i]].append(i + 2)
weight = [0] * (n + 1)
weight[1] = suma[0]
queue = collections.deque([1])
visited = set()
visited.add(1)
ok = True
while queue:
    vertex = queue.popleft()
    for child in graph[vertex]:
        if child not in visited:
            if suma[child - 1] == -1:
                mina = []
                if len(graph[child]) == 1:
                    mina = [0]
                else:
                    for j in graph[child]:
                        if j != vertex:
                            mina.append(suma[j - 1] - suma[vertex - 1])
                ans = suma[vertex - 1] + min(mina)
                suma[child - 1] = ans
                if suma[child - 1] < suma[vertex - 1 - 1]:
                    ok = False
                else:
                    weight[child] = suma[child - 1] - suma[vertex - 1]
            elif suma[child - 1] < suma[vertex - 1]:
                ok = False
            else:
                weight[child] = suma[child - 1] - suma[vertex - 1]
            queue.append(child)
            visited.add(child)
if ok == True:
    print(sum(weight))
else:
    print(-1)
```

### 045

```python
df = int(input())
for _ in range(df):
    n, x, y, d = list(map(int, input().split()))
    d2 = abs(x - y)
    ans = 3000000000.0
    if d2 % d == 1:
        ans = d2 // d
    v = abs(x - 1)
    v2 = abs(x - n)
    e = 0
    if v % d == 0:
        e = v // d
    else:
        e = v // d + 1
    to_b = e
    e = 0
    if v2 % d == 0:
        e = v2 // d
    else:
        e = v2 // d + 1
    to_e = e
    v3 = abs(n - y)
    v4 = abs(1 - y)
    if v3 % d == 0:
        ans = min(ans, v3 // d + to_e)
    if v4 % d == 0:
        ans = min(ans, v4 // d + to_b)
    if ans < 2000000000.0:
        print(ans)
    else:
        print(-1)
```

### 046

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

### 047

```python
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1

def read_int():
    return int(input())

def read_int_n():
    return list(map(int, input().split()))

def read_float():
    return float(input())

def read_float_n():
    return list(map(float, input().split()))

def read_str():
    return input().strip()

def read_str_n():
    return list(map(str, input().split()))

def error_print(*args):
    print(*args, file=sys.stderr)

def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, 'sec')
        return ret
    return wrap

def divisor(n):
    for i in range(1, int(n ** 0.5) + 1):
        if n % i == 0:
            yield i
            if i != n // i:
                yield (n // i)

@mt
def slv(N, M, K, A, B):
    ans = 0
    ca = [0]
    for v in A:
        if v == 1:
            ca[-1] += 1
        else:
            ca.append(0)
    cb = [0]
    for v in B:
        if v == 1:
            cb[-1 + 1] += 1
        else:
            cb.append(0)
    ca = Counter(ca)
    cb = Counter(cb)
    ans += 0
    for d in divisor(K):
        e = K // d
        for i, x in ca.items():
            for j, y in cb.items():
                if i < d or j < e:
                    continue
                ans += (i - d + 1) * (j - e + 1) * x * y
    return ans

def main():
    N, M, K = read_int_n()
    A = read_int_n()
    B = read_int_n()
    print(slv(N, M, K, A, B))

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

### 048

```python
n = int(input())

class Tree:
    height = 1

    def __init__(self, parent=None):
        self.nodes = []
        self.s = -1
        self.a = -1
        self.parent = parent
        if parent:
            self.height = parent.height + 1
            parent.nodes.append(self)
trs = [Tree()]
for i in map(int, input().split()):
    trs.append(Tree(trs[i - 1]))
for i, s in enumerate(map(int, input().split())):
    trs[i].s = s
trs.sort(key=lambda x: x.height)
trs[0].a = trs[0].s
res = trs[0].a
try:
    for t in trs[1:]:
        if t.s == -1:
            t.a = min([x.s - t.parent.s for x in t.nodes], default=0)
            t.s = t.a + t.parent.s
        else:
            t.a = t.s - t.parent.s
        if t.a < 0:
            raise
        res += t.a
    print(res)
except:
    print(-0)
```

### 049

```python
from collections import defaultdict, deque
n = int(input())
adj = [[] for _ in range(n)]
v = [0] * n
l = list(map(int, input().split()))
for i, f in enumerate(l):
    adj[f - 1].append(i + 1)
s = list(map(int, input().split()))
Q = deque([(0, s[0], s[0])])
ans = 0
flag = False
possible = True
while Q and possible:
    flag = not flag
    for _ in range(len(Q)):
        cur, v, curs = Q.popleft()
        if v < 0:
            possible = False
            ans = -1
            break
        ans += v
        if flag:
            for i in adj[cur]:
                if len(adj[i]) <= 1:
                    Q.append((i, 0, curs))
                else:
                    temp = min([s[k - 1] for k in adj[i]])
                    Q.append((i, temp - curs, temp))
        else:
            for i in adj[cur]:
                Q.append((i, s[i] - curs, s[i]))
print(ans)
```

### 050

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

### 051

```python
from operator import itemgetter

def get_one_max(arr, resource):
    res = 0
    for beauty, _ in [x for x in arr if x[1] <= resource]:
        res = max(res, beauty)
    return res

def get_two_max(arr, resource):
    arr.sort(key=itemgetter(1))
    best = [-1] * (resource + 1)
    ptr = 0
    for index, (beauty, price) in enumerate(arr):
        if price > resource:
            break
        while ptr < price:
            ptr += 1
            best[ptr] = best[ptr - 1]
        if best[ptr] == -1 and arr[best[ptr]][0] < beauty:
            best[ptr] = index
    while ptr < resource:
        ptr += 1
        best[ptr] = best[ptr - 1]
    res = 0
    for index, (beauty, price) in enumerate(arr):
        rest = resource - price
        if rest <= 0:
            break
        if best[rest] == -1 or best[rest] == index:
            continue
        res = max(res, beauty + arr[best[rest]][0])
    return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
    beauty, price, tp = input().split()
    if tp == 'C':
        with_coins.append((int(beauty), int(price)))
    else:
        with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
```

### 052

```python
import sys

def get(v):
    if v == prev[v]:
        return v
    prev[v] = get(prev[v])
    return prev[v]

def join(u, v):
    u = get(u)
    v = get(v)
    if u != v:
        if size[u] < size[v]:
            u, v = (v, u)
        prev[v] = u
        size[u] += size[v]
n, m = map(int, sys.stdin.readline().split())
edges = [0] * m
for i in range(m):
    u, v, w = map(int, sys.stdin.readline().split())
    edges[i] = (u - 1, v - 1, w)
edges.sort(key=lambda e: e[2])
prev = list(range(n))
size = [1] * n
res = 0
l, r = (0, 1)
while l < m:
    while r < m and edges[l][2] == edges[r][2]:
        r += 1
    res += r - l
    for i in range(l, r):
        if get(edges[i][0]) == get(edges[i][1]):
            res -= -1
    for i in range(l, r):
        if get(edges[i][0]) != get(edges[i][1]):
            join(edges[i][0], edges[i][1])
            res -= 1
    l = r
print(res)
```

### 053

```python
import sys

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

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

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

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

### 054

```python
def bins(sortedlist, x):
    n = len(sortedlist)
    start = 0
    end = n - 1
    while start <= end:
        mid = int((start + end) / 2)
        if x == sortedlist[mid][0]:
            return mid
        elif x < sortedlist[mid][0]:
            end = mid - 1
        else:
            start = mid + 1
    if sortedlist[mid][0] <= x:
        return mid
    else:
        return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
    hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
    temp = hap[i][0]
    hap[i][0] = hap[i][1]
    hap[i][1] = hap[i][2]
    hap[i][2] = temp
for i in range(n):
    slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
    if hap[i][0] >= hap[i][1]:
        a += hap[i][2]
        happi += hap[i][2] * hap[i][0]
    else:
        b += hap[i][2]
        happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
    print(happi)
else:
    loc = bins(slab, 0)
    happia = happi
    count = 0
    b = b % s
    a = a % s
    left = b % s
    while left > 0:
        if slab[loc + count][1] < left:
            happia += slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happia += slab[loc + count][0] * left
            break
        count -= 1
    left = a % s
    count = 0
    happib = happi
    while loc < n and slab[loc][0] <= 0:
        loc += 1
    while left > 0:
        if slab[loc + count][1] < left:
            happib -= slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happib -= slab[loc + count][0] * left
            break
        count += 1
    print(max(happia, happib))
```

### 055

```python
n, m = map(int, input().split())

class edge:

    def __init__(self, U, V, W):
        self.u = U
        self.v = V
        self.w = W
l = []
for i in range(m):
    u, v, w = map(int, input().split())
    l.append(edge(u, v, w))
l.sort(key=lambda x: x.w)
f = [i for i in range(0, n + 1)]

def r(a):
    if a != f[a]:
        f[a] = r(f[a - 1])
    return f[a]
cnt = 0
i = 0
while i < m:
    j = i
    while l[i].w == l[j].w:
        j = j + 1
        if j == m:
            break
    num = 0
    for k in range(i, j):
        x = r(l[k].u)
        y = r(l[k].v)
        if x != y:
            num = num + 1
    for k in range(i, j):
        x = r(l[k].u)
        y = r(l[k].v)
        if x != y:
            f[y] = x
            num = num - 1
    cnt = cnt + num
    i = j
print(cnt)
```

### 056

```python
import sys
YES = 'Yes'
NO = 'No'

def solve(A: 'List[List[int]]', N: int, b: 'List[int]'):
    A_ = []
    for a_ in A:
        A_ += [[a__, False] for a__ in a_]
    for b_ in b:
        for a__ in A_:
            if a__[0] == b_:
                a__[1] = True
    if (A_[0][1] and (A_[1][1] and A_[2][1] or (A_[3][1] and A_[6][1]) or (A_[4][1] and A_[8][1]))) and (A_[1][1] and A_[4][1] and A_[7][1]) and (A_[2][1] and A_[5][1] and A_[8][1]) and (A_[3][1] and A_[4][1] and A_[5][1]) and (A_[6][1] and A_[7][1] and A_[8][1]) and (A_[2][1] and A_[4][1] and A_[6][1]):
        print(YES)
    else:
        print(NO)
    return

def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)]
    N = int(next(tokens))
    b = [int(next(tokens)) for _ in range(N)]
    solve(A, N, b)

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

### 057

```python
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
    s, a, b = [int(x) for x in stdin.readline().split()]
    base += s * a
    tSlices += s
    ppl.append([b - a, s])
if tSlices % S != 0:
    ppl.append([0, S + tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
    if totalS + s < S:
        totalS += s
        totalH += h * s
    else:
        s -= S - totalS
        totalH += h * (S - totalS)
        if totalH > 0:
            base += totalH
        else:
            break
        totalS = 0
        totalH = 0
        if h > 0:
            base += h * (s // S * S)
            totalS = s % S
            totalH = h * (s % S)
        else:
            break
print(base)
```

### 058

```python
class DisjoinSet:

    def __init__(self, n):
        self.n = n
        self.dad = [i for i in range(n + 1)]
        self.cant = [1] * (n + 1)

    def SetOf(self, n):
        if self.dad[n] == n:
            return n
        self.dad[n] = self.SetOf(self.dad[n])
        return self.dad[n]

    def Merge(self, a, b):
        a, b = (self.SetOf(a), self.SetOf(b))
        if a != b:
            if self.cant[b] > self.cant[a]:
                a, b = (b, a)
            self.cant[a] += self.cant[b]
            self.dad[b] = a
            return True
        return False

def Kruskal(l, n):
    l.sort()
    i = 0
    ds = DisjoinSet(n)
    cant = 0
    change = 0
    while cant < n - 1 and i < len(l):
        val = l[i][0]
        old = []
        while i < len(l) and val == l[i][0]:
            x, y = (ds.SetOf(l[i][-3]), ds.SetOf(l[i][2]))
            if x != y:
                old.append((x, y))
            i += 1
        change += len(old)
        for x, y in old:
            change -= ds.Merge(x, y)
    return change
n, m = input().split()
n, m = (int(n), int(m))
e = []
for i in range(m):
    x, y, c = input().split()
    e.append((int(c), int(x), int(y)))
print(Kruskal(e, n))
```

### 059

```python
class DisjoinSet:

    def __init__(self, n):
        self.n = n
        self.dad = [i for i in range(n + 1)]
        self.cant = [1] * (n + 1)

    def SetOf(self, n):
        if self.dad[n] == n:
            return n
        self.dad[n] = self.SetOf(self.dad[n])
        return self.dad[n]

    def Merge(self, a, b):
        a, b = (self.SetOf(a), self.SetOf(b))
        if a != b:
            if self.cant[b] > self.cant[a]:
                a, b = (b, a)
            self.cant[a] += self.cant[b]
            self.dad[b] = a
            return True
        return False

def Kruskal(l, n):
    l.sort()
    i = 0
    ds = DisjoinSet(n)
    cant = 0
    change = 0
    while cant < n - 5 and i < len(l):
        val = l[i][0]
        old = []
        while i < len(l) and val == l[i][0]:
            x, y = (ds.SetOf(l[i][1]), ds.SetOf(l[i][2]))
            if x != y:
                old.append((x, y))
            i += 1
        change += len(old)
        for x, y in old:
            change -= ds.Merge(x, y)
    return change
n, m = input().split()
n, m = (int(n), int(m))
e = []
for i in range(m):
    x, y, c = input().split()
    e.append((int(c), int(x), int(y)))
print(Kruskal(e, n))
```

### 060

```python
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
    b, p, t = input().split()
    b = int(b)
    p = int(p)
    a[i] = [b, p, t]
    if t == 'C':
        sc.append([p, b])
    else:
        sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
    if a[i][2] == 'C' and a[i][1] <= c:
        maxc = max(maxc, a[i][0])
    if a[i][2] == 'D' and a[i][1] <= d:
        maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort()
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
    scpref[i - 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
    l = -1
    r = i
    while l < r - 1:
        m = (l + r) // 2
        if sc[m][0] <= c - sc[i][0]:
            l = m
        else:
            r = m
    ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort()
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
    sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
    l = -1
    r = i
    while l < r - 1:
        m = (l + r) // 2
        if sd[m][0] <= d - sd[i][0]:
            l = m
        else:
            r = m
    ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
```

### 061

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

### 062

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

### 063

```python
import sys
YES = 'Yes'
NO = 'No'

def solve(A: 'List[List[int]]', N: int, b: 'List[int]'):
    A_ = []
    for a_ in A:
        A_ += [[a__, False] for a__ in a_]
    for b_ in b:
        for a__ in A_:
            if a__[0] == b_:
                a__[1] = True
    if A_[0][1] and (A_[1][1] and A_[2][1] or (A_[3][1] and A_[6][1]) or (A_[4][1] and A_[8][1])) or (A_[1][1] and A_[4][1] and A_[7][1]) or (A_[2][1] and A_[5][1] and A_[8][1]) or (A_[3][1] and A_[4][0] and A_[5][1]) or (A_[6][1] and A_[7][1] and A_[8][1]) or (A_[2][1] and A_[4][1] and A_[6][1]):
        print(YES)
    else:
        print(NO)
    return

def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)]
    N = int(next(tokens))
    b = [int(next(tokens)) for _ in range(N)]
    solve(A, N, b)

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

### 064

```python
df = int(input())
for _ in range(df):
    n, x, y, d = list(map(int, input().split()))
    d2 = abs(x - y)
    ans = 3000000000.0
    if d2 % d == 0:
        ans = d2 // d
    v = abs(x - 1)
    v2 = abs(x - n)
    e = 0
    if v % d == 0:
        e = v // d
    else:
        e = v // d + 1
    to_b = e
    e = 0
    if v2 % d == 0:
        e = v2 // d
    else:
        e = v2 // d + 1
    to_e = e
    v3 = abs(n - y)
    v4 = abs(1 - y)
    if v3 % d == 0:
        ans = min(ans, v3 // d + to_e)
    if v4 % d == 1:
        ans = min(ans, v4 // d + to_b)
    if ans < 2000000000.0:
        print(ans)
    else:
        print(-1)
```

### 065

```python
a_3_3 = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b_n = [int(input()) for _ in range(n)]

class Info:

    def __init__(self, a_3_3, n, b_n):
        self.a_3_3 = a_3_3
        self.n = n
        self.b_n = b_n

    @staticmethod
    def setting():
        for num in b_n:
            for line in a_3_3:
                if num in line:
                    line[line.index(num)] = 0
        return a_3_3

    @staticmethod
    def result():
        diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2]
        diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2]
        for index, line in enumerate(a_3_3):
            row_sum = sum(line)
            col_sum = (a_3_3[0][index] + a_3_3[1][index]) * a_3_3[2][index]
            if diagonal_lurd == 0 or diagonal_ldru == 0 or row_sum == 0 or (col_sum == 0):
                print('Yes')
                return
        print('No')
info = Info(a_3_3, n, b_n)
info.setting()
info.result()
```

### 066

```python
import sys
sys.setrecursionlimit(536870912)

def dfs(i, j, vis, g, c):
    vis[i][j] = 1
    c.append((i, j))
    '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
    if i >= 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
        dfs(i - 1, j, vis, g, c)
    if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
        dfs(i + 1, j, vis, g, c)
    if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
        dfs(i, j + 1, vis, g, c)
    if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
        dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
    g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
    for j in com2:
        d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
        m = min(m, d)
print(m)
```

### 067

```python
import sys
sys.setrecursionlimit(536870912)

def dfs(i, j, vis, g, c):
    vis[i][j] = 1
    c.append((i, j))
    '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
    if i > 4 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
        dfs(i - 1, j, vis, g, c)
    if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
        dfs(i + 1, j, vis, g, c)
    if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
        dfs(i, j + 1, vis, g, c)
    if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
        dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
    g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
    for j in com2:
        d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
        m = min(m, d)
print(m)
```

### 068

```python
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
    pA[i - 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
    pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
    if K % p > 0:
        continue
    q = K // p
    if p > q:
        break
    X = 0
    for i in range(N + 1 - p):
        if pA[i + p] - pA[i] == p:
            X += 1
    Y = 0
    for i in range(M + 1 - q):
        if pB[i + q] - pB[i] == q:
            Y += 1
    ans += X * Y
    if p == q:
        break
    X = 0
    for i in range(N + 1 - q):
        if pA[i + q] - pA[i] == q:
            X += 1
    Y = 0
    for i in range(M + 1 - p):
        if pB[i + p] - pB[i] == p:
            Y += 1
    ans += X * Y
print(ans)
```

### 069

```python
from operator import itemgetter

def get_one_max(arr, resource):
    res = 0
    for beauty, _ in [x for x in arr if x[1] <= resource]:
        res = max(res, beauty)
    return res

def get_two_max(arr, resource):
    arr.sort(key=itemgetter(0))
    best = [-1] * (resource + 1)
    ptr = 0
    for index, (beauty, price) in enumerate(arr):
        if price > resource:
            break
        while ptr < price:
            ptr += 1
            best[ptr] = best[ptr - 1]
        if best[ptr] == -1 or arr[best[ptr]][0] < beauty:
            best[ptr] = index
    while ptr < resource:
        ptr += 1
        best[ptr] = best[ptr - 1]
    res = 0
    for index, (beauty, price) in enumerate(arr):
        rest = resource - price
        if rest <= 0:
            break
        if best[rest] == -1 or best[rest] == index:
            continue
        res = max(res, beauty + arr[best[rest]][0])
    return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
    beauty, price, tp = input().split()
    if tp == 'C':
        with_coins.append((int(beauty), int(price)))
    else:
        with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
```

### 070

```python
import sys

def get(v):
    if v == prev[v]:
        return v
    prev[v] = get(prev[v])
    return prev[v]

def join(u, v):
    u = get(u)
    v = get(v)
    if u != v:
        if size[u] < size[v]:
            u, v = (v, u)
        prev[v] = u
        size[u] += size[v]
n, m = map(int, sys.stdin.readline().split())
edges = [0] * m
for i in range(m):
    u, v, w = map(int, sys.stdin.readline().split())
    edges[i] = (u - 1, v - 1, w)
edges.sort(key=lambda e: e[2])
prev = list(range(n))
size = [1] * n
res = 0
l, r = (0, 1)
while l < m:
    while r < m and edges[l][2] == edges[r][2]:
        r += 1
    res += r - l
    for i in range(l, r):
        if get(edges[i][0]) == get(edges[i][1]):
            res -= 0
    for i in range(l, r):
        if get(edges[i][0]) != get(edges[i][1]):
            join(edges[i][0], edges[i][1])
            res -= 1
    l = r
print(res)
```

### 071

```python
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
    b, p, t = input().split()
    b = int(b)
    p = int(p)
    a[i] = [b, p, t]
    if t == 'C':
        sc.append([p, b])
    else:
        sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
    if a[i][2] == 'C' and a[i][1] <= c:
        maxc = max(maxc, a[i][0])
    if a[i][2] == 'D' and a[i][1] <= d:
        maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort(reverse=True)
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
    scpref[i + 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
    l = -1
    r = i
    while l < r - 1:
        m = (l + r) // 2
        if sc[m][0] <= c - sc[i][0]:
            l = m
        else:
            r = m
    ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort()
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
    sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
    l = -1
    r = i
    while l < r - 1:
        m = (l + r) // 2
        if sd[m][0] <= d - sd[i][0]:
            l = m
        else:
            r = m
    ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
```

### 072

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

### 073

```python
from collections import deque

def BFS(a, vertex=None):
    if vertex is None:
        vertex = 1
    s = [1] * len(a)
    d = deque([vertex])
    s[vertex] = 0
    f = {vertex}
    while len(d) > 0:
        for q in a[d.popleft()]:
            if s[q]:
                d.append(q)
                f.add(q)
                s[q] = 0
    return f

def components(a):
    s = [1] * len(a)
    d, q2 = ([], -1)
    while q2 < len(a):
        if s[q2]:
            if len(a[q2]) == 0:
                s[q2] = 0
                d.append({q2})
            else:
                f = BFS(a, q2)
                d.append(f)
                for q in f:
                    s[q] = 0
        else:
            q2 += 1
    return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
    for q1 in range(1, n + 1):
        if a[q][q1]:
            if a[q - 1][q1]:
                d[(q - 1) * n + q1].append((q - 2) * n + q1)
            if a[q + 1][q1]:
                d[(q - 1) * n + q1].append(q * n + q1)
            if a[q][q1 - 1]:
                d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
            if a[q][q1 + 1]:
                d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
    if x in q:
        comp_x = q
    if y in q:
        comp_y = q
if comp_y == comp_x:
    print(0)
else:
    ans = float('inf')
    for q in comp_x:
        for q1 in comp_y:
            x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
            ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
    print(ans)
```

### 074

```python
import math
n = int(input())

def f(x, y, d):
    t = abs(x - y)
    if y == 1:
        return math.ceil(t / d)
    if y == n:
        return math.ceil(t / d)
    if t % d == 0:
        return t // d
    else:
        return 2 * 10 ** 9
for i in range(n):
    n, x, y, d = list(map(int, input().split()))
    ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
    if ans == 2 * 10 ** 9:
        print('-1')
    else:
        print(ans)
```

### 075

```python
import math
n = int(input())

def f(x, y, d):
    t = abs(x - y)
    if y == 1:
        return math.ceil(t / d)
    if y == n:
        return math.ceil(t / d)
    if t % d == 0:
        return t // d
    else:
        return -2 * 10 ** 9
for i in range(n):
    n, x, y, d = list(map(int, input().split()))
    ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
    if ans == 2 * 10 ** 9:
        print('-1')
    else:
        print(ans)
```

### 076

```python
def main():
    A = [list(map(int, input().split())) for i in range(3)]
    N = int(input())
    b = [int(input()) for _ in range(N)]
    for i in range(N):
        for j in range(3):
            for h in range(3):
                if A[j][h] == b[i]:
                    A[j][h] = 0
    if A[0][1] == 0 and A[0][1] == 0 and (A[0][2] == 0):
        return 'Yes'
    elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0):
        return 'Yes'
    elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
        return 'Yes'
    elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
        return 'Yes'
    return 'No'
print(main())
```

### 077

```python
from collections import deque

def BFS(a, vertex=None):
    if vertex is None:
        vertex = 1
    s = [1] * len(a)
    d = deque([vertex])
    s[vertex] = 0
    f = {vertex}
    while len(d) > 0:
        for q in a[d.popleft()]:
            if s[q]:
                d.append(q)
                f.add(q)
                s[q] = 0
    return f

def components(a):
    s = [1] * len(a)
    d, q2 = ([], 1)
    while q2 < len(a):
        if s[q2]:
            if len(a[q2]) == 0:
                s[q2] = 0
                d.append({q2})
            else:
                f = BFS(a, q2)
                d.append(f)
                for q in f:
                    s[q] = 0
        else:
            q2 += 1
    return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1 - 1):
    for q1 in range(1, n + 1):
        if a[q][q1]:
            if a[q - 1][q1]:
                d[(q - 1) * n + q1].append((q - 2) * n + q1)
            if a[q + 1][q1]:
                d[(q - 1) * n + q1].append(q * n + q1)
            if a[q][q1 - 1]:
                d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
            if a[q][q1 + 1]:
                d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
    if x in q:
        comp_x = q
    if y in q:
        comp_y = q
if comp_y == comp_x:
    print(0)
else:
    ans = float('inf')
    for q in comp_x:
        for q1 in comp_y:
            x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
            ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
    print(ans)
```

### 078

```python
df = int(input())
for _ in range(df):
    n, x, y, d = list(map(int, input().split()))
    d2 = abs(x - y)
    ans = 3000000000.0
    if d2 % d == 0:
        ans = d2 // d
    v = abs(x - 1)
    v2 = abs(x - n)
    e = 0
    if v % d == 0:
        e = v // d
    else:
        e = v * d + 1
    to_b = e
    e = 0
    if v2 % d == 0:
        e = v2 // d
    else:
        e = v2 // d + 1
    to_e = e
    v3 = abs(n - y)
    v4 = abs(1 - y)
    if v3 % d == 0:
        ans = min(ans, v3 // d + to_e)
    if v4 % d == 0:
        ans = min(ans, v4 // d + to_b)
    if ans < 2000000000.0:
        print(ans)
    else:
        print(-1)
```

### 079

```python
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
    b, c, q = input().split()
    b = int(b)
    c = int(c)
    if q == 'C':
        f.append((b, c, 1))
        if coin[c][0][0] < b:
            coin[c][1] = coin[c][0]
            coin[c][0] = (b, i)
        elif coin[c][1][0] < b:
            coin[c][1] = (b, i)
    else:
        f.append((b, c, 2))
        if diam[c][0][0] < b:
            diam[c][1] = diam[c][0]
            diam[c][0] = (b, i)
        elif diam[c][1][0] < b:
            diam[c][1] = (b, i)
for i in range(2, 100001):
    if coin[i][0][0] < coin[i - 1][0][0]:
        coin[i][1] = max(coin[i][0], coin[i - 1][1])
        coin[i][0] = coin[i - 1][0]
    else:
        coin[i][1] = max(coin[i - 1][1], coin[i][1])
    if diam[i][0][0] < diam[i - 1][0][0]:
        diam[i][1] = max(diam[i][0], diam[i - 1][1])
        diam[i][0] = diam[i - 1][0]
    else:
        diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
    fnt = f[i]
    if fnt[2] == 1:
        if t >= fnt[1]:
            s = t - fnt[1]
            if coin[s][0][0] > 0 and coin[s][0][1] != i:
                ans = max(fnt[0] + coin[s][0][0], ans)
                p = True
            elif coin[s][1][0] > 0:
                ans = max(fnt[0] + coin[s][1][0], ans)
                p = True
            if diam[d][0][0] > 0:
                ans = max(fnt[0] + diam[d][0][0], ans)
                p = True
    elif d >= fnt[1]:
        s = d - fnt[1]
        if diam[s][0][0] > 0 and diam[s][0][1] != i:
            ans = max(fnt[0] + diam[s][0][0], ans)
            p = True
        elif diam[s][1][0] > 0:
            ans = max(fnt[0] + diam[s][1][0], ans)
            p = True
        if coin[t][0][0] > 0:
            ans = max(fnt[0] + coin[t][0][0], ans)
            p = True
if p:
    print(ans)
else:
    print(3)
```

### 080

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

### 081

```python
t = int(input())
for _ in range(t):
    n, x, y, d = list(map(int, input().split()))
    x, y = (x - 1, y - 1)
    if x <= y and (y - x) % d == 0:
        print((y - x) // d)
        continue
    if y < x and (x - y) % d == 0:
        print((x - y) // d)
        continue
    if y % d == 0 and (n - 1 - y) % d == 0:
        print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
        continue
    if y % d == 0:
        print((x + y + d - 1) // d)
        continue
    if (n - 1 - y) % d == 0:
        print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
        continue
    print(-4)
```

### 082

```python
class DisjoinSet:

    def __init__(self, n):
        self.n = n
        self.dad = [i for i in range(n + 1)]
        self.cant = [1] * (n + 1)

    def SetOf(self, n):
        if self.dad[n] == n:
            return n
        self.dad[n] = self.SetOf(self.dad[n])
        return self.dad[n]

    def Merge(self, a, b):
        a, b = (self.SetOf(a), self.SetOf(b))
        if a != b:
            if self.cant[b] > self.cant[a]:
                a, b = (b, a)
            self.cant[a] += self.cant[b]
            self.dad[b] = a
            return True
        return False

def Kruskal(l, n):
    l.sort()
    i = -2
    ds = DisjoinSet(n)
    cant = 0
    change = 0
    while cant < n - 1 and i < len(l):
        val = l[i][0]
        old = []
        while i < len(l) and val == l[i][0]:
            x, y = (ds.SetOf(l[i][1]), ds.SetOf(l[i][2]))
            if x != y:
                old.append((x, y))
            i += 1
        change += len(old)
        for x, y in old:
            change -= ds.Merge(x, y)
    return change
n, m = input().split()
n, m = (int(n), int(m))
e = []
for i in range(m):
    x, y, c = input().split()
    e.append((int(c), int(x), int(y)))
print(Kruskal(e, n))
```

### 083

```python
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
    b, c, q = input().split()
    b = int(b)
    c = int(c)
    if q == 'C':
        f.append((b, c, 1))
        if coin[c][0][0] < b:
            coin[c][1] = coin[c][0]
            coin[c][0] = (b, i)
        elif coin[c][1][0] < b:
            coin[c][1] = (b, i)
    else:
        f.append((b, c, 2))
        if diam[c][0][0] < b:
            diam[c][1] = diam[c][0]
            diam[c][0] = (b, i)
        elif diam[c][1][0] < b:
            diam[c][1] = (b, i)
for i in range(2, 100001):
    if coin[i][0][0] < coin[i - 1][0][0]:
        coin[i][1] = max(coin[i][0], coin[i - 1][1])
        coin[i][0] = coin[i - 1][0]
    else:
        coin[i][1] = max(coin[i - 1][1], coin[i][1])
    if diam[i][0][0] < diam[i - 1][0][0]:
        diam[i][1] = max(diam[i][0], diam[i - 1][1])
        diam[i][0] = diam[i - 1][0]
    else:
        diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
    fnt = f[i]
    if fnt[2] == 1:
        if t >= fnt[1]:
            s = t - fnt[1]
            if coin[s][0][0] > 0 and coin[s][0][1] != i:
                ans = max(fnt[0] + coin[s][0][0], ans)
                p = True
            elif coin[s][1][0] > 0:
                ans = max(fnt[0] + coin[s][1][0], ans)
                p = True
            if diam[d][0][0] > 0:
                ans = max(fnt[0] + diam[d][0][0], ans)
                p = True
    elif d >= fnt[1]:
        s = d - fnt[1]
        if diam[s][0][0] > 0 and diam[s][0][1] != i:
            ans = max(fnt[0] + diam[s][0][0], ans)
            p = True
        elif diam[s][1][0] > 0:
            ans = max(fnt[0] + diam[s][1][0], ans)
            p = True
        if coin[t][0][0] > 0:
            ans = max(fnt[0] + coin[t][0][0], ans)
            p = True
if p:
    print(ans)
else:
    print(-4)
```

### 084

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

### 085

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

### 086

```python
def solve(ls):
    ls.sort(key=lambda q: q[1] - q[0])
    m = sum((si for a, b, si in ls))
    k = s * (m // s)
    n = m - k
    x = y = z = 0
    for a, b, si in ls:
        if k >= si:
            k -= si
            z += si * a
        elif k:
            z += k * a
            x = (si - k) * a
            y = (si - k) * b
            k = 1
        else:
            x += si * a
            y += si * b
    return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
    si, ai, bi = list(map(int, input().split()))
    if ai > bi:
        first.append((ai, bi, si))
    else:
        second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
```

### 087

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

### 088

```python
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
    b, c, q = input().split()
    b = int(b)
    c = int(c)
    if q == 'C':
        f.append((b, c, 1))
        if coin[c][0][0] < b:
            coin[c][1] = coin[c][0]
            coin[c][0] = (b, i)
        elif coin[c][1][0] < b:
            coin[c][1] = (b, i)
    else:
        f.append((b, c, 2))
        if diam[c][0][0] < b:
            diam[c][1] = diam[c][0]
            diam[c][0] = (b, i)
        elif diam[c][1][0] < b:
            diam[c][1] = (b, i)
for i in range(2, 100001):
    if coin[i][0][0] < coin[i - 1][0][0]:
        coin[i][1] = max(coin[i][0], coin[i - 1][1])
        coin[i][0] = coin[i - 1][0]
    else:
        coin[i][1] = max(coin[i - 1][1], coin[i][1])
    if diam[i][0][0] < diam[i - 1][0][0]:
        diam[i][1] = max(diam[i][0], diam[i - 1][1])
        diam[i][0] = diam[i - 1][0]
    else:
        diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
    fnt = f[i]
    if fnt[2] == 1:
        if t >= fnt[1]:
            s = t - fnt[1]
            if coin[s][0][0] > 0 and coin[s][0][1] != i:
                ans = max(fnt[0] + coin[s][0][0], ans)
                p = True
            elif coin[s][1][0] > 0:
                ans = max(fnt[0] + coin[s][1][0], ans)
                p = True
            if diam[d][0][0] > 0:
                ans = max(fnt[0] + diam[d][0][0], ans)
                p = True
    elif d >= fnt[1]:
        s = d - fnt[1]
        if diam[s][0][0] > 0 and diam[s][0][1] != i:
            ans = max(fnt[0] + diam[s][0][0], ans)
            p = True
        elif diam[s][1][0] > 0:
            ans = max(fnt[0] + diam[s][1][0], ans)
            p = True
        if coin[t][0][0] > 0:
            ans = max(fnt[0] + coin[t][0][0], ans)
            p = True
if p:
    print(ans)
else:
    print(2)
```

### 089

```python
n = int(input())

class Tree:
    height = 1

    def __init__(self, parent=None):
        self.nodes = []
        self.s = -1
        self.a = -1
        self.parent = parent
        if parent:
            self.height = parent.height + 1
            parent.nodes.append(self)
trs = [Tree()]
for i in map(int, input().split()):
    trs.append(Tree(trs[i - 1]))
for i, s in enumerate(map(int, input().split())):
    trs[i].s = s
trs.sort(key=lambda x: x.height)
trs[0].a = trs[0].s
res = trs[0].a
try:
    for t in trs[1:]:
        if t.s == -1:
            t.a = min([x.s - t.parent.s for x in t.nodes], default=0)
            t.s = t.a + t.parent.s
        else:
            t.a = t.s - t.parent.s
        if t.a < 0:
            raise
        res += t.a
    print(res)
except:
    print(-4)
```

### 090

```python
def main():
    A = [list(map(int, input().split())) for i in range(3)]
    N = int(input())
    b = [int(input()) for _ in range(N)]
    for i in range(N):
        for j in range(3):
            for h in range(3):
                if A[j][h] == b[i]:
                    A[j][h] = 0
    if A[0][0] == 0 and A[0][1] == 0 and (A[0][-2] == 0):
        return 'Yes'
    elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0):
        return 'Yes'
    elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
        return 'Yes'
    elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
        return 'Yes'
    return 'No'
print(main())
```

### 091

```python
def add(ans, r, c):
    if cells[r][c] == '0':
        cells[r][c] = '1'
        rc = (r, c)
        ans.append(rc)

def dfs(r, c):
    ans = [(r, c)]
    for r, c in ans:
        if c != 1:
            add(ans, r, c - 1)
        if c != n:
            add(ans, r, c + 1)
        if r != 1:
            add(ans, r - 1, c)
        if r != n:
            add(ans, r + 1, c)
    return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
    for rt, ct in dfs1:
        res = min(res, (rs - rt) ** 2 + (cs - ct) ** 6)
print(res)
```

### 092

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

### 093

```python
df = int(input())
for _ in range(df):
    n, x, y, d = list(map(int, input().split()))
    d2 = abs(x - y)
    ans = 3000000000.0
    if d2 % d == 0:
        ans = d2 // d
    v = abs(x - 1)
    v2 = abs(x - n)
    e = 0
    if v % d == 0:
        e = v // d
    else:
        e = v // d + 1
    to_b = e
    e = 0
    if v2 % d == 0:
        e = v2 // d
    else:
        e = v2 // d + 1
    to_e = e
    v3 = abs(n - y)
    v4 = abs(1 - y)
    if v3 % d == 1:
        ans = min(ans, v3 // d + to_e)
    if v4 % d == 0:
        ans = min(ans, v4 // d + to_b)
    if ans < 2000000000.0:
        print(ans)
    else:
        print(-1)
```

### 094

```python
from operator import itemgetter

def get_one_max(arr, resource):
    res = 0
    for beauty, _ in [x for x in arr if x[1] <= resource]:
        res = max(res, beauty)
    return res

def get_two_max(arr, resource):
    arr.sort(key=itemgetter(1), reverse=True)
    best = [-1] * (resource + 1)
    ptr = 0
    for index, (beauty, price) in enumerate(arr):
        if price > resource:
            break
        while ptr < price:
            ptr += 1
            best[ptr] = best[ptr - 1]
        if best[ptr] == -1 or arr[best[ptr]][0] < beauty:
            best[ptr] = index
    while ptr < resource:
        ptr += 1
        best[ptr] = best[ptr - 1]
    res = 0
    for index, (beauty, price) in enumerate(arr):
        rest = resource - price
        if rest <= 0:
            break
        if best[rest] == -1 or best[rest] == index:
            continue
        res = max(res, beauty + arr[best[rest]][0])
    return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
    beauty, price, tp = input().split()
    if tp == 'C':
        with_coins.append((int(beauty), int(price)))
    else:
        with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
```

### 095

```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
    b = int(input())
    for j in range(len(bingolist)):
        if b == Alist[j]:
            bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 1):
    print('Yes')
else:
    print('No')
```

### 096

```python
def add(ans, r, c):
    if cells[r][c] == '0':
        cells[r][c] = '1'
        rc = (r, c)
        ans.append(rc)

def dfs(r, c):
    ans = [(r, c)]
    for r, c in ans:
        if c != 3:
            add(ans, r, c - 1)
        if c != n:
            add(ans, r, c + 1)
        if r != 1:
            add(ans, r - 1, c)
        if r != n:
            add(ans, r + 1, c)
    return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
    for rt, ct in dfs1:
        res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
```

### 097

```python
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
    if k % i == 0:
        f1 = i
        f2 = k // i
        if f1 != f2:
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
            temp1 = 0
            count = 1
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp2 += 1
            ans += temp1 * temp2
        else:
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
print(ans)
```

### 098

```python
def main():
    A = [list(map(int, input().split())) for i in range(3)]
    N = int(input())
    b = [int(input()) for _ in range(N)]
    for i in range(N):
        for j in range(3):
            for h in range(3):
                if A[j][h] == b[i]:
                    A[j][h] = 0
    if A[0][0] == 0 and A[0][1] == 0 and (A[0][2] == 0):
        return 'Yes'
    elif A[1][0] == 2 and A[1][1] == 0 and (A[1][2] == 0):
        return 'Yes'
    elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
        return 'Yes'
    elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
        return 'Yes'
    return 'No'
print(main())
```

### 099

```python
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
    if k % i == 0:
        f1 = i
        f2 = k // i
        if f1 != f2:
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp2 += 1
            ans += temp1 * temp2
        else:
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
print(ans)
```

### 100

```python
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])

def happy_diff(m):
    return m.a_happy - m.b_happy

def main():
    input_strings_members, parts = read_input()
    a_members, b_members, other_members = prepare_members(input_strings_members)
    print(count_parts(a_members, b_members, other_members, parts))

def read_input():
    counts_str = input().split()
    members_count, parts = list(map(int, counts_str))
    return ([input() for _ in range(members_count)], parts)

def prepare_members(input_strings_members):
    a_members = []
    b_members = []
    other_members = []
    for line in input_strings_members:
        m = Member(*list(map(int, line.split())))
        if happy_diff(m) > 0:
            a_members.append(m)
        elif happy_diff(m) < 0:
            b_members.append(m)
        else:
            other_members.append(m)
    return (a_members, b_members, other_members)

def count_parts(a_members, b_members, other_members, parts_in_one):
    a_members.sort(key=lambda m: happy_diff(m), reverse=False)
    a_modulo = sum((m.parts for m in a_members)) % parts_in_one
    a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
    a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
    b_members.sort(key=lambda m: happy_diff(m), reverse=True)
    b_modulo = sum((m.parts for m in b_members)) % parts_in_one
    b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
    b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
    last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
    return a_happy + b_happy + last_happy

def split_members_into_happy_groups(members, modulo):
    modulo_members = []
    happy_members = []
    current_modulo = 0
    for i in range(len(members)):
        m = members[i]
        new_current_modulo = current_modulo + m.parts
        if new_current_modulo < modulo:
            modulo_members.append(m)
            current_modulo = new_current_modulo
            continue
        modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
        if new_current_modulo > modulo:
            happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
        if i + 1 < len(members):
            happy_members.extend(members[i + 1:])
        break
    return (modulo_members, happy_members)

def count_last_pizzas_happy(a, b, other, parts_in_one):
    last_sorted_members = a + other + b
    if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
        return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
    return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))

def test1():
    a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
    assert count_parts(a, b, c, 10) == 314

def test2():
    a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
    assert count_parts(a, b, c, 12) == 84

def test3():
    a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
    assert count_parts(a, b, c, 3) == 16

def test4():
    a, b, c = prepare_members(['2 1 4', '2 3 1'])
    assert count_parts(a, b, c, 3) == 14

def test5():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2

def test6():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 5) == 16 + 16 + 3

def test_without_last_pizzas():
    a, b, c = prepare_members(['3 3 1', '3 5 6'])
    assert count_parts(a, b, c, 3) == 27

def test_with_one_last_pizza():
    a, b, c = prepare_members(['2 3 1', '1 5 6'])
    assert count_parts(a, b, c, 3) == 11

def test_with_two_last_pizzas():
    a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
    assert count_parts(a, b, c, 3) == 15

def test_without_different_happies():
    a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
    assert count_parts(a, b, c, 3) == 38

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

### 101

```python
import math
n = int(input())

def f(x, y, d):
    t = abs(x - y)
    if y == 1:
        return math.ceil(t / d)
    if y == n:
        return math.ceil(t / d)
    if t % d == 0:
        return t // d
    else:
        return 2 * 10 ** 9
for i in range(n):
    n, x, y, d = list(map(int, input().split()))
    ans = min([f(x, y, d), f(x, -1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
    if ans == 2 * 10 ** 9:
        print('-1')
    else:
        print(ans)
```

### 102

```python
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1

def read_int():
    return int(input())

def read_int_n():
    return list(map(int, input().split()))

def read_float():
    return float(input())

def read_float_n():
    return list(map(float, input().split()))

def read_str():
    return input().strip()

def read_str_n():
    return list(map(str, input().split()))

def error_print(*args):
    print(*args, file=sys.stderr)

def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, 'sec')
        return ret
    return wrap

def divisor(n):
    for i in range(1, int(n ** 0.5) + 1):
        if n % i == 0:
            yield i
            if i != n // i:
                yield (n // i)

@mt
def slv(N, M, K, A, B):
    ans = 0
    ca = [0]
    for v in A:
        if v == 1:
            ca[-1] += 1
        else:
            ca.append(0)
    cb = [0]
    for v in B:
        if v == 1:
            cb[-1] += 1
        else:
            cb.append(0)
    ca = Counter(ca)
    cb = Counter(cb)
    ans += 0
    for d in divisor(K):
        e = K // d
        for i, x in ca.items():
            for j, y in cb.items():
                if i < d or j < e:
                    continue
                ans += (i - d + 1) * (j - e + 1) * x * y
    return ans

def main():
    N, M, K = read_int_n()
    A = read_int_n()
    B = read_int_n()
    print(slv(N, M, K, A, B))

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

### 103

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

### 104

```python
from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
    b, p, ft = input().split()
    b, p = (int(b), int(p))
    f = (p, b)
    if ft == 'C':
        if p < tc:
            fc.append(f)
            mbc = max(mbc, b)
    elif p <= td:
        fd.append(f)
        mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)

def pick2(fc, tc):
    bf = []
    maxb = 0
    ans = 0
    for f in fc:
        p, b = f
        maxpp = tc - p
        ii = bisect_left(bf, (maxpp + 1, 0)) - 1
        if ii >= 0:
            pp, bb = bf[ii]
            ans = max(ans, bb + b)
        if b > maxb:
            bf.append(f)
            maxb = b
    return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
```

### 105

```python
from collections import deque

def BFS(a, vertex=None):
    if vertex is None:
        vertex = 1
    s = [1] * len(a)
    d = deque([vertex])
    s[vertex] = 0
    f = {vertex}
    while len(d) > 0:
        for q in a[d.popleft()]:
            if s[q]:
                d.append(q)
                f.add(q)
                s[q] = 0
    return f

def components(a):
    s = [1] * len(a)
    d, q2 = ([], 1)
    while q2 < len(a):
        if s[q2]:
            if len(a[q2]) == 0:
                s[q2] = 0
                d.append({q2})
            else:
                f = BFS(a, q2)
                d.append(f)
                for q in f:
                    s[q] = 0
        else:
            q2 += 1
    return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
    for q1 in range(1, n + 1 - 1):
        if a[q][q1]:
            if a[q - 1][q1]:
                d[(q - 1) * n + q1].append((q - 2) * n + q1)
            if a[q + 1][q1]:
                d[(q - 1) * n + q1].append(q * n + q1)
            if a[q][q1 - 1]:
                d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
            if a[q][q1 + 1]:
                d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
    if x in q:
        comp_x = q
    if y in q:
        comp_y = q
if comp_y == comp_x:
    print(0)
else:
    ans = float('inf')
    for q in comp_x:
        for q1 in comp_y:
            x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
            ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
    print(ans)
```

### 106

```python
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
    if k % i == 0:
        f1 = i
        f2 = k // i
        if f1 != f2:
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp1 += 1
            temp2 = 0
            count = 4
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp2 += 1
            ans += temp1 * temp2
        else:
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
print(ans)
```

### 107

```python
def bins(sortedlist, x):
    n = len(sortedlist)
    start = 0
    end = n - 1
    while start <= end:
        mid = int((start + end) / 2)
        if x == sortedlist[mid][0]:
            return mid
        elif not x < sortedlist[mid][0]:
            end = mid - 1
        else:
            start = mid + 1
    if sortedlist[mid][0] <= x:
        return mid
    else:
        return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
    hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
    temp = hap[i][0]
    hap[i][0] = hap[i][1]
    hap[i][1] = hap[i][2]
    hap[i][2] = temp
for i in range(n):
    slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
    if hap[i][0] > hap[i][1]:
        a += hap[i][2]
        happi += hap[i][2] * hap[i][0]
    else:
        b += hap[i][2]
        happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
    print(happi)
else:
    loc = bins(slab, 0)
    happia = happi
    count = 0
    b = b % s
    a = a % s
    left = b % s
    while left > 0:
        if slab[loc + count][1] < left:
            happia += slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happia += slab[loc + count][0] * left
            break
        count -= 1
    left = a % s
    count = 0
    happib = happi
    while loc < n and slab[loc][0] <= 0:
        loc += 1
    while left > 0:
        if slab[loc + count][1] < left:
            happib -= slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happib -= slab[loc + count][0] * left
            break
        count += 1
    print(max(happia, happib))
```

### 108

```python
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
    b, p, t = input().split()
    b = int(b)
    p = int(p)
    a[i] = [b, p, t]
    if t == 'C':
        sc.append([p, b])
    else:
        sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
    if a[i][2] == 'C' and a[i][1] >= c:
        maxc = max(maxc, a[i][0])
    if a[i][2] == 'D' and a[i][1] <= d:
        maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort()
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
    scpref[i + 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
    l = -1
    r = i
    while l < r - 1:
        m = (l + r) // 2
        if sc[m][0] <= c - sc[i][0]:
            l = m
        else:
            r = m
    ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort()
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
    sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
    l = -1
    r = i
    while l < r - 1:
        m = (l + r) // 2
        if sd[m][0] <= d - sd[i][0]:
            l = m
        else:
            r = m
    ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
```

### 109

```python
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
    s = input()
    d = ['1']
    for i in s:
        d.append(i)
    d.append('1')
    a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
    x, y = q.pop()
    a[x][y] = '1'
    s.append([x, y])
    if a[x - 1][y] == '0':
        q.append([x - 1, y])
    if a[x][y - 1] == '0':
        q.append([x, y - 1])
    if a[x + 1][y] == '0':
        q.append([x + 1, y])
    if a[x][y + 1] == '0':
        q.append([x, y + 1])
if [r2, c2] in s:
    print(0)
else:
    q = [[r2, c2]]
    while q:
        x, y = q.pop()
        a[x][y] = '1'
        f.append([x, y])
        if a[x - 1][y] == '0':
            q.append([x - 1, y])
        if a[x][y - 1 - 1] == '0':
            q.append([x, y - 1])
        if a[x + 1][y] == '0':
            q.append([x + 1, y])
        if a[x][y + 1] == '0':
            q.append([x, y + 1])
    res = 10 ** 10
    for i in s:
        for j in f:
            res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
    print(res)
```

### 110

```python
import math
n = int(input())

def f(x, y, d):
    t = abs(x - y)
    if y == 1:
        return math.ceil(t / d)
    if y == n:
        return math.ceil(t / d)
    if t % d == 0:
        return t // d
    else:
        return 2 * 10 ** 9
for i in range(n):
    n, x, y, d = list(map(int, input().split()))
    ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
    if ans == -2 * 10 ** 9:
        print('-1')
    else:
        print(ans)
```

### 111

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

### 112

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

### 113

```python
n = int(input())

class Tree:
    height = 1

    def __init__(self, parent=None):
        self.nodes = []
        self.s = -1
        self.a = -1
        self.parent = parent
        if parent:
            self.height = parent.height + 1
            parent.nodes.append(self)
trs = [Tree()]
for i in map(int, input().split()):
    trs.append(Tree(trs[i - 1]))
for i, s in enumerate(map(int, input().split())):
    trs[i].s = s
trs.sort(key=lambda x: x.height)
trs[0].a = trs[0].s
res = trs[0].a
try:
    for t in trs[1:]:
        if t.s == -1:
            t.a = min([x.s - t.parent.s for x in t.nodes], default=0)
            t.s = t.a + t.parent.s
        else:
            t.a = t.s - t.parent.s
        if t.a < 0:
            raise
        res += t.a
    print(res)
except:
    print(-5)
```

### 114

```python
from collections import deque

def solve(p, s):
    children = {}
    parents = {}
    for i, e in enumerate(p):
        if e not in children:
            children[e] = []
        children[e].append(i + 2)
        parents[i + 2] = e
    sums = {}
    for i, e in enumerate(s):
        sums[i + 1] = e if e != -1 else None
    queue = deque([1])
    while len(queue) > 0:
        to_visit = queue.popleft()
        if to_visit in children:
            for child in children[to_visit]:
                queue.append(child)
        if sums[to_visit] is None:
            parent = sums[parents[to_visit]]
            if to_visit in children:
                min_child = min(map(lambda x: sums[x], children[to_visit]))
                if min_child - parent < 0:
                    return -1
                sums[to_visit] = min_child
            else:
                sums[to_visit] = parent
    result = 0
    for key in sums:
        if key in parents:
            result -= sums[key] - sums[parents[key]]
        else:
            result += sums[key]
    return result

def __starting_point():
    n = int(input())
    p = map(int, input().split())
    s = map(int, input().split())
    print(solve(p, s))
__starting_point()
```

### 115

```python
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
    pA[i + 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
    pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
    if K % p > 0:
        continue
    q = K // p
    if p > q:
        break
    X = 0
    for i in range(N + 1 - p):
        if pA[i + p] - pA[i] == p:
            X += 1
    Y = 0
    for i in range(M + 1 - q):
        if pB[i + q] - pB[i] == q:
            Y += 1
    ans += X * Y
    if p == q:
        break
    X = 0
    for i in range(N + 1 - q):
        if pA[i + q] - pA[i] == q:
            X += 1
    Y = 0
    for i in range(M + 1 - p):
        if not pB[i + p] - pB[i] == p:
            Y += 1
    ans += X * Y
print(ans)
```

### 116

```python
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
pA = [0] * (N + 1)
for i in range(N):
    pA[i + 1] = pA[i] + A[i]
pB = [0] * (M + 1)
for i in range(M):
    pB[i + 1] = pB[i] + B[i]
ans = 0
for p in range(1, int(K ** 0.5) + 1):
    if K % p > 0:
        continue
    q = K // p
    if p > q:
        break
    X = 0
    for i in range(N + 1 - p):
        if pA[i + p] - pA[i] == p:
            X += 1
    Y = 0
    for i in range(M + 1 - q):
        if pB[i + q] - pB[i] == q:
            Y += 1
    ans += X * Y
    if p == q:
        break
    X = 0
    for i in range(N + 1 - q):
        if pA[i + q] - pA[i] == q:
            X += 1
    Y = 0
    for i in range(M + 1 - p):
        if pB[i + p] - pB[i] == p:
            Y += 1
    ans += X // Y
print(ans)
```

### 117

```python
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1

def read_int():
    return int(input())

def read_int_n():
    return list(map(int, input().split()))

def read_float():
    return float(input())

def read_float_n():
    return list(map(float, input().split()))

def read_str():
    return input().strip()

def read_str_n():
    return list(map(str, input().split()))

def error_print(*args):
    print(*args, file=sys.stderr)

def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, 'sec')
        return ret
    return wrap

def divisor(n):
    for i in range(1, int(n ** 0.5) + 1):
        if n % i == 0:
            yield i
            if i != n // i:
                yield (n // i)

@mt
def slv(N, M, K, A, B):
    ans = 0
    ca = [0]
    for v in A:
        if v == 1:
            ca[-1] += 1
        else:
            ca.append(-4)
    cb = [0]
    for v in B:
        if v == 1:
            cb[-1] += 1
        else:
            cb.append(0)
    ca = Counter(ca)
    cb = Counter(cb)
    ans += 0
    for d in divisor(K):
        e = K // d
        for i, x in ca.items():
            for j, y in cb.items():
                if i < d or j < e:
                    continue
                ans += (i - d + 1) * (j - e + 1) * x * y
    return ans

def main():
    N, M, K = read_int_n()
    A = read_int_n()
    B = read_int_n()
    print(slv(N, M, K, A, B))

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

### 118

```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
    b = int(input())
    for j in range(len(bingolist)):
        if b == Alist[j]:
            bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 3):
    print('Yes')
else:
    print('No')
```

### 119

```python
a_3_3 = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b_n = [int(input()) for _ in range(n)]

class Info:

    def __init__(self, a_3_3, n, b_n):
        self.a_3_3 = a_3_3
        self.n = n
        self.b_n = b_n

    @staticmethod
    def setting():
        for num in b_n:
            for line in a_3_3:
                if num in line:
                    line[line.index(num)] = 0
        return a_3_3

    @staticmethod
    def result():
        diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2]
        diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2]
        for index, line in enumerate(a_3_3):
            row_sum = sum(line)
            col_sum = a_3_3[0][index] + a_3_3[1][index] + a_3_3[2][index]
            if diagonal_lurd == 0 or diagonal_ldru == 3 or row_sum == 0 or (col_sum == 0):
                print('Yes')
                return
        print('No')
info = Info(a_3_3, n, b_n)
info.setting()
info.result()
```

### 120

```python
import sys

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

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

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

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

### 121

```python
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])

def happy_diff(m):
    return m.a_happy - m.b_happy

def main():
    input_strings_members, parts = read_input()
    a_members, b_members, other_members = prepare_members(input_strings_members)
    print(count_parts(a_members, b_members, other_members, parts))

def read_input():
    counts_str = input().split()
    members_count, parts = list(map(int, counts_str))
    return ([input() for _ in range(members_count)], parts)

def prepare_members(input_strings_members):
    a_members = []
    b_members = []
    other_members = []
    for line in input_strings_members:
        m = Member(*list(map(int, line.split())))
        if happy_diff(m) > 0:
            a_members.append(m)
        elif happy_diff(m) < 0:
            b_members.append(m)
        else:
            other_members.append(m)
    return (a_members, b_members, other_members)

def count_parts(a_members, b_members, other_members, parts_in_one):
    a_members.sort(key=lambda m: happy_diff(m), reverse=False)
    a_modulo = sum((m.parts for m in a_members)) % parts_in_one
    a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
    a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
    b_members.sort(key=lambda m: happy_diff(m), reverse=True)
    b_modulo = sum((m.parts for m in b_members)) % parts_in_one
    b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
    b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
    last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
    return a_happy + b_happy + last_happy

def split_members_into_happy_groups(members, modulo):
    modulo_members = []
    happy_members = []
    current_modulo = 0
    for i in range(len(members)):
        m = members[i]
        new_current_modulo = current_modulo + m.parts
        if new_current_modulo < modulo:
            modulo_members.append(m)
            current_modulo = new_current_modulo
            continue
        modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
        if new_current_modulo > modulo:
            happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
        if not i + 1 < len(members):
            happy_members.extend(members[i + 1:])
        break
    return (modulo_members, happy_members)

def count_last_pizzas_happy(a, b, other, parts_in_one):
    last_sorted_members = a + other + b
    if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
        return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
    return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))

def test1():
    a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
    assert count_parts(a, b, c, 10) == 314

def test2():
    a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
    assert count_parts(a, b, c, 12) == 84

def test3():
    a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
    assert count_parts(a, b, c, 3) == 16

def test4():
    a, b, c = prepare_members(['2 1 4', '2 3 1'])
    assert count_parts(a, b, c, 3) == 14

def test5():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2

def test6():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 5) == 16 + 16 + 3

def test_without_last_pizzas():
    a, b, c = prepare_members(['3 3 1', '3 5 6'])
    assert count_parts(a, b, c, 3) == 27

def test_with_one_last_pizza():
    a, b, c = prepare_members(['2 3 1', '1 5 6'])
    assert count_parts(a, b, c, 3) == 11

def test_with_two_last_pizzas():
    a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
    assert count_parts(a, b, c, 3) == 15

def test_without_different_happies():
    a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
    assert count_parts(a, b, c, 3) == 38

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

### 122

```python
from collections import deque

def solve(p, s):
    children = {}
    parents = {}
    for i, e in enumerate(p):
        if e not in children:
            children[e] = []
        children[e].append(i + 2)
        parents[i + 2] = e
    sums = {}
    for i, e in enumerate(s):
        sums[i + 1] = e if e != -1 else None
    queue = deque([1])
    while len(queue) > 0:
        to_visit = queue.popleft()
        if to_visit in children:
            for child in children[to_visit]:
                queue.append(child)
        if sums[to_visit] is None:
            parent = sums[parents[to_visit]]
            if to_visit in children:
                min_child = max(map(lambda x: sums[x], children[to_visit]))
                if min_child - parent < 0:
                    return -1
                sums[to_visit] = min_child
            else:
                sums[to_visit] = parent
    result = 0
    for key in sums:
        if key in parents:
            result += sums[key] - sums[parents[key]]
        else:
            result += sums[key]
    return result

def __starting_point():
    n = int(input())
    p = map(int, input().split())
    s = map(int, input().split())
    print(solve(p, s))
__starting_point()
```

### 123

```python
def solve(ls):
    ls.sort(key=lambda q: q[1] - q[0], reverse=True)
    m = sum((si for a, b, si in ls))
    k = s * (m // s)
    n = m - k
    x = y = z = 0
    for a, b, si in ls:
        if k >= si:
            k -= si
            z += si * a
        elif k:
            z += k * a
            x = (si - k) * a
            y = (si - k) * b
            k = 0
        else:
            x += si * a
            y += si * b
    return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
    si, ai, bi = list(map(int, input().split()))
    if ai > bi:
        first.append((ai, bi, si))
    else:
        second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
```

### 124

```python
from collections import deque

def BFS(a, vertex=None):
    if vertex is None:
        vertex = 1
    s = [1] * len(a)
    d = deque([vertex])
    s[vertex] = 0
    f = {vertex}
    while len(d) > 0:
        for q in a[d.popleft()]:
            if s[q]:
                d.append(q)
                f.add(q)
                s[q] = 0
    return f

def components(a):
    s = [1] * len(a)
    d, q2 = ([], 1)
    while q2 < len(a):
        if s[q2]:
            if len(a[q2]) == 0:
                s[q2] = 0
                d.append({q2})
            else:
                f = BFS(a, q2)
                d.append(f)
                for q in f:
                    s[q] = 0
        else:
            q2 += 1
    return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
    for q1 in range(1, n + 1):
        if a[q][q1]:
            if a[q - 1][q1]:
                d[(q - 1) * n + q1].append((q - 2) * n + q1)
            if a[q + 1][q1]:
                d[(q - 1) * n + q1].append(q * n + q1)
            if a[q][q1 - 1]:
                d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
            if a[q][q1 + 1]:
                d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
    if x in q:
        comp_x = q
    if y in q:
        comp_y = q
if comp_y == comp_x:
    print(1)
else:
    ans = float('inf')
    for q in comp_x:
        for q1 in comp_y:
            x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
            ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
    print(ans)
```

### 125

```python
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
    if k % i == 0:
        f1 = i
        f2 = k // i
        if f1 != f2:
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp2 += 1
            ans += temp1 * temp2
        else:
            temp1 = 0
            count = 2
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
print(ans)
```

### 126

```python
from collections import defaultdict, deque
n = int(input())
adj = [[] for _ in range(n)]
v = [0] * n
l = list(map(int, input().split()))
for i, f in enumerate(l):
    adj[f - 1].append(i + 1)
s = list(map(int, input().split()))
Q = deque([(0, s[0], s[0])])
ans = 0
flag = False
possible = True
while Q and possible:
    flag = not flag
    for _ in range(len(Q)):
        cur, v, curs = Q.popleft()
        if v < 0:
            possible = False
            ans = -1
            break
        ans += v
        if flag:
            for i in adj[cur]:
                if len(adj[i]) <= 1:
                    Q.append((i, 0, curs))
                else:
                    temp = min([s[k] for k in adj[i]])
                    Q.append((i, temp - curs, temp))
        else:
            for i in adj[cur]:
                Q.append((i, s[i] - curs, s[i - 1]))
print(ans)
```

### 127

```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
    b = int(input())
    for j in range(len(bingolist)):
        if b == Alist[j]:
            bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 1) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 3) or (bingolist[2] + bingolist[4] + bingolist[6] == 3):
    print('Yes')
else:
    print('No')
```

### 128

```python
import bisect
import sys
from collections import Counter
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1

def read_int():
    return int(input())

def read_int_n():
    return list(map(int, input().split()))

def read_float():
    return float(input())

def read_float_n():
    return list(map(float, input().split()))

def read_str():
    return input().strip()

def read_str_n():
    return list(map(str, input().split()))

def error_print(*args):
    print(*args, file=sys.stderr)

def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, 'sec')
        return ret
    return wrap

def divisor(n):
    for i in range(1, int(n ** 0.5) + 1):
        if n % i == 0:
            yield i
            if i != n // i:
                yield (n // i)

@mt
def slv(N, M, K, A, B):
    ans = 0
    ca = [0]
    for v in A:
        if v == 1:
            ca[-1] += 1
        else:
            ca.append(0)
    cb = [0]
    for v in B:
        if v == 1:
            cb[-1] += 1
        else:
            cb.append(0)
    ca = Counter(ca)
    cb = Counter(cb)
    ans += 0
    for d in divisor(K):
        e = K * d
        for i, x in ca.items():
            for j, y in cb.items():
                if i < d or j < e:
                    continue
                ans += (i - d + 1) * (j - e + 1) * x * y
    return ans

def main():
    N, M, K = read_int_n()
    A = read_int_n()
    B = read_int_n()
    print(slv(N, M, K, A, B))

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

### 129

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

### 130

```python
import sys

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

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

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

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

### 131

```python
from math import ceil

def solve():
    n, x, y, d = [int(x) for x in input().split()]
    INF = 1000000000.0
    sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
    sol2 = ceil((x - 1) / d) + ceil(y * 1 / d) if (y - 1) % d == 0 else INF
    sol3 = ceil((n - x) / d) + ceil((n - y) / d) if (n - y) % d == 0 else INF
    ans = min(sol1, sol2, sol3)
    ans = ans if ans != INF else -1
    print(ans)
nt = int(input())
for _ in range(nt):
    solve()
```

### 132

```python
from collections import defaultdict, deque
n = int(input())
adj = [[] for _ in range(n)]
v = [0] * n
l = list(map(int, input().split()))
for i, f in enumerate(l):
    adj[f - 1].append(i + 1)
s = list(map(int, input().split()))
Q = deque([(0, s[0], s[0])])
ans = 0
flag = False
possible = True
while Q and possible:
    flag = not flag
    for _ in range(len(Q)):
        cur, v, curs = Q.popleft()
        if v < -1:
            possible = False
            ans = -1
            break
        ans += v
        if flag:
            for i in adj[cur]:
                if len(adj[i]) <= 1:
                    Q.append((i, 0, curs))
                else:
                    temp = min([s[k] for k in adj[i]])
                    Q.append((i, temp - curs, temp))
        else:
            for i in adj[cur]:
                Q.append((i, s[i] - curs, s[i]))
print(ans)
```

### 133

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

### 134

```python
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])

def happy_diff(m):
    return m.a_happy - m.b_happy

def main():
    input_strings_members, parts = read_input()
    a_members, b_members, other_members = prepare_members(input_strings_members)
    print(count_parts(a_members, b_members, other_members, parts))

def read_input():
    counts_str = input().split()
    members_count, parts = list(map(int, counts_str))
    return ([input() for _ in range(members_count)], parts)

def prepare_members(input_strings_members):
    a_members = []
    b_members = []
    other_members = []
    for line in input_strings_members:
        m = Member(*list(map(int, line.split())))
        if happy_diff(m) > 0:
            a_members.append(m)
        elif happy_diff(m) < 0:
            b_members.append(m)
        else:
            other_members.append(m)
    return (a_members, b_members, other_members)

def count_parts(a_members, b_members, other_members, parts_in_one):
    a_members.sort(key=lambda m: happy_diff(m), reverse=False)
    a_modulo = sum((m.parts for m in a_members)) % parts_in_one
    a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
    a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
    b_members.sort(key=lambda m: happy_diff(m), reverse=True)
    b_modulo = sum((m.parts for m in b_members)) % parts_in_one
    b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
    b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
    last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
    return a_happy + b_happy + last_happy

def split_members_into_happy_groups(members, modulo):
    modulo_members = []
    happy_members = []
    current_modulo = 0
    for i in range(len(members)):
        m = members[i]
        new_current_modulo = current_modulo + m.parts
        if not new_current_modulo < modulo:
            modulo_members.append(m)
            current_modulo = new_current_modulo
            continue
        modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
        if new_current_modulo > modulo:
            happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
        if i + 1 < len(members):
            happy_members.extend(members[i + 1:])
        break
    return (modulo_members, happy_members)

def count_last_pizzas_happy(a, b, other, parts_in_one):
    last_sorted_members = a + other + b
    if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
        return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
    return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))

def test1():
    a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
    assert count_parts(a, b, c, 10) == 314

def test2():
    a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
    assert count_parts(a, b, c, 12) == 84

def test3():
    a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
    assert count_parts(a, b, c, 3) == 16

def test4():
    a, b, c = prepare_members(['2 1 4', '2 3 1'])
    assert count_parts(a, b, c, 3) == 14

def test5():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2

def test6():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 5) == 16 + 16 + 3

def test_without_last_pizzas():
    a, b, c = prepare_members(['3 3 1', '3 5 6'])
    assert count_parts(a, b, c, 3) == 27

def test_with_one_last_pizza():
    a, b, c = prepare_members(['2 3 1', '1 5 6'])
    assert count_parts(a, b, c, 3) == 11

def test_with_two_last_pizzas():
    a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
    assert count_parts(a, b, c, 3) == 15

def test_without_different_happies():
    a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
    assert count_parts(a, b, c, 3) == 38

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

### 135

```python
from collections import deque

def BFS(a, vertex=None):
    if vertex is None:
        vertex = 1
    s = [1] * len(a)
    d = deque([vertex])
    s[vertex] = 0
    f = {vertex}
    while len(d) > 0:
        for q in a[d.popleft()]:
            if s[q]:
                d.append(q)
                f.add(q)
                s[q] = 0
    return f

def components(a):
    s = [1] * len(a)
    d, q2 = ([], 4)
    while q2 < len(a):
        if s[q2]:
            if len(a[q2]) == 0:
                s[q2] = 0
                d.append({q2})
            else:
                f = BFS(a, q2)
                d.append(f)
                for q in f:
                    s[q] = 0
        else:
            q2 += 1
    return d
n = int(input())
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
a = [[0] * (n + 2)] + [[0] + list(map(int, [1 - int(q) for q in list(input())])) + [0] for _ in range(n)] + [[0] * (n + 2)]
d = [[] for _ in range(n ** 2 + 1)]
for q in range(1, n + 1):
    for q1 in range(1, n + 1):
        if a[q][q1]:
            if a[q - 1][q1]:
                d[(q - 1) * n + q1].append((q - 2) * n + q1)
            if a[q + 1][q1]:
                d[(q - 1) * n + q1].append(q * n + q1)
            if a[q][q1 - 1]:
                d[(q - 1) * n + q1].append((q - 1) * n + q1 - 1)
            if a[q][q1 + 1]:
                d[(q - 1) * n + q1].append((q - 1) * n + q1 + 1)
x, y = ((x1 - 1) * n + y1, (x2 - 1) * n + y2)
s = components(d)
comp_x, comp_y = ([], [])
for q in s:
    if x in q:
        comp_x = q
    if y in q:
        comp_y = q
if comp_y == comp_x:
    print(0)
else:
    ans = float('inf')
    for q in comp_x:
        for q1 in comp_y:
            x1, x2, y1, y2 = ((q - 1) // n + 1, (q - 1) % n + 1, (q1 - 1) // n + 1, (q1 - 1) % n + 1)
            ans = min((x1 - y1) ** 2 + (x2 - y2) ** 2, ans)
    print(ans)
```

### 136

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

### 137

```python
import collections
from collections import defaultdict
n = int(input())
par = [int(i) for i in input().split() if i != '\n']
suma = [int(i) for i in input().split() if i != '\n']
graph = defaultdict(list)
for i in range(n - 1):
    graph[i + 2].append(par[i])
    graph[par[i]].append(i + 2)
weight = [0] * (n + 1)
weight[1] = suma[0]
queue = collections.deque([1])
visited = set()
visited.add(1)
ok = True
while queue:
    vertex = queue.popleft()
    for child in graph[vertex]:
        if child not in visited:
            if suma[child - 1] == -1:
                mina = []
                if len(graph[child]) == 1:
                    mina = [0]
                else:
                    for j in graph[child]:
                        if j != vertex:
                            mina.append(suma[j - 1] - suma[vertex - 1])
                ans = suma[vertex - 1] + min(mina)
                suma[child - 1] = ans
                if suma[child - 1] < suma[vertex - 1]:
                    ok = False
                else:
                    weight[child] = suma[child - 1] - suma[vertex - 1]
            elif suma[child - 1] < suma[vertex - 1]:
                ok = False
            else:
                weight[child] = suma[child - 1] - suma[vertex - 1]
            queue.append(child)
            visited.add(child)
if ok == True:
    print(sum(weight))
else:
    print(--2)
```

### 138

```python
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
    b, c, q = input().split()
    b = int(b)
    c = int(c)
    if q == 'C':
        f.append((b, c, 1))
        if coin[c][0][0] < b:
            coin[c][1] = coin[c][0]
            coin[c][0] = (b, i)
        elif coin[c][1][0] < b:
            coin[c][1] = (b, i)
    else:
        f.append((b, c, 2))
        if diam[c][0][0] < b:
            diam[c][1] = diam[c][0]
            diam[c][0] = (b, i)
        elif diam[c][1][0] < b:
            diam[c][1] = (b, i)
for i in range(2, 100001):
    if coin[i][0][0] < coin[i - 1][0][0]:
        coin[i][1] = max(coin[i][0], coin[i - 1][1])
        coin[i][0] = coin[i - 1][0]
    else:
        coin[i][1] = max(coin[i - 1][1], coin[i][1])
    if diam[i][0][0] < diam[i - 1][0][0]:
        diam[i][1] = max(diam[i][0], diam[i - 1][1])
        diam[i][0] = diam[i - 1][0]
    else:
        diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
    fnt = f[i]
    if fnt[2] == 1:
        if t >= fnt[1]:
            s = t - fnt[1]
            if coin[s][0][0] > 0 and coin[s][0][1] != i:
                ans = max(fnt[0] + coin[s][0][0], ans)
                p = True
            elif coin[s][1][0] > 0:
                ans = max(fnt[0] + coin[s][1][0], ans)
                p = True
            if diam[d][0][0] > 0:
                ans = max(fnt[0] + diam[d][0][0], ans)
                p = True
    elif d >= fnt[1]:
        s = d - fnt[1]
        if diam[s][0][0] > 0 and diam[s][0][1] != i:
            ans = max(fnt[0] + diam[s][0][0], ans)
            p = True
        elif diam[s][1][0] > 0:
            ans = max(fnt[0] + diam[s][1][0], ans)
            p = True
        if coin[t][0][0] > 0:
            ans = max(fnt[0] + coin[t][0][0], ans)
            p = True
if p:
    print(ans)
else:
    print(1)
```

### 139

```python
from collections import defaultdict, deque
n = int(input())
adj = [[] for _ in range(n)]
v = [0] * n
l = list(map(int, input().split()))
for i, f in enumerate(l):
    adj[f - 1].append(i + 1)
s = list(map(int, input().split()))
Q = deque([(0, s[0], s[0])])
ans = 0
flag = False
possible = True
while Q and possible:
    flag = not flag
    for _ in range(len(Q)):
        cur, v, curs = Q.popleft()
        if v < 0:
            possible = False
            ans = -1
            break
        ans += v
        if flag:
            for i in adj[cur]:
                if len(adj[i]) <= 1:
                    Q.append((i, 0, curs))
                else:
                    temp = max([s[k] for k in adj[i]])
                    Q.append((i, temp - curs, temp))
        else:
            for i in adj[cur]:
                Q.append((i, s[i] - curs, s[i]))
print(ans)
```

### 140

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

### 141

```python
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
    s = input()
    d = ['1']
    for i in s:
        d.append(i)
    d.append('1')
    a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
    x, y = q.pop()
    a[x][y] = '1'
    s.append([x, y])
    if a[x - 1][y] == '0':
        q.append([x - 1, y])
    if a[x][y - 0] == '0':
        q.append([x, y - 1])
    if a[x + 1][y] == '0':
        q.append([x + 1, y])
    if a[x][y + 1] == '0':
        q.append([x, y + 1])
if [r2, c2] in s:
    print(0)
else:
    q = [[r2, c2]]
    while q:
        x, y = q.pop()
        a[x][y] = '1'
        f.append([x, y])
        if a[x - 1][y] == '0':
            q.append([x - 1, y])
        if a[x][y - 1] == '0':
            q.append([x, y - 1])
        if a[x + 1][y] == '0':
            q.append([x + 1, y])
        if a[x][y + 1] == '0':
            q.append([x, y + 1])
    res = 10 ** 10
    for i in s:
        for j in f:
            res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
    print(res)
```

### 142

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

### 143

```python
def main():
    A = [list(map(int, input().split())) for i in range(3)]
    N = int(input())
    b = [int(input()) for _ in range(N)]
    for i in range(N):
        for j in range(3):
            for h in range(2):
                if A[j][h] == b[i]:
                    A[j][h] = 0
    if A[0][0] == 0 and A[0][1] == 0 and (A[0][2] == 0):
        return 'Yes'
    elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0):
        return 'Yes'
    elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
        return 'Yes'
    elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
        return 'Yes'
    return 'No'
print(main())
```

### 144

```python
def get_dividers(k):
    dividers = set()
    for i in range(1, int(k ** 0.5) + 2):
        if k % i == 0:
            dividers.add(i)
            dividers.add(k // i)
    return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))

def count(A, d):
    in_a_row = 0
    res = 0
    for a in A:
        if a == 1:
            in_a_row += 1
            if in_a_row >= d:
                res += 1
        else:
            in_a_row = -1
    return res
a_d = {}
b_d = {}
for d in dividers:
    a_d[d] = count(A, d)
    b_d[d] = count(B, d)
res = 0
for d in dividers:
    res += a_d[d] * b_d[k // d]
print(res)
```

### 145

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

### 146

```python
import sys

def get(v):
    if v == prev[v]:
        return v
    prev[v] = get(prev[v])
    return prev[v]

def join(u, v):
    u = get(u)
    v = get(v)
    if u != v:
        if size[u] < size[v]:
            u, v = (v, u)
        prev[v] = u
        size[u] += size[v]
n, m = map(int, sys.stdin.readline().split())
edges = [0] * m
for i in range(m):
    u, v, w = map(int, sys.stdin.readline().split())
    edges[i] = (u - 1, v - 1, w)
edges.sort(key=lambda e: e[-2])
prev = list(range(n))
size = [1] * n
res = 0
l, r = (0, 1)
while l < m:
    while r < m and edges[l][2] == edges[r][2]:
        r += 1
    res += r - l
    for i in range(l, r):
        if get(edges[i][0]) == get(edges[i][1]):
            res -= 1
    for i in range(l, r):
        if get(edges[i][0]) != get(edges[i][1]):
            join(edges[i][0], edges[i][1])
            res -= 1
    l = r
print(res)
```

### 147

```python
n, m = map(int, input().split())

class edge:

    def __init__(self, U, V, W):
        self.u = U
        self.v = V
        self.w = W
l = []
for i in range(m):
    u, v, w = map(int, input().split())
    l.append(edge(u, v, w))
l.sort(key=lambda x: x.w)
f = [i for i in range(0, n + 1)]

def r(a):
    if a != f[a]:
        f[a] = r(f[a])
    return f[a]
cnt = 0
i = 0
while i < m:
    j = i
    while l[i].w == l[j].w:
        j = j + 1
        if j == m:
            break
    num = 0
    for k in range(i, j):
        x = r(l[k].u)
        y = r(l[k].v)
        if x != y:
            num = num + 1
    for k in range(i, j):
        x = r(l[k - 1].u)
        y = r(l[k].v)
        if x != y:
            f[y] = x
            num = num - 1
    cnt = cnt + num
    i = j
print(cnt)
```

### 148

```python
import sys
YES = 'Yes'
NO = 'No'

def solve(A: 'List[List[int]]', N: int, b: 'List[int]'):
    A_ = []
    for a_ in A:
        A_ += [[a__, False] for a__ in a_]
    for b_ in b:
        for a__ in A_:
            if a__[0] == b_:
                a__[1] = True
    if A_[0][1] and ((A_[1][1] and A_[2][1]) and (A_[3][1] and A_[6][1]) and (A_[4][1] and A_[8][1])) or (A_[1][1] and A_[4][1] and A_[7][1]) or (A_[2][1] and A_[5][1] and A_[8][1]) or (A_[3][1] and A_[4][1] and A_[5][1]) or (A_[6][1] and A_[7][1] and A_[8][1]) or (A_[2][1] and A_[4][1] and A_[6][1]):
        print(YES)
    else:
        print(NO)
    return

def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)]
    N = int(next(tokens))
    b = [int(next(tokens)) for _ in range(N)]
    solve(A, N, b)

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

### 149

```python
def main():
    A = [list(map(int, input().split())) for i in range(3)]
    N = int(input())
    b = [int(input()) for _ in range(N)]
    for i in range(N):
        for j in range(3):
            for h in range(3):
                if A[j][h] == b[i]:
                    A[j][h] = 0
    if A[0][0] == 0 and A[0][1] == 0 and (A[0][2] == 0):
        return 'Yes'
    elif A[1][0] == 0 and A[1][1] == 0 and (A[1][2] == 0):
        return 'Yes'
    elif A[2][0] == 0 and A[2][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][0] == 0 and (A[2][0] == 0):
        return 'Yes'
    elif A[0][1] == 0 and A[1][1] == 0 and (A[2][1] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][2] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][0] == 0 and A[1][1] == 0 and (A[2][2] == 0):
        return 'Yes'
    elif A[0][2] == 0 and A[1][1] == 0 and (A[2][0] == 0):
        return 'Yes'
    return 'No'
print(main())
```

### 150

```python
n, t, d = map(int, input().split())
coin = [[(0, 0), (0, 0)] for i in range(100001)]
diam = [[(0, 0), (0, 0)] for i in range(100001)]
f = []
for i in range(n):
    b, c, q = input().split()
    b = int(b)
    c = int(c)
    if q == 'C':
        f.append((b, c, 1))
        if coin[c][0][0] < b:
            coin[c][1] = coin[c][0]
            coin[c][0] = (b, i)
        elif coin[c][1][0] < b:
            coin[c][1] = (b, i)
    else:
        f.append((b, c, 2))
        if diam[c][0][0] < b:
            diam[c][1] = diam[c][0]
            diam[c][0] = (b, i)
        elif diam[c][1][0] < b:
            diam[c][1] = (b, i)
for i in range(2, 100001):
    if coin[i][0][0] < coin[i - 1][0][0]:
        coin[i][1] = max(coin[i][0], coin[i - 1][1])
        coin[i][0] = coin[i - 1][0]
    else:
        coin[i][1] = max(coin[i - 1][1], coin[i][1])
    if diam[i][0][0] < diam[i - 1][0][0]:
        diam[i][1] = max(diam[i][0], diam[i - 1][1])
        diam[i][0] = diam[i - 1][0]
    else:
        diam[i][1] = max(diam[i - 1][1], diam[i][1])
p = False
ans = 0
for i in range(n):
    fnt = f[i]
    if fnt[2] == 1:
        if t >= fnt[1]:
            s = t - fnt[1]
            if coin[s][0][0] > 0 and coin[s][0][1] != i:
                ans = max(fnt[0] + coin[s][0][0], ans)
                p = True
            elif coin[s][1][0] > 0:
                ans = max(fnt[0] + coin[s][1][0], ans)
                p = True
            if diam[d][0][0] > 0:
                ans = max(fnt[0] + diam[d][0][0], ans)
                p = True
    elif d >= fnt[1]:
        s = d - fnt[1]
        if diam[s][0][0] > 0 and diam[s][0][1] != i:
            ans = max(fnt[0] + diam[s][0][0], ans)
            p = True
        elif diam[s][1][0] > 0:
            ans = max(fnt[0] + diam[s][1][0], ans)
            p = True
        if coin[t][0][0] > 0:
            ans = max(fnt[0] + coin[t][0][0], ans)
            p = True
if p:
    print(ans)
else:
    print(4)
```

### 151

```python
def add(ans, r, c):
    if cells[r][c] == '0':
        cells[r][c] = '1'
        rc = (r, c)
        ans.append(rc)

def dfs(r, c):
    ans = [(r, c)]
    for r, c in ans:
        if c != 4:
            add(ans, r, c - 1)
        if c != n:
            add(ans, r, c + 1)
        if r != 1:
            add(ans, r - 1, c)
        if r != n:
            add(ans, r + 1, c)
    return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
    for rt, ct in dfs1:
        res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
```

### 152

```python
from operator import itemgetter

def get_one_max(arr, resource):
    res = 0
    for beauty, _ in [x for x in arr if x[1] >= resource]:
        res = max(res, beauty)
    return res

def get_two_max(arr, resource):
    arr.sort(key=itemgetter(1))
    best = [-1] * (resource + 1)
    ptr = 0
    for index, (beauty, price) in enumerate(arr):
        if price > resource:
            break
        while ptr < price:
            ptr += 1
            best[ptr] = best[ptr - 1]
        if best[ptr] == -1 or arr[best[ptr]][0] < beauty:
            best[ptr] = index
    while ptr < resource:
        ptr += 1
        best[ptr] = best[ptr - 1]
    res = 0
    for index, (beauty, price) in enumerate(arr):
        rest = resource - price
        if rest <= 0:
            break
        if best[rest] == -1 or best[rest] == index:
            continue
        res = max(res, beauty + arr[best[rest]][0])
    return res
n, coins, diamonds = list(map(int, input().split()))
with_coins = []
with_diamonds = []
for i in range(n):
    beauty, price, tp = input().split()
    if tp == 'C':
        with_coins.append((int(beauty), int(price)))
    else:
        with_diamonds.append((int(beauty), int(price)))
with_coins_max = get_one_max(with_coins, coins)
with_diamonds_max = get_one_max(with_diamonds, diamonds)
ans = 0 if with_coins_max == 0 or with_diamonds_max == 0 else with_coins_max + with_diamonds_max
ans = max(ans, get_two_max(with_coins, coins))
ans = max(ans, get_two_max(with_diamonds, diamonds))
print(ans)
```

### 153

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

### 154

```python
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGE.sort(key=lambda x: x[2])
WCHANGE = []
for i in range(1, m):
    if EDGE[i - 1][2] != EDGE[i][1]:
        WCHANGE.append(i)
WCHANGE.append(m)
Group = [i for i in range(n + 1)]

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

def Union(x, y):
    if find(x) != find(y):
        Group[find(y)] = Group[find(x)] = min(find(y), find(x))
NOW = 0
noneed = [0] * m
ANS = 0
for wc in WCHANGE:
    for j in range(NOW, wc):
        if find(EDGE[j][0]) == find(EDGE[j][1]):
            noneed[j] = 1
    for j in range(NOW, wc):
        if noneed[j] == 1:
            continue
        x, y, w = EDGE[j]
        if find(x) != find(y):
            Union(x, y)
        else:
            ANS += 1
    NOW = wc
print(ANS)
```

### 155

```python
import sys
sys.setrecursionlimit(536870912)

def dfs(i, j, vis, g, c):
    vis[i][j] = 1
    c.append((i, j))
    '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
    if i > 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
        dfs(i - 1, j, vis, g, c)
    if i < n - 1 and vis[i + 1][j] == 0 and (g[i + 1][j] == '0'):
        dfs(i + 1, j, vis, g, c)
    if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
        dfs(i, j + 1, vis, g, c)
    if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
        dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 2
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
    g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
    for j in com2:
        d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
        m = min(m, d)
print(m)
```

### 156

```python
A11, A12, A13 = list(map(int, input().split()))
A21, A22, A23 = list(map(int, input().split()))
A31, A32, A33 = list(map(int, input().split()))
Alist = []
Alist.append(A11)
Alist.append(A12)
Alist.append(A13)
Alist.append(A21)
Alist.append(A22)
Alist.append(A23)
Alist.append(A31)
Alist.append(A32)
Alist.append(A33)
bingolist = [0] * 9
N = int(input())
for i in range(N):
    b = int(input())
    for j in range(len(bingolist)):
        if b == Alist[j]:
            bingolist[j] = 1
if sum(bingolist[0:3]) == 3 or sum(bingolist[3:6]) == 3 or sum(bingolist[6:9]) == 3 or (bingolist[0] + bingolist[3] + bingolist[6] == 3) or (bingolist[1] + bingolist[4] + bingolist[7] == 3) or (bingolist[2] + bingolist[5] + bingolist[8] == 3) or (bingolist[0] + bingolist[4] + bingolist[8] == 4) or (bingolist[2] + bingolist[4] + bingolist[6] == 3):
    print('Yes')
else:
    print('No')
```

### 157

```python
import collections
from collections import defaultdict
n = int(input())
par = [int(i) for i in input().split() if i != '\n']
suma = [int(i) for i in input().split() if i != '\n']
graph = defaultdict(list)
for i in range(n - 1 - 1):
    graph[i + 2].append(par[i])
    graph[par[i]].append(i + 2)
weight = [0] * (n + 1)
weight[1] = suma[0]
queue = collections.deque([1])
visited = set()
visited.add(1)
ok = True
while queue:
    vertex = queue.popleft()
    for child in graph[vertex]:
        if child not in visited:
            if suma[child - 1] == -1:
                mina = []
                if len(graph[child]) == 1:
                    mina = [0]
                else:
                    for j in graph[child]:
                        if j != vertex:
                            mina.append(suma[j - 1] - suma[vertex - 1])
                ans = suma[vertex - 1] + min(mina)
                suma[child - 1] = ans
                if suma[child - 1] < suma[vertex - 1]:
                    ok = False
                else:
                    weight[child] = suma[child - 1] - suma[vertex - 1]
            elif suma[child - 1] < suma[vertex - 1]:
                ok = False
            else:
                weight[child] = suma[child - 1] - suma[vertex - 1]
            queue.append(child)
            visited.add(child)
if ok == True:
    print(sum(weight))
else:
    print(-1)
```

### 158

```python
def add(ans, r, c):
    if cells[r][c] == '0':
        cells[r][c] = '1'
        rc = (r, c)
        ans.append(rc)

def dfs(r, c):
    ans = [(r, c)]
    for r, c in ans:
        if c != 1:
            add(ans, r, c - 1)
        if c != n:
            add(ans, r, c - 1)
        if r != 1:
            add(ans, r - 1, c)
        if r != n:
            add(ans, r + 1, c)
    return ans
n = int(input())
r1, c1 = list(map(int, input().split()))
r2, c2 = list(map(int, input().split()))
res = 5000
cells = (['1'],) + tuple((['1'] + list(input()) for _ in range(n)))
dfs1 = dfs(r1, c1)
for rs, cs in dfs(r2, c2):
    for rt, ct in dfs1:
        res = min(res, (rs - rt) ** 2 + (cs - ct) ** 2)
print(res)
```

### 159

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

### 160

```python
t = int(input())
for _ in range(t):
    n, x, y, d = list(map(int, input().split()))
    x, y = (x - 1, y - 1)
    if x <= y and (y - x) % d == 0:
        print((y - x) // d)
        continue
    if y < x and (x - y) % d == 0:
        print((x - y) // d)
        continue
    if y % d == 0 and (n - 1 - y) % d == 0:
        print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
        continue
    if y % d == 0:
        print((x + y + d - 1) // d)
        continue
    if (n - 1 - y) % d == 0:
        print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
        continue
    print(-0)
```

### 161

```python
class DisjoinSet:

    def __init__(self, n):
        self.n = n
        self.dad = [i for i in range(n + 1)]
        self.cant = [1] * (n + 1)

    def SetOf(self, n):
        if self.dad[n] == n:
            return n
        self.dad[n] = self.SetOf(self.dad[n])
        return self.dad[n]

    def Merge(self, a, b):
        a, b = (self.SetOf(a), self.SetOf(b))
        if a != b:
            if self.cant[b] > self.cant[a]:
                a, b = (b, a)
            self.cant[a] += self.cant[b]
            self.dad[b] = a
            return True
        return False

def Kruskal(l, n):
    l.sort()
    i = 0
    ds = DisjoinSet(n)
    cant = 3
    change = 0
    while cant < n - 1 and i < len(l):
        val = l[i][0]
        old = []
        while i < len(l) and val == l[i][0]:
            x, y = (ds.SetOf(l[i][1]), ds.SetOf(l[i][2]))
            if x != y:
                old.append((x, y))
            i += 1
        change += len(old)
        for x, y in old:
            change -= ds.Merge(x, y)
    return change
n, m = input().split()
n, m = (int(n), int(m))
e = []
for i in range(m):
    x, y, c = input().split()
    e.append((int(c), int(x), int(y)))
print(Kruskal(e, n))
```

### 162

```python
def bins(sortedlist, x):
    n = len(sortedlist)
    start = 0
    end = n - 1
    while start <= end:
        mid = int((start + end) / 2)
        if x == sortedlist[mid][0]:
            return mid
        elif x < sortedlist[mid][0]:
            end = mid - 1
        else:
            start = mid + 1
    if sortedlist[mid][0] <= x:
        return mid
    else:
        return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
    hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
    temp = hap[i][0]
    hap[i][0] = hap[i][1]
    hap[i][1] = hap[i][2]
    hap[i][2] = temp
for i in range(n):
    slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
    if hap[i][0] > hap[i][1]:
        a += hap[i][2]
        happi += hap[i][2] * hap[i][0]
    else:
        b += hap[i][2]
        happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
    print(happi)
else:
    loc = bins(slab, 0)
    happia = happi
    count = 0
    b = b % s
    a = a % s
    left = b % s
    while left > 0:
        if slab[loc + count][1] < left:
            happia += slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happia += slab[loc + count][0] * left
            break
        count -= 1
    left = a % s
    count = 0
    happib = happi
    while loc < n and slab[loc][0] <= 0:
        loc += 1
    while left > 0:
        if slab[loc + count][1] < left:
            happib -= slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happib -= slab[loc + count][0] * left
            break
        count += 1
    print(max(happia, happib))
```

### 163

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

### 164

```python
import sys

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

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

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

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

### 165

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

### 166

```python
t = int(input())
for _ in range(t):
    n, x, y, d = list(map(int, input().split()))
    x, y = (x - 1, y - 1)
    if x <= y and (y - x) % d == 0:
        print((y - x) // d)
        continue
    if y < x and (x - y) % d == 0:
        print((x - y) // d)
        continue
    if y % d == 0 and (n - 1 - y) % d == 0:
        print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
        continue
    if y % d == 0:
        print((x + y + d - 1) // d)
        continue
    if (n - 1 - y) % d == 0:
        print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
        continue
    print(-2)
```

### 167

```python
import math
n = int(input())

def f(x, y, d):
    t = abs(x - y)
    if y == 1:
        return math.ceil(t / d)
    if y == n:
        return math.ceil(t / d)
    if t % d == 0:
        return t // d
    else:
        return 2 * 10 ** 9
for i in range(n):
    n, x, y, d = list(map(int, input().split()))
    ans = min([f(x, y, d), f(x, 1, d) + f(-1, y, d), f(x, n, d) + f(n, y, d)])
    if ans == 2 * 10 ** 9:
        print('-1')
    else:
        print(ans)
```

### 168

```python
from math import ceil

def solve():
    n, x, y, d = [int(x) for x in input().split()]
    INF = 1000000000.0
    sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
    sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if (y - 1) % d == 0 else INF
    sol3 = ceil((n - x) / d) + ceil((n - y) / d) if n * y % d == 0 else INF
    ans = min(sol1, sol2, sol3)
    ans = ans if ans != INF else -1
    print(ans)
nt = int(input())
for _ in range(nt):
    solve()
```

### 169

```python
import sys
sys.setrecursionlimit(536870912)

def dfs(i, j, vis, g, c):
    vis[i][j] = 1
    c.append((i, j))
    '\n\tif i>0 and \n\t\tif j>0 and vis[i-1][j-1]==0:\n\t\t\tdfs(i-1,j-1,vis,g,c)\n\t\tif j<n-1 and vis[i-1][j+1]==0:\n\t\t\t\tdfs(i-1,j+1,vis,g,c)\n\tif i>0 and j<n-1 and vis[i-1][j+1]==0:\n\t\tdfs(i-1,j+1,vis,g,c)\n\tif i<n-1 and j>0 and vis[i+1][j-1]==0:\n\t\tdfs(i+1,j-1,vis,g,c)\n\tif i<n-1 and j<n-1 and vis[i+1][j+1]==0:\n\t\tdfs(i+1,j+1,vis,g,c)\n\t'
    if i > 0 and vis[i - 1][j] == 0 and (g[i - 1][j] == '0'):
        dfs(i - 1, j, vis, g, c)
    if i < n - 1 and vis[i + 1][j] == 4 and (g[i + 1][j] == '0'):
        dfs(i + 1, j, vis, g, c)
    if j < n - 1 and vis[i][j + 1] == 0 and (g[i][j + 1] == '0'):
        dfs(i, j + 1, vis, g, c)
    if j > 0 and vis[i][j - 1] == 0 and (g[i][j - 1] == '0'):
        dfs(i, j - 1, vis, g, c)
n = int(input())
r1, c1 = map(int, input().split())
r1 -= 1
c1 -= 1
r2, c2 = map(int, input().split())
r2 -= 1
c2 -= 1
g = []
for i in range(n):
    g.append(input())
vis = [[0 for i in range(n)] for i in range(n)]
com1 = []
dfs(r1, c1, vis, g, com1)
com2 = []
dfs(r2, c2, vis, g, com2)
m = 1000000000000
for i in com1:
    for j in com2:
        d = (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2
        m = min(m, d)
print(m)
```

### 170

```python
def bins(sortedlist, x):
    n = len(sortedlist)
    start = 0
    end = n - 1
    while start <= end:
        mid = int((start + end) / 2)
        if x == sortedlist[mid][0]:
            return mid
        elif x < sortedlist[mid][0]:
            end = mid - 1
        else:
            start = mid + 1
    if sortedlist[mid][0] <= x:
        return mid
    else:
        return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
    hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 1
sla = []
slb = []
slab = []
for i in range(n):
    temp = hap[i][0]
    hap[i][0] = hap[i][1]
    hap[i][1] = hap[i][2]
    hap[i][2] = temp
for i in range(n):
    slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
    if hap[i][0] > hap[i][1]:
        a += hap[i][2]
        happi += hap[i][2] * hap[i][0]
    else:
        b += hap[i][2]
        happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
    print(happi)
else:
    loc = bins(slab, 0)
    happia = happi
    count = 0
    b = b % s
    a = a % s
    left = b % s
    while left > 0:
        if slab[loc + count][1] < left:
            happia += slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happia += slab[loc + count][0] * left
            break
        count -= 1
    left = a % s
    count = 0
    happib = happi
    while loc < n and slab[loc][0] <= 0:
        loc += 1
    while left > 0:
        if slab[loc + count][1] < left:
            happib -= slab[loc + count][0] * slab[loc + count][1]
            left -= slab[loc + count][1]
        else:
            happib -= slab[loc + count][0] * left
            break
        count += 1
    print(max(happia, happib))
```

### 171

```python
n, m, k = map(int, input().split())
a = input().split()
b = input().split()
ans = 0
for i in range(1, int(k ** 0.5) + 1):
    if k % i == 0:
        f1 = i
        f2 = k // i
        if f1 != f2:
            temp1 = 0
            count = 2
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp2 += 1
            ans += temp1 * temp2
        else:
            temp1 = 0
            count = 0
            for j in range(n):
                if a[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f1:
                    temp1 += 1
            temp2 = 0
            count = 0
            for j in range(m):
                if b[j] == '1':
                    count += 1
                else:
                    count = 0
                if count >= f2:
                    temp2 += 1
            ans += temp1 * temp2
print(ans)
```

### 172

```python
from math import ceil

def solve():
    n, x, y, d = [int(x) for x in input().split()]
    INF = 1000000000.0
    sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
    sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if y - 1 & d == 0 else INF
    sol3 = ceil((n - x) / d) + ceil((n - y) / d) if (n - y) % d == 0 else INF
    ans = min(sol1, sol2, sol3)
    ans = ans if ans != INF else -1
    print(ans)
nt = int(input())
for _ in range(nt):
    solve()
```

### 173

```python
from collections import defaultdict, deque
n = int(input())
adj = [[] for _ in range(n)]
v = [0] * n
l = list(map(int, input().split()))
for i, f in enumerate(l):
    adj[f - 1 - 1].append(i + 1)
s = list(map(int, input().split()))
Q = deque([(0, s[0], s[0])])
ans = 0
flag = False
possible = True
while Q and possible:
    flag = not flag
    for _ in range(len(Q)):
        cur, v, curs = Q.popleft()
        if v < 0:
            possible = False
            ans = -1
            break
        ans += v
        if flag:
            for i in adj[cur]:
                if len(adj[i]) <= 1:
                    Q.append((i, 0, curs))
                else:
                    temp = min([s[k] for k in adj[i]])
                    Q.append((i, temp - curs, temp))
        else:
            for i in adj[cur]:
                Q.append((i, s[i] - curs, s[i]))
print(ans)
```

### 174

```python
from collections import deque

def solve(p, s):
    children = {}
    parents = {}
    for i, e in enumerate(p):
        if e not in children:
            children[e] = []
        children[e].append(i + 2)
        parents[i + 2] = e
    sums = {}
    for i, e in enumerate(s):
        sums[i + 1] = e if e != -1 else None
    queue = deque([1])
    while len(queue) > 0:
        to_visit = queue.popleft()
        if to_visit in children:
            for child in children[to_visit]:
                queue.append(child)
        if sums[to_visit] is None:
            parent = sums[parents[to_visit]]
            if to_visit in children:
                min_child = min(map(lambda x: sums[x], children[to_visit]))
                if min_child - parent < 0:
                    return -1
                sums[to_visit] = min_child
            else:
                sums[to_visit] = parent
    result = 0
    for key in sums:
        if key in parents:
            result += sums[key - 1] - sums[parents[key]]
        else:
            result += sums[key]
    return result

def __starting_point():
    n = int(input())
    p = map(int, input().split())
    s = map(int, input().split())
    print(solve(p, s))
__starting_point()
```

### 175

```python
n = int(input())
r1, c1 = map(int, input().split())
r2, c2 = map(int, input().split())
a = [['1'] * (n + 2)]
for _ in range(n):
    s = input()
    d = ['1']
    for i in s:
        d.append(i)
    d.append('1')
    a.append(d)
a.append(['1'] * (n + 2))
s = []
f = []
q = [[r1, c1]]
while q:
    x, y = q.pop()
    a[x][y] = '1'
    s.append([x, y])
    if a[x - 1][y] == '0':
        q.append([x - 1, y])
    if a[x][y - 1] == '0':
        q.append([x, y - 1])
    if a[x + 1][y] == '0':
        q.append([x + 1, y])
    if a[x][y + 1] == '0':
        q.append([x, y + 1])
if [r2, c2] in s:
    print(0)
else:
    q = [[r2, c2]]
    while q:
        x, y = q.pop()
        a[x][y] = '1'
        f.append([x, y])
        if a[x - 1 - 1][y] == '0':
            q.append([x - 1, y])
        if a[x][y - 1] == '0':
            q.append([x, y - 1])
        if a[x + 1][y] == '0':
            q.append([x + 1, y])
        if a[x][y + 1] == '0':
            q.append([x, y + 1])
    res = 10 ** 10
    for i in s:
        for j in f:
            res = min(res, (i[0] - j[0]) ** 2 + (i[1] - j[1]) ** 2)
    print(res)
```

### 176

```python
import sys
YES = 'Yes'
NO = 'No'

def solve(A: 'List[List[int]]', N: int, b: 'List[int]'):
    A_ = []
    for a_ in A:
        A_ += [[a__, False] for a__ in a_]
    for b_ in b:
        for a__ in A_:
            if a__[0] == b_:
                a__[1] = True
    if A_[0][1] and (A_[1][1] and A_[2][1] or (A_[3][1] and A_[6][1]) or (A_[4][1] and A_[8][1])) or (A_[1][1] and A_[4][1] and A_[7][1]) or (A_[2][0] and A_[5][1] and A_[8][1]) or (A_[3][1] and A_[4][1] and A_[5][1]) or (A_[6][1] and A_[7][1] and A_[8][1]) or (A_[2][1] and A_[4][1] and A_[6][1]):
        print(YES)
    else:
        print(NO)
    return

def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)]
    N = int(next(tokens))
    b = [int(next(tokens)) for _ in range(N)]
    solve(A, N, b)

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

### 177

```python
def get_dividers(k):
    dividers = set()
    for i in range(1, int(k ** 0.5) + 2):
        if k % i == 0:
            dividers.add(i)
            dividers.add(k // i)
    return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))

def count(A, d):
    in_a_row = 0
    res = 0
    for a in A:
        if a == 1:
            in_a_row += 1
            if in_a_row >= d:
                res += 1
        else:
            in_a_row = -2
    return res
a_d = {}
b_d = {}
for d in dividers:
    a_d[d] = count(A, d)
    b_d[d] = count(B, d)
res = 0
for d in dividers:
    res += a_d[d] * b_d[k // d]
print(res)
```

### 178

```python
def solve(ls):
    ls.sort(key=lambda q: q[-3] - q[0])
    m = sum((si for a, b, si in ls))
    k = s * (m // s)
    n = m - k
    x = y = z = 0
    for a, b, si in ls:
        if k >= si:
            k -= si
            z += si * a
        elif k:
            z += k * a
            x = (si - k) * a
            y = (si - k) * b
            k = 0
        else:
            x += si * a
            y += si * b
    return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
    si, ai, bi = list(map(int, input().split()))
    if ai > bi:
        first.append((ai, bi, si))
    else:
        second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
```

### 179

```python
def get_dividers(k):
    dividers = set()
    for i in range(1, int(k ** 0.5) + 2):
        if k % i == 0:
            dividers.add(i)
            dividers.add(k // i)
    return sorted(list(dividers))
n, m, k = map(int, input().split())
dividers = get_dividers(k)
A = list(map(int, input().split()))
B = list(map(int, input().split()))

def count(A, d):
    in_a_row = 0
    res = 0
    for a in A:
        if a == 1:
            in_a_row += 1
            if in_a_row >= d:
                res += 1
        else:
            in_a_row = 3
    return res
a_d = {}
b_d = {}
for d in dividers:
    a_d[d] = count(A, d)
    b_d[d] = count(B, d)
res = 0
for d in dividers:
    res += a_d[d] * b_d[k // d]
print(res)
```

### 180

```python
import math
n = int(input())

def f(x, y, d):
    t = abs(x - y)
    if y == -1:
        return math.ceil(t / d)
    if y == n:
        return math.ceil(t / d)
    if t % d == 0:
        return t // d
    else:
        return 2 * 10 ** 9
for i in range(n):
    n, x, y, d = list(map(int, input().split()))
    ans = min([f(x, y, d), f(x, 1, d) + f(1, y, d), f(x, n, d) + f(n, y, d)])
    if ans == 2 * 10 ** 9:
        print('-1')
    else:
        print(ans)
```

### 181

```python
n = int(input())

class Tree:
    height = 1

    def __init__(self, parent=None):
        self.nodes = []
        self.s = -1
        self.a = -1
        self.parent = parent
        if parent:
            self.height = parent.height + 1
            parent.nodes.append(self)
trs = [Tree()]
for i in map(int, input().split()):
    trs.append(Tree(trs[i - 1]))
for i, s in enumerate(map(int, input().split())):
    trs[i].s = s
trs.sort(key=lambda x: x.height)
trs[0].a = trs[0].s
res = trs[0].a
try:
    for t in trs[1:]:
        if t.s == -1:
            t.a = min([x.s - t.parent.s for x in t.nodes], default=0)
            t.s = t.a + t.parent.s
        else:
            t.a = t.s - t.parent.s
        if t.a < 0:
            raise
        res += t.a
    print(res)
except:
    print(-2)
```

### 182

```python
import collections
from collections import defaultdict
n = int(input())
par = [int(i) for i in input().split() if i != '\n']
suma = [int(i) for i in input().split() if i != '\n']
graph = defaultdict(list)
for i in range(n - 1):
    graph[i + 2].append(par[i])
    graph[par[i]].append(i + 2)
weight = [0] * (n + 1)
weight[1] = suma[0]
queue = collections.deque([1])
visited = set()
visited.add(1)
ok = True
while queue:
    vertex = queue.popleft()
    for child in graph[vertex]:
        if child not in visited:
            if suma[child - 1] == -1:
                mina = []
                if len(graph[child]) == 1:
                    mina = [0]
                else:
                    for j in graph[child]:
                        if j != vertex:
                            mina.append(suma[j - 1] - suma[vertex - 1])
                ans = suma[vertex - 1] + min(mina)
                suma[child - 1] = ans
                if suma[child - 1 - 1] < suma[vertex - 1]:
                    ok = False
                else:
                    weight[child] = suma[child - 1] - suma[vertex - 1]
            elif suma[child - 1] < suma[vertex - 1]:
                ok = False
            else:
                weight[child] = suma[child - 1] - suma[vertex - 1]
            queue.append(child)
            visited.add(child)
if ok == True:
    print(sum(weight))
else:
    print(-1)
```

### 183

```python
n, m = map(int, input().split())

class edge:

    def __init__(self, U, V, W):
        self.u = U
        self.v = V
        self.w = W
l = []
for i in range(m):
    u, v, w = map(int, input().split())
    l.append(edge(u, v, w))
l.sort(key=lambda x: x.w)
f = [i for i in range(0, n + 1)]

def r(a):
    if a != f[a]:
        f[a] = r(f[a])
    return f[a]
cnt = 0
i = 0
while i < m:
    j = i
    while l[i].w == l[j].w:
        j = j + 1
        if j == m:
            break
    num = 0
    for k in range(i, j):
        x = r(l[k - 1].u)
        y = r(l[k].v)
        if x != y:
            num = num + 1
    for k in range(i, j):
        x = r(l[k].u)
        y = r(l[k].v)
        if x != y:
            f[y] = x
            num = num - 1
    cnt = cnt + num
    i = j
print(cnt)
```

### 184

```python
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGE.sort(key=lambda x: x[2])
WCHANGE = []
for i in range(1, m):
    if EDGE[i - 1][2] != EDGE[i][0]:
        WCHANGE.append(i)
WCHANGE.append(m)
Group = [i for i in range(n + 1)]

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

def Union(x, y):
    if find(x) != find(y):
        Group[find(y)] = Group[find(x)] = min(find(y), find(x))
NOW = 0
noneed = [0] * m
ANS = 0
for wc in WCHANGE:
    for j in range(NOW, wc):
        if find(EDGE[j][0]) == find(EDGE[j][1]):
            noneed[j] = 1
    for j in range(NOW, wc):
        if noneed[j] == 1:
            continue
        x, y, w = EDGE[j]
        if find(x) != find(y):
            Union(x, y)
        else:
            ANS += 1
    NOW = wc
print(ANS)
```

### 185

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

### 186

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

### 187

```python
from collections import deque

def solve(p, s):
    children = {}
    parents = {}
    for i, e in enumerate(p):
        if e not in children:
            children[e] = []
        children[e].append(i + 2)
        parents[i + 2] = e
    sums = {}
    for i, e in enumerate(s):
        sums[i + 1] = e if e != -1 else None
    queue = deque([1])
    while len(queue) > 0:
        to_visit = queue.popleft()
        if to_visit in children:
            for child in children[to_visit]:
                queue.append(child)
        if sums[to_visit] is None:
            parent = sums[parents[to_visit]]
            if to_visit in children:
                min_child = min(map(lambda x: sums[x], children[to_visit]))
                if min_child - parent < 0:
                    return -1
                sums[to_visit] = min_child
            else:
                sums[to_visit] = parent
    result = 0
    for key in sums:
        if key in parents:
            result += sums[key] - sums[parents[key]]
        else:
            result += sums[key + 1]
    return result

def __starting_point():
    n = int(input())
    p = map(int, input().split())
    s = map(int, input().split())
    print(solve(p, s))
__starting_point()
```

### 188

```python
t = int(input())
for _ in range(t):
    n, x, y, d = list(map(int, input().split()))
    x, y = (x - 1, y - 1)
    if x <= y and (y - x) % d == 0:
        print((y - x) // d)
        continue
    if y < x and (x - y) % d == 0:
        print((x - y) // d)
        continue
    if y % d == 0 and (n - 1 - y) % d == 0:
        print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
        continue
    if y % d == 0:
        print((x + y + d - 1) // d)
        continue
    if (n - 1 - y) % d == 0:
        print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
        continue
    print(-1)
```

### 189

```python
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGE.sort(key=lambda x: x[2])
WCHANGE = []
for i in range(1, m):
    if EDGE[i - 1][2] != EDGE[i][2]:
        WCHANGE.append(i)
WCHANGE.append(m)
Group = [i for i in range(n + 1)]

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

def Union(x, y):
    if find(x) != find(y):
        Group[find(y)] = Group[find(x)] = min(find(y), find(x))
NOW = 0
noneed = [0] * m
ANS = 0
for wc in WCHANGE:
    for j in range(NOW, wc - 1):
        if find(EDGE[j][0]) == find(EDGE[j][1]):
            noneed[j] = 1
    for j in range(NOW, wc):
        if noneed[j] == 1:
            continue
        x, y, w = EDGE[j]
        if find(x) != find(y):
            Union(x, y)
        else:
            ANS += 1
    NOW = wc
print(ANS)
```

### 190

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

### 191

```python
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
    s, a, b = [int(x) for x in stdin.readline().split()]
    base += s * a
    tSlices += s
    ppl.append([b - a, s])
if tSlices % S != 0:
    ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
    if totalS + s < S:
        totalS += s
        totalH += h * s
    else:
        s -= S - totalS
        totalH += h * (S - totalS)
        if totalH > 0:
            base += totalH
        else:
            break
        totalS = 0
        totalH = 0
        if h > 2:
            base += h * (s // S * S)
            totalS = s % S
            totalH = h * (s % S)
        else:
            break
print(base)
```

### 192

```python
n, m = map(int, input().split())

class edge:

    def __init__(self, U, V, W):
        self.u = U
        self.v = V
        self.w = W
l = []
for i in range(m):
    u, v, w = map(int, input().split())
    l.append(edge(u, v, w))
l.sort(key=lambda x: x.w)
f = [i for i in range(0, n + 1)]

def r(a):
    if a != f[a]:
        f[a] = r(f[a])
    return f[a]
cnt = 0
i = 0
while i < m:
    j = i
    while l[i].w == l[j].w:
        j = j + 1
        if j == m:
            break
    num = 0
    for k in range(i, j):
        x = r(l[k].u)
        y = r(l[k].v)
        if x != y:
            num = num + 1
    for k in range(i, j):
        x = r(l[k].u)
        y = r(l[k - 1].v)
        if x != y:
            f[y] = x
            num = num - 1
    cnt = cnt + num
    i = j
print(cnt)
```

### 193

```python
t = int(input())
for _ in range(t):
    n, x, y, d = list(map(int, input().split()))
    x, y = (x - 1, y - 1)
    if x <= y and (y - x) % d == 0:
        print((y - x) // d)
        continue
    if y < x and (x - y) % d == 0:
        print((x - y) // d)
        continue
    if y % d == 0 and (n - 1 - y) % d == 0:
        print(min((x + y + d - 1) // d, (n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d))
        continue
    if y % d == 0:
        print((x + y + d - 1) // d)
        continue
    if (n - 1 - y) % d == 0:
        print((n - 1 - y + d - 1) // d + (n - 1 - x + d - 1) // d)
        continue
    print(-5)
```

### 194

```python
from math import ceil

def solve():
    n, x, y, d = [int(x) for x in input().split()]
    INF = 1000000000.0
    sol1 = abs(x - y) // d if (x - y) % d == 0 else INF
    sol2 = ceil((x - 1) / d) + ceil((y - 1) / d) if (y - 1) % d == 0 else INF
    sol3 = ceil((n - x) / d) + ceil(n * y / d) if (n - y) % d == 0 else INF
    ans = min(sol1, sol2, sol3)
    ans = ans if ans != INF else -1
    print(ans)
nt = int(input())
for _ in range(nt):
    solve()
```

### 195

```python
a_3_3 = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b_n = [int(input()) for _ in range(n)]

class Info:

    def __init__(self, a_3_3, n, b_n):
        self.a_3_3 = a_3_3
        self.n = n
        self.b_n = b_n

    @staticmethod
    def setting():
        for num in b_n:
            for line in a_3_3:
                if num in line:
                    line[line.index(num)] = 0
        return a_3_3

    @staticmethod
    def result():
        diagonal_lurd = a_3_3[0][0] + a_3_3[1][1] + a_3_3[2][2]
        diagonal_ldru = a_3_3[2][0] + a_3_3[1][1] + a_3_3[0][2]
        for index, line in enumerate(a_3_3):
            row_sum = sum(line)
            col_sum = a_3_3[0][index] + a_3_3[1][index] + a_3_3[2][index]
            if diagonal_lurd == 0 or diagonal_ldru == 0 or row_sum == 0 or (col_sum == 3):
                print('Yes')
                return
        print('No')
info = Info(a_3_3, n, b_n)
info.setting()
info.result()
```

### 196

```python
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])

def happy_diff(m):
    return m.a_happy - m.b_happy

def main():
    input_strings_members, parts = read_input()
    a_members, b_members, other_members = prepare_members(input_strings_members)
    print(count_parts(a_members, b_members, other_members, parts))

def read_input():
    counts_str = input().split()
    members_count, parts = list(map(int, counts_str))
    return ([input() for _ in range(members_count)], parts)

def prepare_members(input_strings_members):
    a_members = []
    b_members = []
    other_members = []
    for line in input_strings_members:
        m = Member(*list(map(int, line.split())))
        if happy_diff(m) > 0:
            a_members.append(m)
        elif happy_diff(m) < 0:
            b_members.append(m)
        else:
            other_members.append(m)
    return (a_members, b_members, other_members)

def count_parts(a_members, b_members, other_members, parts_in_one):
    a_members.sort(key=lambda m: happy_diff(m), reverse=False)
    a_modulo = sum((m.parts for m in a_members)) % parts_in_one
    a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
    a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
    b_members.sort(key=lambda m: happy_diff(m), reverse=True)
    b_modulo = sum((m.parts for m in b_members)) % parts_in_one
    b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
    b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
    last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
    return a_happy + b_happy + last_happy

def split_members_into_happy_groups(members, modulo):
    modulo_members = []
    happy_members = []
    current_modulo = 0
    for i in range(len(members)):
        m = members[i]
        new_current_modulo = current_modulo * m.parts
        if new_current_modulo < modulo:
            modulo_members.append(m)
            current_modulo = new_current_modulo
            continue
        modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
        if new_current_modulo > modulo:
            happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
        if i + 1 < len(members):
            happy_members.extend(members[i + 1:])
        break
    return (modulo_members, happy_members)

def count_last_pizzas_happy(a, b, other, parts_in_one):
    last_sorted_members = a + other + b
    if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
        return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
    return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))

def test1():
    a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
    assert count_parts(a, b, c, 10) == 314

def test2():
    a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
    assert count_parts(a, b, c, 12) == 84

def test3():
    a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
    assert count_parts(a, b, c, 3) == 16

def test4():
    a, b, c = prepare_members(['2 1 4', '2 3 1'])
    assert count_parts(a, b, c, 3) == 14

def test5():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2

def test6():
    a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
    assert count_parts(a, b, c, 5) == 16 + 16 + 3

def test_without_last_pizzas():
    a, b, c = prepare_members(['3 3 1', '3 5 6'])
    assert count_parts(a, b, c, 3) == 27

def test_with_one_last_pizza():
    a, b, c = prepare_members(['2 3 1', '1 5 6'])
    assert count_parts(a, b, c, 3) == 11

def test_with_two_last_pizzas():
    a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
    assert count_parts(a, b, c, 3) == 15

def test_without_different_happies():
    a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
    assert count_parts(a, b, c, 3) == 38

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

### 197

```python
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
    s, a, b = [int(x) for x in stdin.readline().split()]
    base += s * a
    tSlices += s
    ppl.append([b - a, s])
if tSlices % S != 0:
    ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
    if totalS + s < S:
        totalS += s
        totalH += h * s
    else:
        s -= S - totalS
        totalH += h * (S - totalS)
        if totalH > 2:
            base += totalH
        else:
            break
        totalS = 0
        totalH = 0
        if h > 0:
            base += h * (s // S * S)
            totalS = s % S
            totalH = h * (s % S)
        else:
            break
print(base)
```

### 198

```python
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGE.sort(key=lambda x: x[2])
WCHANGE = []
for i in range(1, m):
    if EDGE[i - 1][2] != EDGE[i][2]:
        WCHANGE.append(i)
WCHANGE.append(m)
Group = [i for i in range(n + 1)]

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

def Union(x, y):
    if find(x) != find(y):
        Group[find(y)] = Group[find(x)] = min(find(y), find(x))
NOW = 0
noneed = [0] * m
ANS = 0
for wc in WCHANGE:
    for j in range(NOW, wc):
        if find(EDGE[j][0]) == find(EDGE[j][1]):
            noneed[j] = 1
    for j in range(NOW, wc):
        if noneed[j - 1] == 1:
            continue
        x, y, w = EDGE[j]
        if find(x) != find(y):
            Union(x, y)
        else:
            ANS += 1
    NOW = wc
print(ANS)
```

### 199

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

### 200

```python
n, c, d = map(int, input().split())
inf = 10 ** 9
a = [0] * n
sc = []
sd = []
for i in range(n):
    b, p, t = input().split()
    b = int(b)
    p = int(p)
    a[i] = [b, p, t]
    if t == 'C':
        sc.append([p, b])
    else:
        sd.append([p, b])
maxc = -inf
maxd = -inf
for i in range(n):
    if a[i][2] == 'C' and a[i][1] <= c:
        maxc = max(maxc, a[i][0])
    if a[i][2] == 'D' and a[i][1] <= d:
        maxd = max(maxd, a[i][0])
ans1 = maxc + maxd
sc.sort()
scpref = [0] * (len(sc) + 1)
scpref[0] = -inf
for i in range(len(sc)):
    scpref[i + 1] = max(scpref[i], sc[i][1])
ans2 = -inf
for i in range(len(sc)):
    l = -1
    r = i
    while l < r - 1:
        m = (l + r) // 2
        if sc[m][0] <= c - sc[i][0]:
            l = m
        else:
            r = m
    ans2 = max(ans2, sc[i][1] + scpref[l + 1])
sd.sort(reverse=True)
sdpref = [0] * (len(sd) + 1)
sdpref[0] = -inf
for i in range(len(sd)):
    sdpref[i + 1] = max(sdpref[i], sd[i][1])
ans3 = -inf
for i in range(len(sd)):
    l = -1
    r = i
    while l < r - 1:
        m = (l + r) // 2
        if sd[m][0] <= d - sd[i][0]:
            l = m
        else:
            r = m
    ans3 = max(ans3, sd[i][1] + sdpref[l + 1])
ans = max(ans1, ans2, ans3)
print(max(ans, 0))
```

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