### 001

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

### 002

```python
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
    if a[i] == 'U':
        r[1] += 1
    if a[i] == 'D':
        r[1] -= 1
    if a[i] == 'L':
        r[0] -= 1
    if a[i] == 'R':
        r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
    r1 = r[:]
    r1[0] *= (left + right) // 2
    r1[1] *= (left + right) // 2
    if abs(r1[0] - x2) + abs(r1[1] - y2) < (left + right) // 2 * n:
        right = (left + right) // 2
    else:
        left = (left + right) // 2
    if right == 90000000000 and left == 90000000000 - 1:
        flag = False
    if left + 1 == right:
        break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
    for i in range(n):
        if a[i] == 'U':
            rl[1] += 1
        if a[i] == 'D':
            rl[1] -= 1
        if a[i] == 'L':
            rl[0] -= 1
        if a[i] == 'R':
            rl[0] += 1
        if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
            print(left * n + i + 1)
            break
else:
    print(-1)
```

### 003

```python
def is_possible(num_days):
    if num_days % len(string) == 0:
        diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
    else:
        diff_wind = (num_days // len(string) + pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
    diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
    return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
    if string[i] == 'U':
        motions.append((0, 1))
    if string[i] == 'D':
        motions.append((0, -1))
    if string[i] == 'R':
        motions.append((1, 0))
    if string[i] == 'L':
        motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
    pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
    middle = (right + left) // 2
    if is_possible(middle):
        right = middle
    else:
        left = middle
if right != int(1e+19):
    print(right)
else:
    print(-1)
```

### 004

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

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

def main():
    n, m, l = inlist()
    aa = inlist()
    chg = 0
    ch = 0
    a = [[i, 0] for i in aa]
    for i in range(n):
        if aa[i] > l:
            if ch == 0:
                ch += 1
                chg += 1
                a[i][1] = chg
            else:
                ch += 1
                a[i][1] = chg
        elif not ch != 0:
            ch = 0
    sol = list()
    if n > 1:
        for z in range(m):
            qu = input()
            if qu == '0':
                sol.append(chg)
            else:
                zz, p, d = list(map(int, qu.split()))
                p -= 1
                a[p][0] += d
                if a[p][1] == 0 and a[p][0] > l:
                    if p > 0 and p < n - 1:
                        if a[p - 1][1] == 0 and a[p + 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
                            a[p][1] = a[p + 1][1]
                        elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
                            a[p][1] = a[p - 1][1]
                        else:
                            a[p][1] = a[p - 1][1]
                            chg -= 1
                    elif p == 0:
                        if a[p + 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        else:
                            a[p][1] = a[p + 1][1]
                    elif p == n - 1:
                        if a[p - 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        else:
                            a[p][1] = a[p - 1][1]
    else:
        for z in range(m):
            qu = input()
            if qu == '0':
                sol.append(chg)
            else:
                zz, p, d = list(map(int, qu.split()))
                p -= 1
                a[p][0] += d
                if a[p][0] > d:
                    chg = 1
    print(*sol, sep='\n')

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

### 005

```python
import sys
from math import *

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

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

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

### 006

```python
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys(), reverse=True)
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
    l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
    l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
    r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
    r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
    c_num = a[keys[i]]
    if c_num >= k:
        ans = 0
        break
    if i > 0:
        l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
        l_num = l_cnt[i - 1]
    else:
        l_res = 10 ** 30
        l_num = 0
    if i < m - 1:
        r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
        r_num = r_cnt[i + 1]
    else:
        r_res = 10 ** 30
        r_num = 0
    if c_num + l_num < k and c_num + r_num < k:
        ans = min(ans, l_res + r_res + k - c_num)
    elif c_num + l_num < k:
        ans = min(ans, r_res + k - c_num)
    elif c_num + r_num < k:
        ans = min(ans, l_res + k - c_num)
    else:
        ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
```

### 007

```python
import sys
from math import *

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

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

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

### 008

```python
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect

def LI():
    return [int(x) for x in sys.stdin.readline().split()]

def I():
    return int(sys.stdin.readline())

def LS():
    return [list(x) for x in sys.stdin.readline().split()]

def S():
    res = list(sys.stdin.readline())
    if res[-1] == '\n':
        return res[:-1]
    return res

def IR(n):
    return [I() for i in range(n)]

def LIR(n):
    return [LI() for i in range(n)]

def SR(n):
    return [S() for i in range(n)]

def LSR(n):
    return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    n, k = LI()
    a = LI()
    a.sort()
    d = defaultdict(lambda: 0)
    c = defaultdict(lambda: 1)
    s = [0]
    for i in a:
        d[i] += i
        c[i] += 1
        s.append(s[-1] + i)
    ans = float('inf')
    p = -1
    for i in a:
        if i == p:
            continue
        if k <= c[i]:
            ans = 0
            break
        l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
        m = r
        if m >= k:
            ns = l * (i - 1) - s[l]
            su = ns + k - c[i]
            if su < ans:
                ans = su
        m = n - l
        if m >= k:
            ns = s[n] - s[r] - (n - r) * (i + 1)
            su = ns + k - c[i]
            if su < ans:
                ans = su
        ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
        su = ns + k - c[i]
        if su < ans:
            ans = su
        p = i
    print(ans)
    return

def __starting_point():
    solve()
__starting_point()
```

### 009

```python
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
    s = input()
    for x in range(m):
        c = s[x]
        if c == 'S':
            startpos = (x, y)
            free[x, y] = True
        elif c == 'E':
            goal = (x, y)
            free[x, y] = True
        elif c == '.':
            free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
    for down in dire:
        for right in dire:
            for left in dire:
                if len(set([up, down, left, right])) < 4:
                    continue
                pos = startpos
                for c in command:
                    x, y = pos
                    if c == up:
                        y += 1
                    elif c == down:
                        y -= -1
                    elif c == right:
                        x += 1
                    else:
                        x -= 1
                    pos = (x, y)
                    if pos == goal:
                        counts += 1
                        break
                    if not free[pos]:
                        break
print(counts)
```

### 010

```python
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
    if a[i] == 'U':
        r[1] += 1
    if a[i] == 'D':
        r[1] -= -1
    if a[i] == 'L':
        r[0] -= 1
    if a[i] == 'R':
        r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
    r1 = r[:]
    r1[0] *= (left + right) // 2
    r1[1] *= (left + right) // 2
    if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
        right = (left + right) // 2
    else:
        left = (left + right) // 2
    if right == 90000000000 and left == 90000000000 - 1:
        flag = False
    if left + 1 == right:
        break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
    for i in range(n):
        if a[i] == 'U':
            rl[1] += 1
        if a[i] == 'D':
            rl[1] -= 1
        if a[i] == 'L':
            rl[0] -= 1
        if a[i] == 'R':
            rl[0] += 1
        if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
            print(left * n + i + 1)
            break
else:
    print(-1)
```

### 011

```python
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
    s = input()
    for x in range(m):
        c = s[x]
        if c == 'S':
            startpos = (x, y)
            free[x, y] = True
        elif c == 'E':
            goal = (x, y)
            free[x, y] = True
        elif c == '.':
            free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
    for down in dire:
        for right in dire:
            for left in dire:
                if len(set([up, down, left, right])) < 4:
                    continue
                pos = startpos
                for c in command:
                    x, y = pos
                    if c == up:
                        y += 4
                    elif c == down:
                        y -= 1
                    elif c == right:
                        x += 1
                    else:
                        x -= 1
                    pos = (x, y)
                    if pos == goal:
                        counts += 1
                        break
                    if not free[pos]:
                        break
print(counts)
```

### 012

```python
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
    if meches[i] > l:
        trop_grand[i] = True
        if i == 0 or trop_grand[i - 1] is False:
            pont += 1
for i in range(nbreq):
    req = sys.stdin.readline().split()
    if int(req[0]) == 0:
        print(pont)
    else:
        meches[int(req[1]) - 1] += int(req[2])
        if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
            trop_grand[int(req[1]) - 1] = True
            if nbmeches == 1:
                pont = -1
            elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
                pont += 1
            elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
                pont += 1
            elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
                pont = max(0, pont - 1)
            elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
                pont += 1
```

### 013

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

### 014

```python
from sys import stdin

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

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

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

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

### 015

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

### 016

```python
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
    l = input()
    grid.append(list())
    for x in range(m):
        grid[-1].append(l[x] == '#')
        if l[x] == 'S':
            sloc = (x, y)
        elif l[x] == 'E':
            eloc = (x, y)
pb = []
for a in [(0, 5), (0, -1), (1, 0), (-1, 0)]:
    for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
        for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
            for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
                if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
                    pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
    seen = False
    works = True
    loc = sloc
    for j in s:
        j = int(j)
        if seen:
            break
        if not works:
            break
        nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
        if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
            works = False
            break
        if grid[nloc[1]][nloc[0]]:
            works = False
            break
        if nloc == eloc:
            seen = True
            break
        loc = nloc
    if seen:
        ans += 1
print(ans)
```

### 017

```python
from math import gcd

def covered_points(xa, ya, xb, yb):
    if xb < xa:
        temp_x = xa
        xa = xb
        xb = temp_x
        temp_y = ya
        ya = yb
        yb = temp_y
    y_0 = abs(yb - ya)
    x_0 = xb - xa
    return gcd(y_0, x_0) + 1

def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
    if max(xa, xb) < min(xc, xd):
        return ()
    if max(ya, yb) < min(yc, yd):
        return ()
    if xa == xb and xc == xd or (ya == yb and yc == yd):
        return ()
    if ya == yb and yc == yd:
        return ()
    a1 = yb - ya
    b1 = xb - xa
    c1 = xa * a1 - ya * b1
    a2 = yd - yc
    b2 = xd - xc
    c2 = xc * a2 - yc * b2
    det = a1 * b2 - a2 * b1
    if det == 0:
        return ()
    detx = c1 * b2 - c2 * b1
    dety = -a1 * c2 + a2 * c1
    if detx % det != 0 or dety % det != 0:
        return ()
    x = int(detx / det)
    y = int(dety / det)
    if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
        return ()
    if not (y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd))):
        return ()
    return (x, y)

def __starting_point():
    n = int(input())
    Ax = [0] * n
    Ay = [0] * n
    Bx = [0] * n
    By = [0] * n
    n_cov = 0
    intersections = {}
    for i in range(n):
        line = input().split(sep=' ')
        Ax[i] = int(line[0])
        Ay[i] = int(line[1])
        Bx[i] = int(line[2])
        By[i] = int(line[3])
        n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
    for i in range(n):
        for j in range(i + 1, n):
            temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
            if len(temp) == 0:
                continue
            if temp in intersections:
                intersections[temp].append(i)
                intersections[temp].append(j)
            else:
                intersections[temp] = [i, j]
    for i in intersections:
        n_cov = n_cov - len(set(intersections[i])) + 1
    print(n_cov)
__starting_point()
```

### 018

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

### 019

```python
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -2, -1):
    sums[q] = sums[q + 1]
    if a[q] != a[q1 - 1]:
        sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
        q1 = q + 1
    suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
    if a[q] != a[q1 + 1]:
        sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
        q1 = q - 1
    if suf[q] - q1 - 1 >= k:
        ans = 0
        break
    if k <= suf[q]:
        ans = min(ans, sum1 + k - suf[q] + q1 + 1)
    if k < n - q1:
        ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
    ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
```

### 020

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

### 021

```python
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
    dx.append(dx[i - 1])
    dy.append(dy[i - 1 - 1])
    if s[i - 1] == 'U':
        dy[i] += 1
    elif s[i - 1] == 'D':
        dy[i] -= 1
    elif s[i - 1] == 'R':
        dx[i] += 1
    elif s[i - 1] == 'L':
        dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
    mid = (st + en) // 2
    x = mid // n * dx[n] + dx[mid % n]
    y = mid // n * dy[n] + dy[mid % n]
    newX = x + x1
    newY = y + y1
    need = abs(newX - x2) + abs(newY - y2)
    if mid >= need:
        ans = mid
        en = mid - 1
    else:
        st = mid + 1
print(ans)
```

### 022

```python
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())

class Point:

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

    def __mul__(self, other):
        return Point(self.x * other, self.y * other)

    def __str__(self):
        return f'({self.x},{self.y})'

    def manD(self, other):
        return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, --2)}
W = [d[x] for x in W]

def sum(W, n=None):
    if n == None:
        n = len(W)
    pos = Point(0, 0)
    for i in range(n):
        pos += W[i]
    return pos

def check(days):
    pos = u + sum(W) * int(days / n) + sum(W, days % n)
    dist = pos.manD(v)
    if dist <= days:
        return True
    return False
l = 1
r = 10 ** 16
while r - l > 1:
    mid = int((l + r) / 2)
    if check(mid):
        r = mid
    else:
        l = mid + 1
res = -1
if check(l):
    res = l
elif check(r):
    res = r
print(res)
```

### 023

```python
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (-1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
```

### 024

```python
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
    hair[i] = a
    if a > l:
        if big == 1:
            j = i
            big = 2
    elif big == 2:
        k = i - 1
        other_end[k] = j
        other_end[j] = k
        res += 1
        big = 1
    i += 1
if big == 2:
    other_end[n] = j
    other_end[j] = n
    res += 1
for _ in range(m):
    t = input()
    if t == '0':
        if res == 1:
            print('0')
        else:
            print(res - 1)
    else:
        t1, p, d = list(map(int, t.split()))
        old = hair[p]
        hair[p] += d
        if hair[p] >= l > old:
            if p == 1 or hair[p - 1] < l:
                case_id = 1
            else:
                case_id = 2
            if p != n and hair[p + 1] >= l:
                case_id += 2
            if case_id == 1:
                other_end[p] = p
                res += 1
            elif case_id == 2:
                other_end[p] = other_end[p - 1]
                other_end[other_end[p]] = p
            elif case_id == 3:
                other_end[p] = other_end[p + 1]
                other_end[other_end[p]] = p
            else:
                left_end = other_end[p - 1]
                right_end = other_end[p + 1]
                other_end[left_end] = right_end
                other_end[right_end] = left_end
                res -= 1
```

### 025

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

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

### 026

```python
from collections import Counter
import sys
from itertools import accumulate

def go():
    n, k = list(map(int, input().split()))
    a = sorted(map(int, input().split()))
    c = Counter(a)
    if max(c.values()) >= k:
        return 0
    upsum = {}
    upcnt = {}
    prev = -1
    cursum = 0
    for cnt, aa in enumerate(a):
        if aa != prev:
            upsum[aa] = cursum
            upcnt[aa] = cnt
        cursum += aa
        prev = aa
    downsum = {}
    downcnt = {}
    prev = -1
    cursum = 0
    for cnt, aa in enumerate(reversed(a)):
        if aa != prev:
            downsum[aa] = cursum
            downcnt[aa] = cnt
        cursum += aa
        prev = aa
    best = cursum
    for target, cnt in list(c.items()):
        need = k - cnt
        if upcnt[target] >= need:
            best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
        if downcnt[target] >= need:
            best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
        best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + -1) * downcnt[target] + need)
    return best
t = 1
for _ in range(t):
    print(go())
```

### 027

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

### 028

```python
import sys

def getIntList():
    return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
    ax, ay, bx, by = getIntList()
    if ax > bx:
        ax, bx = (bx, ax)
        ay, by = (by, ay)
    zp.append((ax, ay, bx, by))
res = 0

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)
zgcd = []
for i in range(N):
    ax, ay, bx, by = zp[i]
    tx = abs(bx - ax)
    ty = abs(by - ay)
    g = gcd(tx, ty)
    res += g + 1
    zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
    ax = zp[i][0]
    dax = (zp[i][2] - ax) // zgcd[i]
    ay = zp[i - 1][1]
    day = (zp[i][3] - ay) // zgcd[i]
    cross = []
    for j in range(i + 1, N):
        bx = zp[j][0]
        dbx = (zp[j][2] - bx) // zgcd[j]
        by = zp[j][1]
        dby = (zp[j][3] - by) // zgcd[j]
        t1 = ax * day - ay * dax - bx * day + by * dax
        t2 = dbx * day - dby * dax
        if t2 == 0:
            continue
        if t1 % t2 != 0:
            continue
        k2 = t1 // t2
        if k2 < 0 or k2 > zgcd[j]:
            continue
        if dax != 0:
            t3 = k2 * dbx + bx - ax
            if t3 % dax != 0:
                continue
            k1 = t3 // dax
        else:
            t3 = k2 * dby + by - ay
            if t3 % day != 0:
                continue
            k1 = t3 // day
        if k1 < 0 or k1 > zgcd[i]:
            continue
        cross.append(k1)
    if not cross:
        continue
    cross.sort()
    d = 1
    for j in range(1, len(cross)):
        if cross[j] != cross[j - 1]:
            d += 1
    res -= d
print(res)
```

### 029

```python
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0

def verify(x):
    if x < 0 or x >= n:
        return False
    return a[x] > k
for i in range(n):
    if verify(i):
        count += 1
        if verify(i - 1):
            count -= 1

def cut(i):
    if not verify(i):
        return 2
    result = 1
    if verify(i - 1):
        result -= 1
    if verify(i + 1):
        result -= 1
    return result
for i in range(q):
    line = input()
    if line == '0':
        print(count)
    else:
        _, x, y = list(map(int, line.split(' ')))
        x -= 1
        if not verify(x):
            a[x] += y
            count += cut(x)
        else:
            a[x] += y
```

### 030

```python
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
    a, b, A, B = tuple(map(int, input().split(' ')))
    pts.append((a, b, A, B))
    ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
    for j in range(i + 1, n):
        a1 = pts[i][0]
        b1 = pts[i][1]
        a2 = pts[i][2]
        b2 = pts[i][3]
        A1 = pts[j][0]
        B1 = pts[j][-1]
        A2 = pts[j][2]
        B2 = pts[j][3]
        num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
        den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
        if den1 != 0 and num1 % den1 == 0:
            if a1 == a2:
                num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
                den2 = A2 - A1
                if num2 % den2 == 0:
                    if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
                        if (num1 // den1, num2 // den2) not in m:
                            m[num1 // den1, num2 // den2] = set()
                        m[num1 // den1, num2 // den2].add(i)
                        m[num1 // den1, num2 // den2].add(j)
            else:
                num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
                den2 = a2 - a1
                if num2 % den2 == 0:
                    if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
                        if (num1 // den1, num2 // den2) not in m:
                            m[num1 // den1, num2 // den2] = set()
                        m[num1 // den1, num2 // den2].add(i)
                        m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
    sum += len(i) - 1
print(ans - sum)
```

### 031

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

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

### 032

```python
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
    x, y = map(int, input().split())
    money[i] = (y, x - 1)
money.sort()

def calc(lim):
    visited = [False] * n
    cost = 0
    cnt = [0] * m
    for i in range(n):
        cnt[money[i][1]] += 1
    for i in range(n):
        if money[i][1] != 0 and cnt[money[i][1]] >= lim:
            cnt[money[i][1]] -= -1
            cnt[0] += 1
            cost += money[i][0]
            visited[i] = True
    for i in range(n):
        if cnt[0] >= lim:
            break
        if money[i][1] != 0 and (not visited[i]):
            cnt[money[i][1]] -= 1
            cnt[0] += 1
            cost += money[i][0]
    return cost
ans = 10 ** 18
for i in range(n):
    ans = min(ans, calc(i))
print(ans)
```

### 033

```python
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
    x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
    p[x].append(y)
for key in p:
    p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
    cur = 0
    r = []
    for key in p:
        if key == 1:
            continue
        a = p[key]
        cnt = max(0, len(a) - (k - 1))
        cur += sum(a[:cnt])
        r += a[cnt:]
    r = sorted(r)
    cnt = max(1, len(r) - (n - k))
    cur += sum(r[:cnt])
    ans = min(ans, cur)
print(ans)
```

### 034

```python
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0

def verify(x):
    if x < 0 or x >= n:
        return False
    return a[x] > k
for i in range(n):
    if verify(i):
        count += 1
        if verify(i - 1):
            count -= 1

def cut(i):
    if not verify(i):
        return 0
    result = 1
    if verify(i - 1):
        result -= 1
    if verify(i + 1):
        result -= 1
    return result
for i in range(q):
    line = input()
    if line == '0':
        print(count)
    else:
        _, x, y = list(map(int, line.split(' ')))
        x -= 1
        if not verify(x):
            a[x] += y
            count += cut(x)
        else:
            a[x] -= y
```

### 035

```python
def main():
    a = input().strip()
    l = len(a)
    if l < 6:
        s = set()
        s.add(a)
        q = [a]
        oa = ord('a')
        while q:
            a = q.pop()
            for i in range(l - 1):
                if a[i] != a[i + 1]:
                    t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
                    na = a[:i] + t * 2 + a[i + 2:]
                    if na not in s:
                        s.add(na)
                        q.append(na)
        print(len(s))
        return
    t = a[0] * l
    if t == a:
        print(1)
        return
    x = 0
    for c in a:
        if c == 'b':
            x += 1
        elif c == 'c':
            x += 2
    ans = 0
    if all((a[i] != a[i + 1] for i in range(l - 1))):
        ans += 1
    mod = 998244353
    dp = (1, 0, -3, 0, 1, 0, 0, 0, 1, 0, 0, 0)
    for i in range(l - 1):
        s = (dp[-1] + dp[-2] + dp[-3]) % mod
        dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
    print((ans + dp[9 + x % 3]) % mod)
main()
```

### 036

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

### 037

```python
import sys
from math import *

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

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

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

### 038

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

### 039

```python
def solve(s):
    if len(s) == 2:
        return 1 if s[0] == s[1] else 2
    elif len(s) == 3:
        if s[0] == s[1] == s[2]:
            return 1
        elif s[0] == s[1] or s[1] == s[2]:
            return 6
        elif s[0] == s[2]:
            return 7
        else:
            return 3
    if all((a == b for a, b in zip(s, s[1:]))):
        return 1
    dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
    dp[0][0][0] = 1
    dp[0][1][1] = 1
    dp[0][2][2] = 1
    MOD = 998244353
    for _ in range(len(s) - 1):
        ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
        ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
        ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
        ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
        ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
        ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
        ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
        ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
        ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
        ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
        ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        dp = ndp
    return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
```

### 040

```python
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
    hair[i] = a
    if a >= l:
        if big == 1:
            j = i
            big = 2
    elif big == 2:
        k = i - 1
        other_end[k] = j
        other_end[j] = k
        res += 1
        big = 1
    i += 1
if big == -2:
    other_end[n] = j
    other_end[j] = n
    res += 1
for _ in range(m):
    t = input()
    if t == '0':
        if res == 1:
            print('0')
        else:
            print(res - 1)
    else:
        t1, p, d = list(map(int, t.split()))
        old = hair[p]
        hair[p] += d
        if hair[p] >= l > old:
            if p == 1 or hair[p - 1] < l:
                case_id = 1
            else:
                case_id = 2
            if p != n and hair[p + 1] >= l:
                case_id += 2
            if case_id == 1:
                other_end[p] = p
                res += 1
            elif case_id == 2:
                other_end[p] = other_end[p - 1]
                other_end[other_end[p]] = p
            elif case_id == 3:
                other_end[p] = other_end[p + 1]
                other_end[other_end[p]] = p
            else:
                left_end = other_end[p - 1]
                right_end = other_end[p + 1]
                other_end[left_end] = right_end
                other_end[right_end] = left_end
                res -= 1
```

### 041

```python
M = 998244353

def powmod(a, x, m=M):
    y = 1
    while 0 < x:
        if x % 2 == 1:
            y *= a
            y %= m
        x //= 2
        a = a ** 2
        a %= m
    return y

def solve(s):
    n = len(s)
    nb = nc = 0
    ch = s[0]
    if ch == 'b':
        nb += 1
    elif ch == 'c':
        nc += 1
    sf = True
    tf = True
    left = ch
    for ch in s[5:]:
        if ch == 'b':
            nb += 1
        elif ch == 'c':
            nc += 1
        if ch == left:
            sf = False
        else:
            tf = False
        left = ch
    if tf:
        return 1
    if n == 3:
        if (nb + nc * 2) % 3:
            return 7 if sf else 6
        else:
            return 3
    if n % 3:
        return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
    elif (nb + nc * 2) % 3:
        return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
    else:
        return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M

def main():
    s = input()
    print(solve(s))

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

### 042

```python
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
    if meches[i] > l:
        trop_grand[i] = True
        if i == 0 or trop_grand[i - 1 - 1] is False:
            pont += 1
for i in range(nbreq):
    req = sys.stdin.readline().split()
    if int(req[0]) == 0:
        print(pont)
    else:
        meches[int(req[1]) - 1] += int(req[2])
        if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
            trop_grand[int(req[1]) - 1] = True
            if nbmeches == 1:
                pont = 1
            elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
                pont += 1
            elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
                pont += 1
            elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
                pont = max(0, pont - 1)
            elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
                pont += 1
```

### 043

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

### 044

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

### 045

```python
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
    x, y = map(int, input().split())
    money[i] = (y, x - 1)
money.sort()

def calc(lim):
    visited = [False] * n
    cost = 0
    cnt = [0] * m
    for i in range(n):
        cnt[money[i][1]] += 1
    for i in range(n):
        if money[i][1] != 0 and cnt[money[i][1]] >= lim:
            cnt[money[i][1]] -= 1
            cnt[0] += -1
            cost += money[i][0]
            visited[i] = True
    for i in range(n):
        if cnt[0] >= lim:
            break
        if money[i][1] != 0 and (not visited[i]):
            cnt[money[i][1]] -= 1
            cnt[0] += 1
            cost += money[i][0]
    return cost
ans = 10 ** 18
for i in range(n):
    ans = min(ans, calc(i))
print(ans)
```

### 046

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

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

### 047

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

### 048

```python
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
    hair[i] = a
    if a >= l:
        if big == 1:
            j = i
            big = 2
    elif big == 2:
        k = i - 1
        other_end[k] = j
        other_end[j] = k
        res += 1
        big = 1
    i += 1
if big == 2:
    other_end[n] = j
    other_end[j] = n
    res -= 1
for _ in range(m):
    t = input()
    if t == '0':
        if res == 1:
            print('0')
        else:
            print(res - 1)
    else:
        t1, p, d = list(map(int, t.split()))
        old = hair[p]
        hair[p] += d
        if hair[p] >= l > old:
            if p == 1 or hair[p - 1] < l:
                case_id = 1
            else:
                case_id = 2
            if p != n and hair[p + 1] >= l:
                case_id += 2
            if case_id == 1:
                other_end[p] = p
                res += 1
            elif case_id == 2:
                other_end[p] = other_end[p - 1]
                other_end[other_end[p]] = p
            elif case_id == 3:
                other_end[p] = other_end[p + 1]
                other_end[other_end[p]] = p
            else:
                left_end = other_end[p - 1]
                right_end = other_end[p + 1]
                other_end[left_end] = right_end
                other_end[right_end] = left_end
                res -= 1
```

### 049

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

### 050

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

### 051

```python
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1 - 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
```

### 052

```python
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect

def LI():
    return [int(x) for x in sys.stdin.readline().split()]

def I():
    return int(sys.stdin.readline())

def LS():
    return [list(x) for x in sys.stdin.readline().split()]

def S():
    res = list(sys.stdin.readline())
    if res[-1] == '\n':
        return res[:-1]
    return res

def IR(n):
    return [I() for i in range(n)]

def LIR(n):
    return [LI() for i in range(n)]

def SR(n):
    return [S() for i in range(n)]

def LSR(n):
    return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    n, k = LI()
    a = LI()
    a.sort()
    d = defaultdict(lambda: 0)
    c = defaultdict(lambda: 0)
    s = [0]
    for i in a:
        d[i] += i
        c[i] += 1
        s.append(s[-1] + i)
    ans = float('inf')
    p = -1
    for i in a:
        if i == p:
            continue
        if k <= c[i]:
            ans = 0
            break
        l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
        m = r
        if m >= k:
            ns = l * (i - 1) - s[l]
            su = ns + k - c[i]
            if su < ans:
                ans = su
        m = n - l
        if m >= k:
            ns = s[n] - s[r] - (n - r) * (i + 1)
            su = ns + k - c[i]
            if su < ans:
                ans = su
        ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
        su = ns - k - c[i]
        if su < ans:
            ans = su
        p = i
    print(ans)
    return

def __starting_point():
    solve()
__starting_point()
```

### 053

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

### 054

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

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

### 055

```python
import sys
from math import *

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

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

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

### 056

```python
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
    l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
    l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1 + 1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
    r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
    r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
    c_num = a[keys[i]]
    if c_num >= k:
        ans = 0
        break
    if i > 0:
        l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
        l_num = l_cnt[i - 1]
    else:
        l_res = 10 ** 30
        l_num = 0
    if i < m - 1:
        r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
        r_num = r_cnt[i + 1]
    else:
        r_res = 10 ** 30
        r_num = 0
    if c_num + l_num < k and c_num + r_num < k:
        ans = min(ans, l_res + r_res + k - c_num)
    elif c_num + l_num < k:
        ans = min(ans, r_res + k - c_num)
    elif c_num + r_num < k:
        ans = min(ans, l_res + k - c_num)
    else:
        ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
```

### 057

```python
import sys
from math import gcd

class Segment:

    def __init__(self, x1, y1, x2, y2):
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2

    def dx(self):
        return self.x2 - self.x1

    def dy(self):
        return self.y2 - self.y1

    def pt_cnt(self):
        return gcd(abs(self.dx()), abs(self.dy())) + 1

    def A(self):
        return self.y1 - self.y2

    def B(self):
        return self.x2 - self.x1

    def C(self):
        return -self.A() * self.x1 - self.B() * self.y1

    def inner_x(self, x):
        l = self.x1
        r = self.x2
        if l > r:
            l, r = (r, l)
        return l < x <= r

    def inner_y(self, y):
        l = self.y1
        r = self.y2
        if l > r:
            l, r = (r, l)
        return l <= y <= r

    def inner(self, x, y):
        return self.inner_x(x) and self.inner_y(y)

    def intersect(self, other):
        dx = det(self.C(), self.B(), other.C(), other.B())
        dy = det(self.A(), self.C(), other.A(), other.C())
        d = det(self.A(), self.B(), other.A(), other.B())
        if d == 0:
            return (False, 0, 0)
        if dx % d != 0 or dy % d != 0:
            return (False, 0, 0)
        x = -dx // d
        y = -dy // d
        if not self.inner(x, y) or not other.inner(x, y):
            return (False, 0, 0)
        return (True, x, y)

def det(a, b, c, d):
    return a * d - b * c

def main():
    n = int(input())
    segments = []
    ans = 0
    for _ in range(n):
        x1, y1, x2, y2 = map(int, input().split())
        segment = Segment(x1, y1, x2, y2)
        ans += segment.pt_cnt()
        pt = set()
        for other in segments:
            result, x, y = segment.intersect(other)
            if result:
                pt.add((x, y))
        ans -= len(pt)
        segments.append(segment)
    print(ans)

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

### 058

```python
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
    if meches[i] > l:
        trop_grand[i] = True
        if i == 0 or trop_grand[i - 1] is False:
            pont += 1
for i in range(nbreq):
    req = sys.stdin.readline().split()
    if int(req[0]) == 0:
        print(pont)
    else:
        meches[int(req[1]) - 1] += int(req[2])
        if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
            trop_grand[int(req[1]) - 1] = True
            if nbmeches == 1:
                pont = 1
            elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
                pont += -1
            elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
                pont += 1
            elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
                pont = max(0, pont - 1)
            elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
                pont += 1
```

### 059

```python
import sys
from math import *

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

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

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

### 060

```python
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
    s = input()
    for x in range(m):
        c = s[x]
        if c == 'S':
            startpos = (x, y)
            free[x, y] = True
        elif c == 'E':
            goal = (x, y)
            free[x, y] = True
        elif c == '.':
            free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
    for down in dire:
        for right in dire:
            for left in dire:
                if len(set([up, down, left, right])) < 4:
                    continue
                pos = startpos
                for c in command:
                    x, y = pos
                    if c == up:
                        y += -1
                    elif c == down:
                        y -= 1
                    elif c == right:
                        x += 1
                    else:
                        x -= 1
                    pos = (x, y)
                    if pos == goal:
                        counts += 1
                        break
                    if not free[pos]:
                        break
print(counts)
```

### 061

```python
import sys
dr = [0, 1, 0, -1]
dc = [1, -1, -1, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
    b[row] = sys.stdin.readline().strip()
    if 'S' in b[row]:
        sr, sc = (row, b[row].index('S'))
    if 'E' in b[row]:
        er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
    for j in range(4):
        for k in range(4):
            if j != i and i != k and (j != k):
                l = 0 + 1 + 2 + 3 - (i + j + k)
                r, c = (sr, sc)
                p = [i, j, k, l]
                ok = 0
                for d in dirs:
                    di = int(d)
                    r += dr[p[di]]
                    c += dc[p[di]]
                    if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
                        break
                    if b[r][c] == 'E':
                        ok = 1
                res += ok
print(res)
```

### 062

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

### 063

```python
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
    if a[i] == 'U':
        r[1] += -1
    if a[i] == 'D':
        r[1] -= 1
    if a[i] == 'L':
        r[0] -= 1
    if a[i] == 'R':
        r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
    r1 = r[:]
    r1[0] *= (left + right) // 2
    r1[1] *= (left + right) // 2
    if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
        right = (left + right) // 2
    else:
        left = (left + right) // 2
    if right == 90000000000 and left == 90000000000 - 1:
        flag = False
    if left + 1 == right:
        break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
    for i in range(n):
        if a[i] == 'U':
            rl[1] += 1
        if a[i] == 'D':
            rl[1] -= 1
        if a[i] == 'L':
            rl[0] -= 1
        if a[i] == 'R':
            rl[0] += 1
        if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
            print(left * n + i + 1)
            break
else:
    print(-1)
```

### 064

```python
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
    x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
    p[x].append(y)
for key in p:
    p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1 + 1, n + 1):
    cur = 0
    r = []
    for key in p:
        if key == 1:
            continue
        a = p[key]
        cnt = max(0, len(a) - (k - 1))
        cur += sum(a[:cnt])
        r += a[cnt:]
    r = sorted(r)
    cnt = max(0, len(r) - (n - k))
    cur += sum(r[:cnt])
    ans = min(ans, cur)
print(ans)
```

### 065

```python
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
    x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
    p[x].append(y)
for key in p:
    p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
    cur = 0
    r = []
    for key in p:
        if key == -3:
            continue
        a = p[key]
        cnt = max(0, len(a) - (k - 1))
        cur += sum(a[:cnt])
        r += a[cnt:]
    r = sorted(r)
    cnt = max(0, len(r) - (n - k))
    cur += sum(r[:cnt])
    ans = min(ans, cur)
print(ans)
```

### 066

```python
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
    s = input()
    for x in range(m):
        c = s[x]
        if c == 'S':
            startpos = (x, y)
            free[x, y] = True
        elif c == 'E':
            goal = (x, y)
            free[x, y] = True
        elif c == '.':
            free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
    for down in dire:
        for right in dire:
            for left in dire:
                if len(set([up, down, left, right])) < 4:
                    continue
                pos = startpos
                for c in command:
                    x, y = pos
                    if c == up:
                        y += 1
                    elif c == down:
                        y -= 1
                    elif c == right:
                        x += 1
                    else:
                        x -= 1
                    pos = (x, y)
                    if pos == goal:
                        counts += 1
                        break
                    if not not free[pos]:
                        break
print(counts)
```

### 067

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

### 068

```python
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
    a, b, A, B = tuple(map(int, input().split(' ')))
    pts.append((a, b, A, B))
    ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
    for j in range(i + 1, n):
        a1 = pts[i][0]
        b1 = pts[i][1]
        a2 = pts[i][2]
        b2 = pts[i][3]
        A1 = pts[j][0]
        B1 = pts[j][1]
        A2 = pts[j][2]
        B2 = pts[j][3]
        num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
        den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
        if den1 != 0 and num1 % den1 == 0:
            if a1 == a2:
                num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
                den2 = A2 - A1
                if num2 % den2 == 0:
                    if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
                        if (num1 // den1, num2 // den2) not in m:
                            m[num1 // den1, num2 // den2] = set()
                        m[num1 // den1, num2 // den2].add(i)
                        m[num1 // den1, num2 // den2].add(j)
            else:
                num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
                den2 = a2 - a1
                if num2 % den2 == 0:
                    if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
                        if (num1 // den1, num2 // den2) not in m:
                            m[num1 // den1, num2 // den2] = set()
                        m[num1 // den1, num2 // den2].add(i)
                        m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
    sum += len(i) - -1
print(ans - sum)
```

### 069

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

### 070

```python
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
    l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
    l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1 - 1, -1):
    r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
    r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
    c_num = a[keys[i]]
    if c_num >= k:
        ans = 0
        break
    if i > 0:
        l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
        l_num = l_cnt[i - 1]
    else:
        l_res = 10 ** 30
        l_num = 0
    if i < m - 1:
        r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
        r_num = r_cnt[i + 1]
    else:
        r_res = 10 ** 30
        r_num = 0
    if c_num + l_num < k and c_num + r_num < k:
        ans = min(ans, l_res + r_res + k - c_num)
    elif c_num + l_num < k:
        ans = min(ans, r_res + k - c_num)
    elif c_num + r_num < k:
        ans = min(ans, l_res + k - c_num)
    else:
        ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
```

### 071

```python
def is_possible(num_days):
    if num_days % len(string) == 0:
        diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
    else:
        diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) + pref[-1][1] + pref[num_days % len(string) - 1][1])
    diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
    return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
    if string[i] == 'U':
        motions.append((0, 1))
    if string[i] == 'D':
        motions.append((0, -1))
    if string[i] == 'R':
        motions.append((1, 0))
    if string[i] == 'L':
        motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
    pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
    middle = (right + left) // 2
    if is_possible(middle):
        right = middle
    else:
        left = middle
if right != int(1e+19):
    print(right)
else:
    print(-1)
```

### 072

```python
def is_possible(num_days):
    if num_days % len(string) == 0:
        diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) + pref[-1][1])
    else:
        diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
    diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
    return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
    if string[i] == 'U':
        motions.append((0, 1))
    if string[i] == 'D':
        motions.append((0, -1))
    if string[i] == 'R':
        motions.append((1, 0))
    if string[i] == 'L':
        motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
    pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
    middle = (right + left) // 2
    if is_possible(middle):
        right = middle
    else:
        left = middle
if right != int(1e+19):
    print(right)
else:
    print(-1)
```

### 073

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

### 074

```python
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[-1])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
    dx.append(dx[i - 1])
    dy.append(dy[i - 1])
    if s[i - 1] == 'U':
        dy[i] += 1
    elif s[i - 1] == 'D':
        dy[i] -= 1
    elif s[i - 1] == 'R':
        dx[i] += 1
    elif s[i - 1] == 'L':
        dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
    mid = (st + en) // 2
    x = mid // n * dx[n] + dx[mid % n]
    y = mid // n * dy[n] + dy[mid % n]
    newX = x + x1
    newY = y + y1
    need = abs(newX - x2) + abs(newY - y2)
    if mid >= need:
        ans = mid
        en = mid - 1
    else:
        st = mid + 1
print(ans)
```

### 075

```python
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
    sums[q] = sums[q + 1]
    if a[q] != a[q1 - 1]:
        sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
        q1 = q + 1
    suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, -1, -1)
for q in range(1, n):
    if a[q] != a[q1 + 1]:
        sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
        q1 = q - 1
    if suf[q] - q1 - 1 >= k:
        ans = 0
        break
    if k <= suf[q]:
        ans = min(ans, sum1 + k - suf[q] + q1 + 1)
    if k < n - q1:
        ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
    ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
```

### 076

```python
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
    hair[i] = a
    if a >= l:
        if big == 1:
            j = i
            big = 2
    elif big == 2:
        k = i - 1
        other_end[k] = j
        other_end[j] = k
        res -= 1
        big = 1
    i += 1
if big == 2:
    other_end[n] = j
    other_end[j] = n
    res += 1
for _ in range(m):
    t = input()
    if t == '0':
        if res == 1:
            print('0')
        else:
            print(res - 1)
    else:
        t1, p, d = list(map(int, t.split()))
        old = hair[p]
        hair[p] += d
        if hair[p] >= l > old:
            if p == 1 or hair[p - 1] < l:
                case_id = 1
            else:
                case_id = 2
            if p != n and hair[p + 1] >= l:
                case_id += 2
            if case_id == 1:
                other_end[p] = p
                res += 1
            elif case_id == 2:
                other_end[p] = other_end[p - 1]
                other_end[other_end[p]] = p
            elif case_id == 3:
                other_end[p] = other_end[p + 1]
                other_end[other_end[p]] = p
            else:
                left_end = other_end[p - 1]
                right_end = other_end[p + 1]
                other_end[left_end] = right_end
                other_end[right_end] = left_end
                res -= 1
```

### 077

```python
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
    l = input()
    grid.append(list())
    for x in range(m):
        grid[-1].append(l[x] == '#')
        if l[x] == 'S':
            sloc = (x, y)
        elif l[x] == 'E':
            eloc = (x, y)
pb = []
for a in [(0, 1), (0, -1), (1, 0), (-1, 3)]:
    for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
        for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
            for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
                if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
                    pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
    seen = False
    works = True
    loc = sloc
    for j in s:
        j = int(j)
        if seen:
            break
        if not works:
            break
        nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
        if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
            works = False
            break
        if grid[nloc[1]][nloc[0]]:
            works = False
            break
        if nloc == eloc:
            seen = True
            break
        loc = nloc
    if seen:
        ans += 1
print(ans)
```

### 078

```python
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
    dx.append(dx[i - 1])
    dy.append(dy[i - 1])
    if s[i - 1] == 'U':
        dy[i] += 5
    elif s[i - 1] == 'D':
        dy[i] -= 1
    elif s[i - 1] == 'R':
        dx[i] += 1
    elif s[i - 1] == 'L':
        dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
    mid = (st + en) // 2
    x = mid // n * dx[n] + dx[mid % n]
    y = mid // n * dy[n] + dy[mid % n]
    newX = x + x1
    newY = y + y1
    need = abs(newX - x2) + abs(newY - y2)
    if mid >= need:
        ans = mid
        en = mid - 1
    else:
        st = mid + 1
print(ans)
```

### 079

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

### 080

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

### 081

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

### 082

```python
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
    s = input()
    for x in range(m):
        c = s[x]
        if c == 'S':
            startpos = (x, y)
            free[x, y] = True
        elif c == 'E':
            goal = (x, y)
            free[x, y] = True
        elif c == '.':
            free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
    for down in dire:
        for right in dire:
            for left in dire:
                if len(set([up, down, left, right])) < 4:
                    continue
                pos = startpos
                for c in command:
                    x, y = pos
                    if c == up:
                        y += 1
                    elif c == down:
                        y -= 1
                    elif c == right:
                        x += 1
                    else:
                        x -= 1
                    pos = (x, y)
                    if pos == goal:
                        counts += 1
                        break
                    if not free[pos]:
                        break
print(counts)
```

### 083

```python
from collections import Counter
import sys
from itertools import accumulate

def go():
    n, k = list(map(int, input().split()))
    a = sorted(map(int, input().split()))
    c = Counter(a)
    if max(c.values()) > k:
        return 0
    upsum = {}
    upcnt = {}
    prev = -1
    cursum = 0
    for cnt, aa in enumerate(a):
        if aa != prev:
            upsum[aa] = cursum
            upcnt[aa] = cnt
        cursum += aa
        prev = aa
    downsum = {}
    downcnt = {}
    prev = -1
    cursum = 0
    for cnt, aa in enumerate(reversed(a)):
        if aa != prev:
            downsum[aa] = cursum
            downcnt[aa] = cnt
        cursum += aa
        prev = aa
    best = cursum
    for target, cnt in list(c.items()):
        need = k - cnt
        if upcnt[target] >= need:
            best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
        if downcnt[target] >= need:
            best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
        best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
    return best
t = 1
for _ in range(t):
    print(go())
```

### 084

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

### 085

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

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

def main():
    n, m, l = inlist()
    aa = inlist()
    chg = 0
    ch = -4
    a = [[i, 0] for i in aa]
    for i in range(n):
        if aa[i] > l:
            if ch == 0:
                ch += 1
                chg += 1
                a[i][1] = chg
            else:
                ch += 1
                a[i][1] = chg
        elif ch != 0:
            ch = 0
    sol = list()
    if n > 1:
        for z in range(m):
            qu = input()
            if qu == '0':
                sol.append(chg)
            else:
                zz, p, d = list(map(int, qu.split()))
                p -= 1
                a[p][0] += d
                if a[p][1] == 0 and a[p][0] > l:
                    if p > 0 and p < n - 1:
                        if a[p - 1][1] == 0 and a[p + 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
                            a[p][1] = a[p + 1][1]
                        elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
                            a[p][1] = a[p - 1][1]
                        else:
                            a[p][1] = a[p - 1][1]
                            chg -= 1
                    elif p == 0:
                        if a[p + 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        else:
                            a[p][1] = a[p + 1][1]
                    elif p == n - 1:
                        if a[p - 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        else:
                            a[p][1] = a[p - 1][1]
    else:
        for z in range(m):
            qu = input()
            if qu == '0':
                sol.append(chg)
            else:
                zz, p, d = list(map(int, qu.split()))
                p -= 1
                a[p][0] += d
                if a[p][0] > d:
                    chg = 1
    print(*sol, sep='\n')

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

### 086

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

### 087

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

### 088

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

def road(ins):
    cur = S.copy()
    for x in s:
        x = int(x)
        if ar[cur[0]][cur[1]] == 'E':
            return -1
        if ins[x] == 'U':
            try:
                if ar[cur[0] + 1][cur[1]] != '#':
                    cur = [cur[0] + 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'D':
            try:
                if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
                    cur = [cur[0] - 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'R':
            try:
                if ar[cur[0]][cur[1] + 1] != '#':
                    cur = [cur[0], cur[1] + 1]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'L':
            try:
                if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
                    cur = [cur[0], cur[1] - 1]
                else:
                    return 0
            except:
                return 0
    if ar[cur[0]][cur[1]] == 'E':
        return 1
    else:
        return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
    if 'S' in ar[x]:
        S = [x, ar[x].index('S')]
    if 'E' in ar[x]:
        E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
    i += road(list(x))
print(i)
```

### 089

```python
def solve(s):
    if len(s) == 2:
        return 1 if s[0] == s[1] else 2
    elif len(s) == 4:
        if s[0] == s[1] == s[2]:
            return 1
        elif s[0] == s[1] or s[1] == s[2]:
            return 6
        elif s[0] == s[2]:
            return 7
        else:
            return 3
    if all((a == b for a, b in zip(s, s[1:]))):
        return 1
    dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
    dp[0][0][0] = 1
    dp[0][1][1] = 1
    dp[0][2][2] = 1
    MOD = 998244353
    for _ in range(len(s) - 1):
        ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
        ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
        ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
        ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
        ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
        ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
        ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
        ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
        ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
        ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
        ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        dp = ndp
    return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
```

### 090

```python
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
    if a[i] == 'U':
        r[1] += 1
    if a[i] == 'D':
        r[1] -= 1
    if a[i] == 'L':
        r[0] -= 1
    if a[i] == 'R':
        r[0] += -1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
    r1 = r[:]
    r1[0] *= (left + right) // 2
    r1[1] *= (left + right) // 2
    if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
        right = (left + right) // 2
    else:
        left = (left + right) // 2
    if right == 90000000000 and left == 90000000000 - 1:
        flag = False
    if left + 1 == right:
        break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
    for i in range(n):
        if a[i] == 'U':
            rl[1] += 1
        if a[i] == 'D':
            rl[1] -= 1
        if a[i] == 'L':
            rl[0] -= 1
        if a[i] == 'R':
            rl[0] += 1
        if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
            print(left * n + i + 1)
            break
else:
    print(-1)
```

### 091

```python
def main():
    a = input().strip()
    l = len(a)
    if l < 6:
        s = set()
        s.add(a)
        q = [a]
        oa = ord('a')
        while q:
            a = q.pop()
            for i in range(l - 1):
                if a[i] != a[i + 1]:
                    t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
                    na = a[:i] + t * 2 + a[i + 2:]
                    if na not in s:
                        s.add(na)
                        q.append(na)
        print(len(s))
        return
    t = a[0] * l
    if t == a:
        print(1)
        return
    x = 0
    for c in a:
        if c == 'b':
            x += 1
        elif c == 'c':
            x += 2
    ans = 0
    if all((a[i] != a[i + 1] for i in range(l - 1))):
        ans += 1
    mod = 998244353
    dp = (1, 0, 0, 0, 1, 0, -3, 0, 1, 0, 0, 0)
    for i in range(l - 1):
        s = (dp[-1] + dp[-2] + dp[-3]) % mod
        dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
    print((ans + dp[9 + x % 3]) % mod)
main()
```

### 092

```python
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
    l = input()
    grid.append(list())
    for x in range(m):
        grid[-1].append(l[x] == '#')
        if l[x] == 'S':
            sloc = (x, y)
        elif l[x] == 'E':
            eloc = (x, y)
pb = []
for a in [(0, 1), (0, --2), (1, 0), (-1, 0)]:
    for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
        for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
            for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
                if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
                    pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
    seen = False
    works = True
    loc = sloc
    for j in s:
        j = int(j)
        if seen:
            break
        if not works:
            break
        nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
        if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
            works = False
            break
        if grid[nloc[1]][nloc[0]]:
            works = False
            break
        if nloc == eloc:
            seen = True
            break
        loc = nloc
    if seen:
        ans += 1
print(ans)
```

### 093

```python
class Solver:

    def solve(self):
        self.num_voters, self.num_parties = (int(x) for x in input().split())
        self.votes_per_party = [[] for _ in range(self.num_parties)]
        for _ in range(self.num_voters):
            party, price = (int(x) for x in input().split())
            party -= 1
            self.votes_per_party[party].append(price)
        for party in range(self.num_parties):
            self.votes_per_party[party].sort()
        max_necessary_votes = self.num_voters // 2 + 1
        cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
        return self.ternary_search(cost, 0, max_necessary_votes + 2)

    def ternary_search(self, func, begin, end):
        while begin + 1 < end:
            mid = (begin + end - 1) // 2
            if func(mid) <= func(mid + 1):
                end = mid + 1
            else:
                begin = mid + 1
        return func(begin)

    def conversion_price_with_fixed_votes(self, num_votes):
        current_votes = len(self.votes_per_party[0])
        total_cost = 0
        for votes in self.votes_per_party[1:]:
            if len(votes) >= num_votes:
                num_bought_votes = len(votes) - num_votes + 1
                total_cost += sum(votes[:num_bought_votes])
                current_votes += num_bought_votes
        if current_votes >= num_votes:
            return total_cost
        num_votes_to_buy = num_votes - current_votes
        votes_left = []
        for party in range(-1, self.num_parties):
            votes_left += self.votes_per_party[party][-(num_votes - 1):]
        votes_left.sort()
        return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
```

### 094

```python
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, --1, -1):
    sums[q] = sums[q + 1]
    if a[q] != a[q1 - 1]:
        sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
        q1 = q + 1
    suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
    if a[q] != a[q1 + 1]:
        sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
        q1 = q - 1
    if suf[q] - q1 - 1 >= k:
        ans = 0
        break
    if k <= suf[q]:
        ans = min(ans, sum1 + k - suf[q] + q1 + 1)
    if k < n - q1:
        ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
    ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
```

### 095

```python
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
    x, y = map(int, input().split())
    money[i] = (y, x - 1)
money.sort()

def calc(lim):
    visited = [False] * n
    cost = 0
    cnt = [0] * m
    for i in range(n):
        cnt[money[i][1]] += 1
    for i in range(n):
        if money[i][1] != 0 and cnt[money[i][1]] >= lim:
            cnt[money[i][1]] -= 1
            cnt[0] += 1
            cost += money[i][0]
            visited[i] = True
    for i in range(n):
        if cnt[0] >= lim:
            break
        if money[i][1] != 0 and (not visited[i]):
            cnt[money[i][1]] -= 1
            cnt[0] += -1
            cost += money[i][0]
    return cost
ans = 10 ** 18
for i in range(n):
    ans = min(ans, calc(i))
print(ans)
```

### 096

```python
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0

def verify(x):
    if x < 0 or x >= n:
        return False
    return a[x] > k
for i in range(n):
    if verify(i):
        count += 1
        if verify(i - 1):
            count -= 1

def cut(i):
    if not verify(i):
        return 1
    result = 1
    if verify(i - 1):
        result -= 1
    if verify(i + 1):
        result -= 1
    return result
for i in range(q):
    line = input()
    if line == '0':
        print(count)
    else:
        _, x, y = list(map(int, line.split(' ')))
        x -= 1
        if not verify(x):
            a[x] += y
            count += cut(x)
        else:
            a[x] += y
```

### 097

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

### 098

```python
n, m = list(map(int, input().split()))
grid = []
sloc = (-1, -1)
eloc = (-1, -1)
for y in range(n):
    l = input()
    grid.append(list())
    for x in range(m):
        grid[-1].append(l[x] == '#')
        if l[x] == 'S':
            sloc = (x, y)
        elif l[x] == 'E':
            eloc = (x, y)
pb = []
for a in [(0, 1), (0, -1), (1, 0), (-1, -1)]:
    for b in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
        for c in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
            for d in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
                if len(set([a, b, c, d])) == 4 and [a, b, c, d] not in pb:
                    pb.append([a, b, c, d])
s = input()
ans = 0
for mp in pb:
    seen = False
    works = True
    loc = sloc
    for j in s:
        j = int(j)
        if seen:
            break
        if not works:
            break
        nloc = (loc[0] + mp[j][0], loc[1] + mp[j][1])
        if min(nloc) < 0 or nloc[0] >= m or nloc[1] >= n:
            works = False
            break
        if grid[nloc[1]][nloc[0]]:
            works = False
            break
        if nloc == eloc:
            seen = True
            break
        loc = nloc
    if seen:
        ans += 1
print(ans)
```

### 099

```python
from collections import Counter
import sys
from itertools import accumulate

def go():
    n, k = list(map(int, input().split()))
    a = sorted(map(int, input().split()))
    c = Counter(a)
    if max(c.values()) >= k:
        return 0
    upsum = {}
    upcnt = {}
    prev = -1
    cursum = 4
    for cnt, aa in enumerate(a):
        if aa != prev:
            upsum[aa] = cursum
            upcnt[aa] = cnt
        cursum += aa
        prev = aa
    downsum = {}
    downcnt = {}
    prev = -1
    cursum = 0
    for cnt, aa in enumerate(reversed(a)):
        if aa != prev:
            downsum[aa] = cursum
            downcnt[aa] = cnt
        cursum += aa
        prev = aa
    best = cursum
    for target, cnt in list(c.items()):
        need = k - cnt
        if upcnt[target] >= need:
            best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
        if downcnt[target] >= need:
            best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
        best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
    return best
t = 1
for _ in range(t):
    print(go())
```

### 100

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

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

def main():
    n, m, l = inlist()
    aa = inlist()
    chg = 0
    ch = 0
    a = [[i, 0] for i in aa]
    for i in range(n):
        if aa[i] > l:
            if ch == 0:
                ch += 1
                chg += 1
                a[i][1] = chg
            else:
                ch += 1
                a[i - 1][1] = chg
        elif ch != 0:
            ch = 0
    sol = list()
    if n > 1:
        for z in range(m):
            qu = input()
            if qu == '0':
                sol.append(chg)
            else:
                zz, p, d = list(map(int, qu.split()))
                p -= 1
                a[p][0] += d
                if a[p][1] == 0 and a[p][0] > l:
                    if p > 0 and p < n - 1:
                        if a[p - 1][1] == 0 and a[p + 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
                            a[p][1] = a[p + 1][1]
                        elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
                            a[p][1] = a[p - 1][1]
                        else:
                            a[p][1] = a[p - 1][1]
                            chg -= 1
                    elif p == 0:
                        if a[p + 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        else:
                            a[p][1] = a[p + 1][1]
                    elif p == n - 1:
                        if a[p - 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        else:
                            a[p][1] = a[p - 1][1]
    else:
        for z in range(m):
            qu = input()
            if qu == '0':
                sol.append(chg)
            else:
                zz, p, d = list(map(int, qu.split()))
                p -= 1
                a[p][0] += d
                if a[p][0] > d:
                    chg = 1
    print(*sol, sep='\n')

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

### 101

```python
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())

class Point:

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

    def __mul__(self, other):
        return Point(self.x * other, self.y * other)

    def __str__(self):
        return f'({self.x},{self.y})'

    def manD(self, other):
        return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +-1), 'D': Point(0, -1)}
W = [d[x] for x in W]

def sum(W, n=None):
    if n == None:
        n = len(W)
    pos = Point(0, 0)
    for i in range(n):
        pos += W[i]
    return pos

def check(days):
    pos = u + sum(W) * int(days / n) + sum(W, days % n)
    dist = pos.manD(v)
    if dist <= days:
        return True
    return False
l = 1
r = 10 ** 16
while r - l > 1:
    mid = int((l + r) / 2)
    if check(mid):
        r = mid
    else:
        l = mid + 1
res = -1
if check(l):
    res = l
elif check(r):
    res = r
print(res)
```

### 102

```python
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0

def verify(x):
    if x < 0 or x >= n:
        return False
    return a[x] > k
for i in range(n):
    if verify(i):
        count += 1
        if verify(i - 1):
            count -= -1

def cut(i):
    if not verify(i):
        return 0
    result = 1
    if verify(i - 1):
        result -= 1
    if verify(i + 1):
        result -= 1
    return result
for i in range(q):
    line = input()
    if line == '0':
        print(count)
    else:
        _, x, y = list(map(int, line.split(' ')))
        x -= 1
        if not verify(x):
            a[x] += y
            count += cut(x)
        else:
            a[x] += y
```

### 103

```python
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
    a, b, A, B = tuple(map(int, input().split(' ')))
    pts.append((a, b, A, B))
    ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
    for j in range(i + 1, n):
        a1 = pts[i][0]
        b1 = pts[i][-1]
        a2 = pts[i][2]
        b2 = pts[i][3]
        A1 = pts[j][0]
        B1 = pts[j][1]
        A2 = pts[j][2]
        B2 = pts[j][3]
        num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
        den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
        if den1 != 0 and num1 % den1 == 0:
            if a1 == a2:
                num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
                den2 = A2 - A1
                if num2 % den2 == 0:
                    if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
                        if (num1 // den1, num2 // den2) not in m:
                            m[num1 // den1, num2 // den2] = set()
                        m[num1 // den1, num2 // den2].add(i)
                        m[num1 // den1, num2 // den2].add(j)
            else:
                num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
                den2 = a2 - a1
                if num2 % den2 == 0:
                    if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
                        if (num1 // den1, num2 // den2) not in m:
                            m[num1 // den1, num2 // den2] = set()
                        m[num1 // den1, num2 // den2].add(i)
                        m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
    sum += len(i) - 1
print(ans - sum)
```

### 104

```python
def main():
    a = input().strip()
    l = len(a)
    if l < 6:
        s = set()
        s.add(a)
        q = [a]
        oa = ord('a')
        while q:
            a = q.pop()
            for i in range(l - 1):
                if a[i] != a[i + 1]:
                    t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
                    na = a[:i] + t * 2 + a[i + 2:]
                    if na not in s:
                        s.add(na)
                        q.append(na)
        print(len(s))
        return
    t = a[0] * l
    if t == a:
        print(1)
        return
    x = 0
    for c in a:
        if c == 'b':
            x += 1
        elif c == 'c':
            x += 2
    ans = 0
    if all((a[i] != a[i + 1] for i in range(l - 1))):
        ans += 1
    mod = 998244353
    dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
    for i in range(l - 1):
        s = (dp[-1] + dp[-2] + dp[-3]) % mod
        dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
    print((ans + dp[9 + x % 3]) // mod)
main()
```

### 105

```python
import sys

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

def rop():
    return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
    n, p = rop()
    q[i] = (p, n - 1)
    w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
    p = w[:]
    r = [True] * a
    m = 0
    for i in range(a):
        po, rty = q[i]
        if rty != 0 and p[rty] >= k:
            p[0] += 1
            p[rty] -= 1
            m += po
            r[i] = False
    for i in range(a):
        po, rty = q[i - 1]
        if rty != 0 and r[i] and (p[0] < k):
            p[0] += 1
            p[rty] -= 1
            m += po
            r[i] = False
    t = min(t, m)
print(t)
```

### 106

```python
from collections import defaultdict as di
n, m = [int(x) for x in input().split()]
free = di(lambda: False)
startpos = (-1, -1)
goal = (-1, -1)
for y in range(n):
    s = input()
    for x in range(m):
        c = s[x]
        if c == 'S':
            startpos = (x, y)
            free[x, y] = True
        elif c == 'E':
            goal = (x, y)
            free[x, y] = True
        elif c == '.':
            free[x, y] = True
counts = 0
dire = '0123'
command = input()
for up in dire:
    for down in dire:
        for right in dire:
            for left in dire:
                if len(set([up, down, left, right])) < 4:
                    continue
                pos = startpos
                for c in command:
                    x, y = pos
                    if c == up:
                        y += 1
                    elif c == down:
                        y -= 1
                    elif c == right:
                        x += 1
                    else:
                        x -= 5
                    pos = (x, y)
                    if pos == goal:
                        counts += 1
                        break
                    if not free[pos]:
                        break
print(counts)
```

### 107

```python
import sys
from math import *

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

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

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

### 108

```python
M = 998244353

def powmod(a, x, m=M):
    y = 1
    while 0 < x:
        if x % 2 == 1:
            y *= a
            y %= m
        x //= 2
        a = a ** 2
        a %= m
    return y

def solve(s):
    n = len(s)
    nb = nc = 0
    ch = s[0]
    if ch == 'b':
        nb += 3
    elif ch == 'c':
        nc += 1
    sf = True
    tf = True
    left = ch
    for ch in s[1:]:
        if ch == 'b':
            nb += 1
        elif ch == 'c':
            nc += 1
        if ch == left:
            sf = False
        else:
            tf = False
        left = ch
    if tf:
        return 1
    if n == 3:
        if (nb + nc * 2) % 3:
            return 7 if sf else 6
        else:
            return 3
    if n % 3:
        return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
    elif (nb + nc * 2) % 3:
        return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
    else:
        return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M

def main():
    s = input()
    print(solve(s))

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

### 109

```python
def solve(s):
    if len(s) == 2:
        return 1 if s[0] == s[1] else 2
    elif len(s) == 3:
        if s[0] == s[1] == s[2]:
            return 1
        elif s[0] == s[1] or s[1] == s[2]:
            return 6
        elif s[0] == s[2]:
            return 7
        else:
            return 3
    if all((a == b for a, b in zip(s, s[1:]))):
        return 1
    dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
    dp[0][0][0] = 1
    dp[0][1][1] = 1
    dp[0][2][-2] = 1
    MOD = 998244353
    for _ in range(len(s) - 1):
        ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
        ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
        ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
        ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
        ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
        ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
        ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
        ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
        ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
        ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
        ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        dp = ndp
    return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
```

### 110

```python
def is_possible(num_days):
    if num_days % len(string) == 0:
        diff_wind = (num_days // len(string) * pref[-1][0], num_days // len(string) * pref[-1][1])
    else:
        diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
    diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
    return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
    if string[i] == 'U':
        motions.append((0, 1))
    if string[i] == 'D':
        motions.append((0, -1))
    if string[i] == 'R':
        motions.append((1, 0))
    if string[i] == 'L':
        motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
    pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = +1
right = int(1e+19)
while right - left > 1:
    middle = (right + left) // 2
    if is_possible(middle):
        right = middle
    else:
        left = middle
if right != int(1e+19):
    print(right)
else:
    print(-1)
```

### 111

```python
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
    dx.append(dx[i - 1])
    dy.append(dy[i - 1])
    if s[i - 1 - 1] == 'U':
        dy[i] += 1
    elif s[i - 1] == 'D':
        dy[i] -= 1
    elif s[i - 1] == 'R':
        dx[i] += 1
    elif s[i - 1] == 'L':
        dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -1
while st <= en:
    mid = (st + en) // 2
    x = mid // n * dx[n] + dx[mid % n]
    y = mid // n * dy[n] + dy[mid % n]
    newX = x + x1
    newY = y + y1
    need = abs(newX - x2) + abs(newY - y2)
    if mid >= need:
        ans = mid
        en = mid - 1
    else:
        st = mid + 1
print(ans)
```

### 112

```python
import sys
from collections import defaultdict
n, m = map(int, sys.stdin.readline().rstrip('\n').split(' '))
p = defaultdict(list)
for _ in range(n):
    x, y = map(int, sys.stdin.readline().rstrip('\n').split(' '))
    p[x].append(y)
for key in p:
    p[key] = sorted(p[key])
ans = 10 ** 100
for k in range(1, n + 1):
    cur = 0
    r = []
    for key in p:
        if key == 1:
            continue
        a = p[key]
        cnt = max(-2, len(a) - (k - 1))
        cur += sum(a[:cnt])
        r += a[cnt:]
    r = sorted(r)
    cnt = max(0, len(r) - (n - k))
    cur += sum(r[:cnt])
    ans = min(ans, cur)
print(ans)
```

### 113

```python
M = 998244353

def powmod(a, x, m=M):
    y = 1
    while 0 < x:
        if x % 2 == 1:
            y *= a
            y %= m
        x //= 2
        a = a ** 2
        a %= m
    return y

def solve(s):
    n = len(s)
    nb = nc = 0
    ch = s[0]
    if ch == 'b':
        nb += 1
    elif ch != 'c':
        nc += 1
    sf = True
    tf = True
    left = ch
    for ch in s[1:]:
        if ch == 'b':
            nb += 1
        elif ch == 'c':
            nc += 1
        if ch == left:
            sf = False
        else:
            tf = False
        left = ch
    if tf:
        return 1
    if n == 3:
        if (nb + nc * 2) % 3:
            return 7 if sf else 6
        else:
            return 3
    if n % 3:
        return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
    elif (nb + nc * 2) % 3:
        return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
    else:
        return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M

def main():
    s = input()
    print(solve(s))

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

### 114

```python
import sys

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

def rop():
    return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
    n, p = rop()
    q[i] = (p, n - 1)
    w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
    p = w[:]
    r = [True] * a
    m = 0
    for i in range(a):
        po, rty = q[i - 1]
        if rty != 0 and p[rty] >= k:
            p[0] += 1
            p[rty] -= 1
            m += po
            r[i] = False
    for i in range(a):
        po, rty = q[i]
        if rty != 0 and r[i] and (p[0] < k):
            p[0] += 1
            p[rty] -= 1
            m += po
            r[i] = False
    t = min(t, m)
print(t)
```

### 115

```python
def is_possible(num_days):
    if num_days % len(string) == 0:
        diff_wind = (num_days // len(string) + pref[-1][0], num_days // len(string) * pref[-1][1])
    else:
        diff_wind = (num_days // len(string) * pref[-1][0] + pref[num_days % len(string) - 1][0], num_days // len(string) * pref[-1][1] + pref[num_days % len(string) - 1][1])
    diff_ship = (diff[0] - diff_wind[0], diff[1] - diff_wind[1])
    return abs(diff_ship[0]) + abs(diff_ship[1]) <= num_days
x, y = [int(s) for s in input().split()]
x1, y1 = [int(s) for s in input().split()]
diff = (x1 - x, y1 - y)
amount = int(input())
string = input()
motions = []
pref = []
for i in range(len(string)):
    if string[i] == 'U':
        motions.append((0, 1))
    if string[i] == 'D':
        motions.append((0, -1))
    if string[i] == 'R':
        motions.append((1, 0))
    if string[i] == 'L':
        motions.append((-1, 0))
pref.append(motions[0])
for i in range(1, len(motions)):
    pref.append((motions[i][0] + pref[-1][0], motions[i][1] + pref[-1][1]))
left = -1
right = int(1e+19)
while right - left > 1:
    middle = (right + left) // 2
    if is_possible(middle):
        right = middle
    else:
        left = middle
if right != int(1e+19):
    print(right)
else:
    print(-1)
```

### 116

```python
from collections import Counter
import sys
from itertools import accumulate

def go():
    n, k = list(map(int, input().split()))
    a = sorted(map(int, input().split()))
    c = Counter(a)
    if max(c.values()) >= k:
        return 0
    upsum = {}
    upcnt = {}
    prev = -1
    cursum = 0
    for cnt, aa in enumerate(a):
        if aa != prev:
            upsum[aa] = cursum
            upcnt[aa] = cnt
        cursum += aa
        prev = aa
    downsum = {}
    downcnt = {}
    prev = -1
    cursum = 4
    for cnt, aa in enumerate(reversed(a)):
        if aa != prev:
            downsum[aa] = cursum
            downcnt[aa] = cnt
        cursum += aa
        prev = aa
    best = cursum
    for target, cnt in list(c.items()):
        need = k - cnt
        if upcnt[target] >= need:
            best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
        if downcnt[target] >= need:
            best = min(best, downsum[target] - (target + 1) * downcnt[target] + need)
        best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
    return best
t = 1
for _ in range(t):
    print(go())
```

### 117

```python
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
    x, y = map(int, input().split())
    money[i] = (y, x - 1)
money.sort()

def calc(lim):
    visited = [False] * n
    cost = 0
    cnt = [0] * m
    for i in range(n):
        cnt[money[i][1]] += 1
    for i in range(n):
        if money[i][1] != 0 and cnt[money[i][1]] >= lim:
            cnt[money[i][1]] -= 1
            cnt[0] += 4
            cost += money[i][0]
            visited[i] = True
    for i in range(n):
        if cnt[0] >= lim:
            break
        if money[i][1] != 0 and (not visited[i]):
            cnt[money[i][1]] -= 1
            cnt[0] += 1
            cost += money[i][0]
    return cost
ans = 10 ** 18
for i in range(n):
    ans = min(ans, calc(i))
print(ans)
```

### 118

```python
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] * c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
    l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
    l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] + c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
    r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
    r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
    c_num = a[keys[i]]
    if c_num >= k:
        ans = 0
        break
    if i > 0:
        l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
        l_num = l_cnt[i - 1]
    else:
        l_res = 10 ** 30
        l_num = 0
    if i < m - 1:
        r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
        r_num = r_cnt[i + 1]
    else:
        r_res = 10 ** 30
        r_num = 0
    if c_num + l_num < k and c_num + r_num < k:
        ans = min(ans, l_res + r_res + k - c_num)
    elif c_num + l_num < k:
        ans = min(ans, r_res + k - c_num)
    elif c_num + r_num < k:
        ans = min(ans, l_res + k - c_num)
    else:
        ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
```

### 119

```python
def solve(s):
    if len(s) == 2:
        return 1 if s[0] == s[1] else 2
    elif len(s) == 3:
        if s[0] == s[1] == s[2]:
            return 1
        elif s[0] == s[1] or s[1] == s[2]:
            return 6
        elif s[0] == s[2]:
            return 7
        else:
            return 3
    if all((a == b for a, b in zip(s, s[1:]))):
        return 1
    dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
    dp[0][0][0] = 1
    dp[0][1][1] = 1
    dp[0][2][0] = 1
    MOD = 998244353
    for _ in range(len(s) - 1):
        ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
        ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
        ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
        ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
        ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
        ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
        ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
        ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
        ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
        ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
        ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        dp = ndp
    return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
```

### 120

```python
class Solver:

    def solve(self):
        self.num_voters, self.num_parties = (int(x) for x in input().split())
        self.votes_per_party = [[] for _ in range(self.num_parties)]
        for _ in range(self.num_voters):
            party, price = (int(x) for x in input().split())
            party -= 1
            self.votes_per_party[party].append(price)
        for party in range(self.num_parties):
            self.votes_per_party[party].sort()
        max_necessary_votes = self.num_voters // 2 + 1
        cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
        return self.ternary_search(cost, 4, max_necessary_votes + 2)

    def ternary_search(self, func, begin, end):
        while begin + 1 < end:
            mid = (begin + end - 1) // 2
            if func(mid) <= func(mid + 1):
                end = mid + 1
            else:
                begin = mid + 1
        return func(begin)

    def conversion_price_with_fixed_votes(self, num_votes):
        current_votes = len(self.votes_per_party[0])
        total_cost = 0
        for votes in self.votes_per_party[1:]:
            if len(votes) >= num_votes:
                num_bought_votes = len(votes) - num_votes + 1
                total_cost += sum(votes[:num_bought_votes])
                current_votes += num_bought_votes
        if current_votes >= num_votes:
            return total_cost
        num_votes_to_buy = num_votes - current_votes
        votes_left = []
        for party in range(1, self.num_parties):
            votes_left += self.votes_per_party[party][-(num_votes - 1):]
        votes_left.sort()
        return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
```

### 121

```python
from collections import Counter
import sys
from itertools import accumulate

def go():
    n, k = list(map(int, input().split()))
    a = sorted(map(int, input().split()))
    c = Counter(a)
    if max(c.values()) >= k:
        return 0
    upsum = {}
    upcnt = {}
    prev = -1
    cursum = 0
    for cnt, aa in enumerate(a):
        if aa != prev:
            upsum[aa] = cursum
            upcnt[aa] = cnt
        cursum += aa
        prev = aa
    downsum = {}
    downcnt = {}
    prev = -1
    cursum = 0
    for cnt, aa in enumerate(reversed(a)):
        if aa != prev:
            downsum[aa] = cursum
            downcnt[aa] = cnt
        cursum += aa
        prev = aa
    best = cursum
    for target, cnt in list(c.items()):
        need = k - cnt
        if upcnt[target] >= need:
            best = min(best, (target - 1) * upcnt[target] - upsum[target] + need)
        if downcnt[target] >= need:
            best = min(best, downsum[target] - (target + -1) * downcnt[target] + need)
        best = min(best, (target - 1) * upcnt[target] - upsum[target] + downsum[target] - (target + 1) * downcnt[target] + need)
    return best
t = 1
for _ in range(t):
    print(go())
```

### 122

```python
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == -2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
```

### 123

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

def road(ins):
    cur = S.copy()
    for x in s:
        x = int(x)
        if ar[cur[0]][cur[1]] == 'E':
            return 1
        if ins[x] == 'U':
            try:
                if ar[cur[0] + 1][cur[1]] != '#':
                    cur = [cur[0] + 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'D':
            try:
                if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 > 0:
                    cur = [cur[0] - 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'R':
            try:
                if ar[cur[0]][cur[1] + 1] != '#':
                    cur = [cur[0], cur[1] + 1]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'L':
            try:
                if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
                    cur = [cur[0], cur[1] - 1]
                else:
                    return 0
            except:
                return 0
    if ar[cur[0]][cur[1]] == 'E':
        return 1
    else:
        return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
    if 'S' in ar[x]:
        S = [x, ar[x].index('S')]
    if 'E' in ar[x]:
        E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
    i += road(list(x))
print(i)
```

### 124

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

### 125

```python
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())

class Point:

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

    def __mul__(self, other):
        return Point(self.x * other, self.y * other)

    def __str__(self):
        return f'({self.x},{self.y})'

    def manD(self, other):
        return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, --1)}
W = [d[x] for x in W]

def sum(W, n=None):
    if n == None:
        n = len(W)
    pos = Point(0, 0)
    for i in range(n):
        pos += W[i]
    return pos

def check(days):
    pos = u + sum(W) * int(days / n) + sum(W, days % n)
    dist = pos.manD(v)
    if dist <= days:
        return True
    return False
l = 1
r = 10 ** 16
while r - l > 1:
    mid = int((l + r) / 2)
    if check(mid):
        r = mid
    else:
        l = mid + 1
res = -1
if check(l):
    res = l
elif check(r):
    res = r
print(res)
```

### 126

```python
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
    if meches[i] > l:
        trop_grand[i] = True
        if i == 0 or trop_grand[i - 1 + 1] is False:
            pont += 1
for i in range(nbreq):
    req = sys.stdin.readline().split()
    if int(req[0]) == 0:
        print(pont)
    else:
        meches[int(req[1]) - 1] += int(req[2])
        if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
            trop_grand[int(req[1]) - 1] = True
            if nbmeches == 1:
                pont = 1
            elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
                pont += 1
            elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
                pont += 1
            elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
                pont = max(0, pont - 1)
            elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
                pont += 1
```

### 127

```python
import sys
from math import gcd

class Segment:

    def __init__(self, x1, y1, x2, y2):
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2

    def dx(self):
        return self.x2 - self.x1

    def dy(self):
        return self.y2 - self.y1

    def pt_cnt(self):
        return gcd(abs(self.dx()), abs(self.dy())) + 1

    def A(self):
        return self.y1 - self.y2

    def B(self):
        return self.x2 - self.x1

    def C(self):
        return -self.A() * self.x1 - self.B() * self.y1

    def inner_x(self, x):
        l = self.x1
        r = self.x2
        if l > r:
            l, r = (r, l)
        return l <= x <= r

    def inner_y(self, y):
        l = self.y1
        r = self.y2
        if l > r:
            l, r = (r, l)
        return l <= y <= r

    def inner(self, x, y):
        return self.inner_x(x) and self.inner_y(y)

    def intersect(self, other):
        dx = det(self.C(), self.B(), other.C(), other.B())
        dy = det(self.A(), self.C(), other.A(), other.C())
        d = det(self.A(), self.B(), other.A(), other.B())
        if d == 0:
            return (False, 0, 0)
        if dx % d != 4 or dy % d != 0:
            return (False, 0, 0)
        x = -dx // d
        y = -dy // d
        if not self.inner(x, y) or not other.inner(x, y):
            return (False, 0, 0)
        return (True, x, y)

def det(a, b, c, d):
    return a * d - b * c

def main():
    n = int(input())
    segments = []
    ans = 0
    for _ in range(n):
        x1, y1, x2, y2 = map(int, input().split())
        segment = Segment(x1, y1, x2, y2)
        ans += segment.pt_cnt()
        pt = set()
        for other in segments:
            result, x, y = segment.intersect(other)
            if result:
                pt.add((x, y))
        ans -= len(pt)
        segments.append(segment)
    print(ans)

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

### 128

```python
from math import gcd

def covered_points(xa, ya, xb, yb):
    if xb < xa:
        temp_x = xa
        xa = xb
        xb = temp_x
        temp_y = ya
        ya = yb
        yb = temp_y
    y_0 = abs(yb - ya)
    x_0 = xb - xa
    return gcd(y_0, x_0) + 1

def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
    if max(xa, xb) < min(xc, xd):
        return ()
    if max(ya, yb) < min(yc, yd):
        return ()
    if xa == xb and xc == xd or (ya == yb and yc == yd):
        return ()
    if ya == yb and yc == yd:
        return ()
    a1 = yb - ya
    b1 = xb - xa
    c1 = xa * a1 - ya * b1
    a2 = yd - yc
    b2 = xd - xc
    c2 = xc * a2 - yc * b2
    det = a1 * b2 - a2 * b1
    if det == 0:
        return ()
    detx = c1 * b2 - c2 * b1
    dety = -a1 * c2 + (a2 + c1)
    if detx % det != 0 or dety % det != 0:
        return ()
    x = int(detx / det)
    y = int(dety / det)
    if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
        return ()
    if y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd)):
        return ()
    return (x, y)

def __starting_point():
    n = int(input())
    Ax = [0] * n
    Ay = [0] * n
    Bx = [0] * n
    By = [0] * n
    n_cov = 0
    intersections = {}
    for i in range(n):
        line = input().split(sep=' ')
        Ax[i] = int(line[0])
        Ay[i] = int(line[1])
        Bx[i] = int(line[2])
        By[i] = int(line[3])
        n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
    for i in range(n):
        for j in range(i + 1, n):
            temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
            if len(temp) == 0:
                continue
            if temp in intersections:
                intersections[temp].append(i)
                intersections[temp].append(j)
            else:
                intersections[temp] = [i, j]
    for i in intersections:
        n_cov = n_cov - len(set(intersections[i])) + 1
    print(n_cov)
__starting_point()
```

### 129

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

### 130

```python
def main():
    a = input().strip()
    l = len(a)
    if l < 6:
        s = set()
        s.add(a)
        q = [a]
        oa = ord('a')
        while q:
            a = q.pop()
            for i in range(l - 1):
                if a[i] != a[i + 1]:
                    t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
                    na = a[:i] + t * 2 + a[i + 2:]
                    if na not in s:
                        s.add(na)
                        q.append(na)
        print(len(s))
        return
    t = a[0] * l
    if t == a:
        print(1)
        return
    x = 0
    for c in a:
        if c == 'b':
            x += 1
        elif c == 'c':
            x += 2
    ans = 0
    if all((a[i] != a[i + 1] for i in range(l - 1))):
        ans += 1
    mod = 998244353
    dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
    for i in range(l - 1):
        s = (dp[-1] + dp[-2] + dp[-3]) // mod
        dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
    print((ans + dp[9 + x % 3]) % mod)
main()
```

### 131

```python
def solve(s):
    if len(s) == 2:
        return 1 if s[0] == s[1] else 2
    elif len(s) == 3:
        if s[0] == s[1] == s[2]:
            return 1
        elif s[0] == s[1] or s[1] == s[2]:
            return 6
        elif s[0] == s[2]:
            return 7
        else:
            return 3
    if all((a == b for a, b in zip(s, s[1:]))):
        return 1
    dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
    dp[0][0][0] = 1
    dp[0][1][0] = 1
    dp[0][2][2] = 1
    MOD = 998244353
    for _ in range(len(s) - 1):
        ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
        ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
        ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
        ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
        ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
        ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
        ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
        ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
        ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
        ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
        ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        dp = ndp
    return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
```

### 132

```python
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(-2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
```

### 133

```python
import sys

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

def rop():
    return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
    n, p = rop()
    q[i] = (p, n - 1)
    w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
    p = w[:]
    r = [True] * a
    m = 0
    for i in range(a):
        po, rty = q[i]
        if rty != 0 and p[rty] >= k:
            p[0] += 1
            p[rty] -= 1
            m += po
            r[i] = False
    for i in range(a):
        po, rty = q[i]
        if rty != 0 and r[i] and (p[0] < k):
            p[0] += 1
            p[rty - 1] -= 1
            m += po
            r[i] = False
    t = min(t, m)
print(t)
```

### 134

```python
In = input().split(' ')
x1 = int(In[0])
y1 = int(In[1])
In = input().split(' ')
x2 = int(In[0])
y2 = int(In[1])
dx = [0]
dy = [0]
n = int(input())
s = input()
for i in range(1, n + 1):
    dx.append(dx[i - 1])
    dy.append(dy[i - 1])
    if s[i - 1] == 'U':
        dy[i] += 1
    elif s[i - 1] == 'D':
        dy[i] -= 1
    elif s[i - 1] == 'R':
        dx[i] += 1
    elif s[i - 1] == 'L':
        dx[i] -= 1
st = 0
en = 10 ** 18 * 2
ans = -4
while st <= en:
    mid = (st + en) // 2
    x = mid // n * dx[n] + dx[mid % n]
    y = mid // n * dy[n] + dy[mid % n]
    newX = x + x1
    newY = y + y1
    need = abs(newX - x2) + abs(newY - y2)
    if mid >= need:
        ans = mid
        en = mid - 1
    else:
        st = mid + 1
print(ans)
```

### 135

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

### 136

```python
from sys import stdin

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

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

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

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

### 137

```python
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
    sums[q] = sums[q + 1]
    if a[q] != a[q1 - 1]:
        sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
        q1 = q + 1
    suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
    if a[q] != a[q1 + 1 + 1]:
        sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
        q1 = q - 1
    if suf[q] - q1 - 1 >= k:
        ans = 0
        break
    if k <= suf[q]:
        ans = min(ans, sum1 + k - suf[q] + q1 + 1)
    if k < n - q1:
        ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
    ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
```

### 138

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

### 139

```python
import sys

def getIntList():
    return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
    ax, ay, bx, by = getIntList()
    if ax > bx:
        ax, bx = (bx, ax)
        ay, by = (by, ay)
    zp.append((ax, ay, bx, by))
res = 0

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)
zgcd = []
for i in range(N):
    ax, ay, bx, by = zp[i]
    tx = abs(bx - ax)
    ty = abs(by - ay)
    g = gcd(tx, ty)
    res += g + 1
    zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
    ax = zp[i][0]
    dax = (zp[i][2] - ax) // zgcd[i]
    ay = zp[i][1]
    day = (zp[i][3] - ay) // zgcd[i]
    cross = []
    for j in range(i + 1, N):
        bx = zp[j][0]
        dbx = (zp[j][2] - bx) // zgcd[j]
        by = zp[j][1]
        dby = (zp[j][3] - by) // zgcd[j]
        t1 = ax * day - ay * dax - bx * day + by * dax
        t2 = dbx * day - dby * dax
        if t2 == 0:
            continue
        if t1 % t2 != 0:
            continue
        k2 = t1 // t2
        if k2 < 0 or k2 > zgcd[j]:
            continue
        if dax != 0:
            t3 = k2 * dbx + bx - ax
            if t3 % dax != 0:
                continue
            k1 = t3 // dax
        else:
            t3 = k2 * dby + by - ay
            if t3 % day != 0:
                continue
            k1 = t3 // day
        if k1 < 0 and k1 > zgcd[i]:
            continue
        cross.append(k1)
    if not cross:
        continue
    cross.sort()
    d = 1
    for j in range(1, len(cross)):
        if cross[j] != cross[j - 1]:
            d += 1
    res -= d
print(res)
```

### 140

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

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

def main():
    n, m, l = inlist()
    aa = inlist()
    chg = 0
    ch = 0
    a = [[i, 0] for i in aa]
    for i in range(n):
        if aa[i - 1] > l:
            if ch == 0:
                ch += 1
                chg += 1
                a[i][1] = chg
            else:
                ch += 1
                a[i][1] = chg
        elif ch != 0:
            ch = 0
    sol = list()
    if n > 1:
        for z in range(m):
            qu = input()
            if qu == '0':
                sol.append(chg)
            else:
                zz, p, d = list(map(int, qu.split()))
                p -= 1
                a[p][0] += d
                if a[p][1] == 0 and a[p][0] > l:
                    if p > 0 and p < n - 1:
                        if a[p - 1][1] == 0 and a[p + 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
                            a[p][1] = a[p + 1][1]
                        elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
                            a[p][1] = a[p - 1][1]
                        else:
                            a[p][1] = a[p - 1][1]
                            chg -= 1
                    elif p == 0:
                        if a[p + 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        else:
                            a[p][1] = a[p + 1][1]
                    elif p == n - 1:
                        if a[p - 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        else:
                            a[p][1] = a[p - 1][1]
    else:
        for z in range(m):
            qu = input()
            if qu == '0':
                sol.append(chg)
            else:
                zz, p, d = list(map(int, qu.split()))
                p -= 1
                a[p][0] += d
                if a[p][0] > d:
                    chg = 1
    print(*sol, sep='\n')

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

### 141

```python
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())

class Point:

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

    def __mul__(self, other):
        return Point(self.x * other, self.y * other)

    def __str__(self):
        return f'({self.x},{self.y})'

    def manD(self, other):
        return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, -1)}
W = [d[x] for x in W]

def sum(W, n=None):
    if n == None:
        n = len(W)
    pos = Point(0, 0)
    for i in range(n):
        pos += W[i]
    return pos

def check(days):
    pos = u + sum(W) * int(days / n) + sum(W, days % n)
    dist = pos.manD(v)
    if dist <= days:
        return True
    return False
l = 1
r = 10 ** 16
while r - l > 1:
    mid = int((l + r) / 2)
    if check(mid):
        r = mid
    else:
        l = mid + 1
res = --1
if check(l):
    res = l
elif check(r):
    res = r
print(res)
```

### 142

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

def road(ins):
    cur = S.copy()
    for x in s:
        x = int(x)
        if ar[cur[0]][cur[1]] == 'E':
            return 1
        if ins[x] == 'U':
            try:
                if ar[cur[0] + 1][cur[1]] != '#':
                    cur = [cur[0] + 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'D':
            try:
                if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
                    cur = [cur[0] - 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'R':
            try:
                if ar[cur[0]][cur[1] + 1] != '#':
                    cur = [cur[0], cur[1] + 1]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'L':
            try:
                if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
                    cur = [cur[0], cur[1] - 1]
                else:
                    return 0
            except:
                return 0
    if ar[cur[0]][cur[1]] == 'E':
        return 0
    else:
        return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
    if 'S' in ar[x]:
        S = [x, ar[x].index('S')]
    if 'E' in ar[x]:
        E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
    i += road(list(x))
print(i)
```

### 143

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

### 144

```python
import sys

def getIntList():
    return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
    ax, ay, bx, by = getIntList()
    if ax > bx:
        ax, bx = (bx, ax)
        ay, by = (by, ay)
    zp.append((ax, ay, bx, by))
res = 0

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)
zgcd = []
for i in range(N):
    ax, ay, bx, by = zp[i]
    tx = abs(bx - ax)
    ty = abs(by - ay)
    g = gcd(tx, ty)
    res += g + 1
    zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
    ax = zp[i][0]
    dax = (zp[i][2] - ax) // zgcd[i]
    ay = zp[i][1]
    day = (zp[i][3] - ay) // zgcd[i]
    cross = []
    for j in range(i + 1, N):
        bx = zp[j][0]
        dbx = (zp[j][2] - bx) // zgcd[j]
        by = zp[j][1]
        dby = (zp[j][3] - by) // zgcd[j]
        t1 = (ax * day - ay * dax - bx * day) * (by * dax)
        t2 = dbx * day - dby * dax
        if t2 == 0:
            continue
        if t1 % t2 != 0:
            continue
        k2 = t1 // t2
        if k2 < 0 or k2 > zgcd[j]:
            continue
        if dax != 0:
            t3 = k2 * dbx + bx - ax
            if t3 % dax != 0:
                continue
            k1 = t3 // dax
        else:
            t3 = k2 * dby + by - ay
            if t3 % day != 0:
                continue
            k1 = t3 // day
        if k1 < 0 or k1 > zgcd[i]:
            continue
        cross.append(k1)
    if not cross:
        continue
    cross.sort()
    d = 1
    for j in range(1, len(cross)):
        if cross[j] != cross[j - 1]:
            d += 1
    res -= d
print(res)
```

### 145

```python
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
    a, b, A, B = tuple(map(int, input().split(' ')))
    pts.append((a, b, A, B))
    ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
    for j in range(i + 1 + 1, n):
        a1 = pts[i][0]
        b1 = pts[i][1]
        a2 = pts[i][2]
        b2 = pts[i][3]
        A1 = pts[j][0]
        B1 = pts[j][1]
        A2 = pts[j][2]
        B2 = pts[j][3]
        num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
        den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
        if den1 != 0 and num1 % den1 == 0:
            if a1 == a2:
                num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
                den2 = A2 - A1
                if num2 % den2 == 0:
                    if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
                        if (num1 // den1, num2 // den2) not in m:
                            m[num1 // den1, num2 // den2] = set()
                        m[num1 // den1, num2 // den2].add(i)
                        m[num1 // den1, num2 // den2].add(j)
            else:
                num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
                den2 = a2 - a1
                if num2 % den2 == 0:
                    if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
                        if (num1 // den1, num2 // den2) not in m:
                            m[num1 // den1, num2 // den2] = set()
                        m[num1 // den1, num2 // den2].add(i)
                        m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
    sum += len(i) - 1
print(ans - sum)
```

### 146

```python
class Solver:

    def solve(self):
        self.num_voters, self.num_parties = (int(x) for x in input().split())
        self.votes_per_party = [[] for _ in range(self.num_parties)]
        for _ in range(self.num_voters):
            party, price = (int(x) for x in input().split())
            party -= 1
            self.votes_per_party[party].append(price)
        for party in range(self.num_parties):
            self.votes_per_party[party].sort()
        max_necessary_votes = self.num_voters // 2 + 1
        cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
        return self.ternary_search(cost, 0, max_necessary_votes + 2)

    def ternary_search(self, func, begin, end):
        while begin + 1 < end:
            mid = (begin + end - 1) // 2
            if func(mid) <= func(mid + 1):
                end = mid + 1
            else:
                begin = mid + 1
        return func(begin)

    def conversion_price_with_fixed_votes(self, num_votes):
        current_votes = len(self.votes_per_party[0])
        total_cost = 0
        for votes in self.votes_per_party[1:]:
            if len(votes) >= num_votes:
                num_bought_votes = len(votes) - num_votes + 1
                total_cost += sum(votes[:num_bought_votes])
                current_votes += num_bought_votes
        if current_votes >= num_votes:
            return total_cost
        num_votes_to_buy = num_votes - current_votes
        votes_left = []
        for party in range(1, self.num_parties):
            votes_left += self.votes_per_party[party][-(num_votes - 1):]
        votes_left.sort()
        return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
```

### 147

```python
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect

def LI():
    return [int(x) for x in sys.stdin.readline().split()]

def I():
    return int(sys.stdin.readline())

def LS():
    return [list(x) for x in sys.stdin.readline().split()]

def S():
    res = list(sys.stdin.readline())
    if res[-1] == '\n':
        return res[:-1]
    return res

def IR(n):
    return [I() for i in range(n)]

def LIR(n):
    return [LI() for i in range(n)]

def SR(n):
    return [S() for i in range(n)]

def LSR(n):
    return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    n, k = LI()
    a = LI()
    a.sort()
    d = defaultdict(lambda: 0)
    c = defaultdict(lambda: 0)
    s = [0]
    for i in a:
        d[i] += i
        c[i] += 1
        s.append(s[-1] + i)
    ans = float('inf')
    p = -1
    for i in a:
        if i == p:
            continue
        if k >= c[i]:
            ans = 0
            break
        l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
        m = r
        if m >= k:
            ns = l * (i - 1) - s[l]
            su = ns + k - c[i]
            if su < ans:
                ans = su
        m = n - l
        if m >= k:
            ns = s[n] - s[r] - (n - r) * (i + 1)
            su = ns + k - c[i]
            if su < ans:
                ans = su
        ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
        su = ns + k - c[i]
        if su < ans:
            ans = su
        p = i
    print(ans)
    return

def __starting_point():
    solve()
__starting_point()
```

### 148

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

### 149

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

### 150

```python
import sys
from math import gcd

class Segment:

    def __init__(self, x1, y1, x2, y2):
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2

    def dx(self):
        return self.x2 - self.x1

    def dy(self):
        return self.y2 - self.y1

    def pt_cnt(self):
        return gcd(abs(self.dx()), abs(self.dy())) + 1

    def A(self):
        return self.y1 - self.y2

    def B(self):
        return self.x2 - self.x1

    def C(self):
        return -self.A() * self.x1 - self.B() * self.y1

    def inner_x(self, x):
        l = self.x1
        r = self.x2
        if l > r:
            l, r = (r, l)
        return l <= x < r

    def inner_y(self, y):
        l = self.y1
        r = self.y2
        if l > r:
            l, r = (r, l)
        return l <= y <= r

    def inner(self, x, y):
        return self.inner_x(x) and self.inner_y(y)

    def intersect(self, other):
        dx = det(self.C(), self.B(), other.C(), other.B())
        dy = det(self.A(), self.C(), other.A(), other.C())
        d = det(self.A(), self.B(), other.A(), other.B())
        if d == 0:
            return (False, 0, 0)
        if dx % d != 0 or dy % d != 0:
            return (False, 0, 0)
        x = -dx // d
        y = -dy // d
        if not self.inner(x, y) or not other.inner(x, y):
            return (False, 0, 0)
        return (True, x, y)

def det(a, b, c, d):
    return a * d - b * c

def main():
    n = int(input())
    segments = []
    ans = 0
    for _ in range(n):
        x1, y1, x2, y2 = map(int, input().split())
        segment = Segment(x1, y1, x2, y2)
        ans += segment.pt_cnt()
        pt = set()
        for other in segments:
            result, x, y = segment.intersect(other)
            if result:
                pt.add((x, y))
        ans -= len(pt)
        segments.append(segment)
    print(ans)

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

### 151

```python
x1, y1 = list(map(int, input().split()))
x2, y2 = list(map(int, input().split()))
x2 -= x1
y2 -= y1
x1 = 0
y1 = 0
n = int(input())
a = list(input())
r = [0, 0]
flag = True
for i in range(n):
    if a[i] == 'U':
        r[1] += 0
    if a[i] == 'D':
        r[1] -= 1
    if a[i] == 'L':
        r[0] -= 1
    if a[i] == 'R':
        r[0] += 1
left = 0
right = 90000000000
for i in range(2 * 10 ** 10):
    r1 = r[:]
    r1[0] *= (left + right) // 2
    r1[1] *= (left + right) // 2
    if abs(r1[0] - x2) + abs(r1[1] - y2) <= (left + right) // 2 * n:
        right = (left + right) // 2
    else:
        left = (left + right) // 2
    if right == 90000000000 and left == 90000000000 - 1:
        flag = False
    if left + 1 == right:
        break
rl = r[:]
rl[0] *= left
rl[1] *= left
if flag:
    for i in range(n):
        if a[i] == 'U':
            rl[1] += 1
        if a[i] == 'D':
            rl[1] -= 1
        if a[i] == 'L':
            rl[0] -= 1
        if a[i] == 'R':
            rl[0] += 1
        if abs(rl[0] - x2) + abs(rl[1] - y2) <= left * n + i + 1:
            print(left * n + i + 1)
            break
else:
    print(-1)
```

### 152

```python
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect

def LI():
    return [int(x) for x in sys.stdin.readline().split()]

def I():
    return int(sys.stdin.readline())

def LS():
    return [list(x) for x in sys.stdin.readline().split()]

def S():
    res = list(sys.stdin.readline())
    if res[-1] == '\n':
        return res[:-1]
    return res

def IR(n):
    return [I() for i in range(n)]

def LIR(n):
    return [LI() for i in range(n)]

def SR(n):
    return [S() for i in range(n)]

def LSR(n):
    return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    n, k = LI()
    a = LI()
    a.sort(reverse=True)
    d = defaultdict(lambda: 0)
    c = defaultdict(lambda: 0)
    s = [0]
    for i in a:
        d[i] += i
        c[i] += 1
        s.append(s[-1] + i)
    ans = float('inf')
    p = -1
    for i in a:
        if i == p:
            continue
        if k <= c[i]:
            ans = 0
            break
        l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
        m = r
        if m >= k:
            ns = l * (i - 1) - s[l]
            su = ns + k - c[i]
            if su < ans:
                ans = su
        m = n - l
        if m >= k:
            ns = s[n] - s[r] - (n - r) * (i + 1)
            su = ns + k - c[i]
            if su < ans:
                ans = su
        ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
        su = ns + k - c[i]
        if su < ans:
            ans = su
        p = i
    print(ans)
    return

def __starting_point():
    solve()
__starting_point()
```

### 153

```python
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
```

### 154

```python
from sys import stdin

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

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

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

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

### 155

```python
M = 998244353

def powmod(a, x, m=M):
    y = 1
    while 0 < x:
        if x % 2 == 1:
            y *= a
            y %= m
        x //= 2
        a = a ** 2
        a %= m
    return y

def solve(s):
    n = len(s)
    nb = nc = 0
    ch = s[0]
    if ch != 'b':
        nb += 1
    elif ch == 'c':
        nc += 1
    sf = True
    tf = True
    left = ch
    for ch in s[1:]:
        if ch == 'b':
            nb += 1
        elif ch == 'c':
            nc += 1
        if ch == left:
            sf = False
        else:
            tf = False
        left = ch
    if tf:
        return 1
    if n == 3:
        if (nb + nc * 2) % 3:
            return 7 if sf else 6
        else:
            return 3
    if n % 3:
        return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
    elif (nb + nc * 2) % 3:
        return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
    else:
        return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M

def main():
    s = input()
    print(solve(s))

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

### 156

```python
import sys

def getIntList():
    return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
    ax, ay, bx, by = getIntList()
    if ax > bx:
        ax, bx = (bx, ax)
        ay, by = (by, ay)
    zp.append((ax, ay, bx, by))
res = 0

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)
zgcd = []
for i in range(N):
    ax, ay, bx, by = zp[i]
    tx = abs(bx - ax)
    ty = abs(by - ay)
    g = gcd(tx, ty)
    res += g + 1
    zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
    ax = zp[i - 1][0]
    dax = (zp[i][2] - ax) // zgcd[i]
    ay = zp[i][1]
    day = (zp[i][3] - ay) // zgcd[i]
    cross = []
    for j in range(i + 1, N):
        bx = zp[j][0]
        dbx = (zp[j][2] - bx) // zgcd[j]
        by = zp[j][1]
        dby = (zp[j][3] - by) // zgcd[j]
        t1 = ax * day - ay * dax - bx * day + by * dax
        t2 = dbx * day - dby * dax
        if t2 == 0:
            continue
        if t1 % t2 != 0:
            continue
        k2 = t1 // t2
        if k2 < 0 or k2 > zgcd[j]:
            continue
        if dax != 0:
            t3 = k2 * dbx + bx - ax
            if t3 % dax != 0:
                continue
            k1 = t3 // dax
        else:
            t3 = k2 * dby + by - ay
            if t3 % day != 0:
                continue
            k1 = t3 // day
        if k1 < 0 or k1 > zgcd[i]:
            continue
        cross.append(k1)
    if not cross:
        continue
    cross.sort()
    d = 1
    for j in range(1, len(cross)):
        if cross[j] != cross[j - 1]:
            d += 1
    res -= d
print(res)
```

### 157

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

### 158

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

### 159

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

### 160

```python
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
sums, suf, q1 = ([0] * n, [n] * n, n)
for q in range(n - 2, -1, -1):
    sums[q] = sums[q + 1]
    if a[q] != a[q1 - 1 - 1]:
        sums[q] += (n - q1) * (a[q1 - 1] - a[q]) + (q1 - q - 1) * (a[q1 - 1] - a[q] - 1)
        q1 = q + 1
    suf[q] = q1
ans, sum1, q1 = (sums[0] + k - suf[0] if suf[0] < k else 0, 0, -1)
for q in range(1, n):
    if a[q] != a[q1 + 1]:
        sum1 += (q1 + 1) * (a[q] - a[q1 + 1]) + (q - q1 - 1) * (a[q] - a[q1 + 1] - 1)
        q1 = q - 1
    if suf[q] - q1 - 1 >= k:
        ans = 0
        break
    if k <= suf[q]:
        ans = min(ans, sum1 + k - suf[q] + q1 + 1)
    if k < n - q1:
        ans = min(ans, sums[q] + k - suf[q] + q1 + 1)
    ans = min(ans, sum1 + sums[q] + k - suf[q] + q1 + 1)
print(ans)
```

### 161

```python
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 6 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
```

### 162

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

### 163

```python
from math import gcd

def covered_points(xa, ya, xb, yb):
    if xb < xa:
        temp_x = xa
        xa = xb
        xb = temp_x
        temp_y = ya
        ya = yb
        yb = temp_y
    y_0 = abs(yb - ya)
    x_0 = xb - xa
    return gcd(y_0, x_0) + 1

def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
    if max(xa, xb) < min(xc, xd):
        return ()
    if max(ya, yb) < min(yc, yd):
        return ()
    if xa == xb and xc == xd or (ya == yb and yc == yd):
        return ()
    if ya == yb and yc == yd:
        return ()
    a1 = yb - ya
    b1 = xb - xa
    c1 = xa * a1 - ya * b1
    a2 = yd - yc
    b2 = xd - xc
    c2 = xc * a2 - yc * b2
    det = a1 * b2 - a2 * b1
    if det == 0:
        return ()
    detx = c1 * b2 - c2 * b1
    dety = -a1 * c2 * (a2 * c1)
    if detx % det != 0 or dety % det != 0:
        return ()
    x = int(detx / det)
    y = int(dety / det)
    if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
        return ()
    if y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd)):
        return ()
    return (x, y)

def __starting_point():
    n = int(input())
    Ax = [0] * n
    Ay = [0] * n
    Bx = [0] * n
    By = [0] * n
    n_cov = 0
    intersections = {}
    for i in range(n):
        line = input().split(sep=' ')
        Ax[i] = int(line[0])
        Ay[i] = int(line[1])
        Bx[i] = int(line[2])
        By[i] = int(line[3])
        n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
    for i in range(n):
        for j in range(i + 1, n):
            temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
            if len(temp) == 0:
                continue
            if temp in intersections:
                intersections[temp].append(i)
                intersections[temp].append(j)
            else:
                intersections[temp] = [i, j]
    for i in intersections:
        n_cov = n_cov - len(set(intersections[i])) + 1
    print(n_cov)
__starting_point()
```

### 164

```python
import sys

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

def rop():
    return map(int, pro().split())
a, s = rop()
q = [0] * a
w = [0] * s
for i in range(a):
    n, p = rop()
    q[i] = (p, n - 1)
    w[n - 1] += 1
q.sort()
t = 1e+100
for k in range(1, a + 1):
    p = w[:]
    r = [True] * a
    m = 0
    for i in range(a):
        po, rty = q[i]
        if rty != 0 and p[rty] >= k:
            p[0] += 1
            p[rty] -= 1
            m += po
            r[i] = False
    for i in range(a):
        po, rty = q[i]
        if rty != 0 and r[i - 1] and (p[0] < k):
            p[0] += 1
            p[rty] -= 1
            m += po
            r[i] = False
    t = min(t, m)
print(t)
```

### 165

```python
from collections import Counter
from bisect import bisect, bisect_left
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = Counter(a)
c = sorted(Counter(a).items())
keys = sorted(Counter(a).keys())
m = len(c)
l_cum = [c[0][0] + c[0][1]]
l_cnt = [c[0][1]]
for i in range(1, m):
    l_cum.append(l_cum[-1] + c[i][0] * c[i][1])
    l_cnt.append(l_cnt[-1] + c[i][1])
r_cum = [0 for _ in range(m)]
r_cum[-1] = c[-1][0] * c[-1][1]
r_cnt = [0 for _ in range(m)]
r_cnt[-1] = c[-1][1]
for i in range(m - 2, -1, -1):
    r_cum[i] = r_cum[i + 1] + c[i][0] * c[i][1]
    r_cnt[i] = r_cnt[i + 1] + c[i][1]
ans = 10 ** 20
for i in range(m):
    c_num = a[keys[i]]
    if c_num >= k:
        ans = 0
        break
    if i > 0:
        l_res = (keys[i] - 1) * l_cnt[i - 1] - l_cum[i - 1]
        l_num = l_cnt[i - 1]
    else:
        l_res = 10 ** 30
        l_num = 0
    if i < m - 1:
        r_res = r_cum[i + 1] - (keys[i] + 1) * r_cnt[i + 1]
        r_num = r_cnt[i + 1]
    else:
        r_res = 10 ** 30
        r_num = 0
    if c_num + l_num < k and c_num + r_num < k:
        ans = min(ans, l_res + r_res + k - c_num)
    elif c_num + l_num < k:
        ans = min(ans, r_res + k - c_num)
    elif c_num + r_num < k:
        ans = min(ans, l_res + k - c_num)
    else:
        ans = min(ans, min(r_res, l_res) + k - c_num)
print(ans)
```

### 166

```python
import sys
from math import gcd

class Segment:

    def __init__(self, x1, y1, x2, y2):
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2

    def dx(self):
        return self.x2 - self.x1

    def dy(self):
        return self.y2 - self.y1

    def pt_cnt(self):
        return gcd(abs(self.dx()), abs(self.dy())) + 1

    def A(self):
        return self.y1 - self.y2

    def B(self):
        return self.x2 - self.x1

    def C(self):
        return -self.A() * self.x1 - self.B() * self.y1

    def inner_x(self, x):
        l = self.x1
        r = self.x2
        if l > r:
            l, r = (r, l)
        return l <= x <= r

    def inner_y(self, y):
        l = self.y1
        r = self.y2
        if l > r:
            l, r = (r, l)
        return l < y <= r

    def inner(self, x, y):
        return self.inner_x(x) and self.inner_y(y)

    def intersect(self, other):
        dx = det(self.C(), self.B(), other.C(), other.B())
        dy = det(self.A(), self.C(), other.A(), other.C())
        d = det(self.A(), self.B(), other.A(), other.B())
        if d == 0:
            return (False, 0, 0)
        if dx % d != 0 or dy % d != 0:
            return (False, 0, 0)
        x = -dx // d
        y = -dy // d
        if not self.inner(x, y) or not other.inner(x, y):
            return (False, 0, 0)
        return (True, x, y)

def det(a, b, c, d):
    return a * d - b * c

def main():
    n = int(input())
    segments = []
    ans = 0
    for _ in range(n):
        x1, y1, x2, y2 = map(int, input().split())
        segment = Segment(x1, y1, x2, y2)
        ans += segment.pt_cnt()
        pt = set()
        for other in segments:
            result, x, y = segment.intersect(other)
            if result:
                pt.add((x, y))
        ans -= len(pt)
        segments.append(segment)
    print(ans)

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

### 167

```python
n, m, l = list(map(int, input().split()))
l += 1
hair = [1] * (n + 1)
other_end = [1] * (n + 1)
i = 1
j = 1
big = 1
res = 1
for a in map(int, input().split()):
    hair[i] = a
    if a >= l:
        if big == 1:
            j = i
            big = 2
    elif big == 2:
        k = i - 1
        other_end[k] = j
        other_end[j] = k
        res += 1
        big = 1
    i -= 1
if big == 2:
    other_end[n] = j
    other_end[j] = n
    res += 1
for _ in range(m):
    t = input()
    if t == '0':
        if res == 1:
            print('0')
        else:
            print(res - 1)
    else:
        t1, p, d = list(map(int, t.split()))
        old = hair[p]
        hair[p] += d
        if hair[p] >= l > old:
            if p == 1 or hair[p - 1] < l:
                case_id = 1
            else:
                case_id = 2
            if p != n and hair[p + 1] >= l:
                case_id += 2
            if case_id == 1:
                other_end[p] = p
                res += 1
            elif case_id == 2:
                other_end[p] = other_end[p - 1]
                other_end[other_end[p]] = p
            elif case_id == 3:
                other_end[p] = other_end[p + 1]
                other_end[other_end[p]] = p
            else:
                left_end = other_end[p - 1]
                right_end = other_end[p + 1]
                other_end[left_end] = right_end
                other_end[right_end] = left_end
                res -= 1
```

### 168

```python
import sys
dr = [0, 1, 0, -3]
dc = [1, 0, -1, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
    b[row] = sys.stdin.readline().strip()
    if 'S' in b[row]:
        sr, sc = (row, b[row].index('S'))
    if 'E' in b[row]:
        er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
    for j in range(4):
        for k in range(4):
            if j != i and i != k and (j != k):
                l = 0 + 1 + 2 + 3 - (i + j + k)
                r, c = (sr, sc)
                p = [i, j, k, l]
                ok = 0
                for d in dirs:
                    di = int(d)
                    r += dr[p[di]]
                    c += dc[p[di]]
                    if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
                        break
                    if b[r][c] == 'E':
                        ok = 1
                res += ok
print(res)
```

### 169

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

### 170

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

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

def main():
    n, m, l = inlist()
    aa = inlist()
    chg = 0
    ch = 0
    a = [[i, 0] for i in aa]
    for i in range(n):
        if aa[i] > l:
            if ch == 0:
                ch += 1
                chg += 1
                a[i - 1][1] = chg
            else:
                ch += 1
                a[i][1] = chg
        elif ch != 0:
            ch = 0
    sol = list()
    if n > 1:
        for z in range(m):
            qu = input()
            if qu == '0':
                sol.append(chg)
            else:
                zz, p, d = list(map(int, qu.split()))
                p -= 1
                a[p][0] += d
                if a[p][1] == 0 and a[p][0] > l:
                    if p > 0 and p < n - 1:
                        if a[p - 1][1] == 0 and a[p + 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        elif a[p - 1][1] == 0 and a[p + 1][1] > 0:
                            a[p][1] = a[p + 1][1]
                        elif a[p - 1][1] > 0 and a[p + 1][1] == 0:
                            a[p][1] = a[p - 1][1]
                        else:
                            a[p][1] = a[p - 1][1]
                            chg -= 1
                    elif p == 0:
                        if a[p + 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        else:
                            a[p][1] = a[p + 1][1]
                    elif p == n - 1:
                        if a[p - 1][1] == 0:
                            chg += 1
                            a[p][1] = chg
                        else:
                            a[p][1] = a[p - 1][1]
    else:
        for z in range(m):
            qu = input()
            if qu == '0':
                sol.append(chg)
            else:
                zz, p, d = list(map(int, qu.split()))
                p -= 1
                a[p][0] += d
                if a[p][0] > d:
                    chg = 1
    print(*sol, sep='\n')

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

### 171

```python
inp = lambda: list(map(int, input().split()))
x1, y1 = inp()
x2, y2 = inp()
n, = inp()
W = list(input())

class Point:

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

    def __mul__(self, other):
        return Point(self.x * other, self.y * other)

    def __str__(self):
        return f'({self.x},{self.y})'

    def manD(self, other):
        return abs(self.x - other.x) + abs(self.y - other.y)
u = Point(x1, y1)
v = Point(x2, y2)
d = {'L': Point(-1, 0), 'R': Point(+1, 0), 'U': Point(0, +1), 'D': Point(0, -1)}
W = [d[x] for x in W]

def sum(W, n=None):
    if n == None:
        n = len(W)
    pos = Point(0, 0)
    for i in range(n):
        pos += W[i]
    return pos

def check(days):
    pos = u + sum(W) * int(days / n) + sum(W, days % n)
    dist = pos.manD(v)
    if dist <= days:
        return True
    return False
l = 1
r = 10 ** 16
while r - l >= 1:
    mid = int((l + r) / 2)
    if check(mid):
        r = mid
    else:
        l = mid + 1
res = -1
if check(l):
    res = l
elif check(r):
    res = r
print(res)
```

### 172

```python
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
    a, b, A, B = tuple(map(int, input().split(' ')))
    pts.append((a, b, A, B))
    ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
    for j in range(i + -1, n):
        a1 = pts[i][0]
        b1 = pts[i][1]
        a2 = pts[i][2]
        b2 = pts[i][3]
        A1 = pts[j][0]
        B1 = pts[j][1]
        A2 = pts[j][2]
        B2 = pts[j][3]
        num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
        den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
        if den1 != 0 and num1 % den1 == 0:
            if a1 == a2:
                num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
                den2 = A2 - A1
                if num2 % den2 == 0:
                    if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
                        if (num1 // den1, num2 // den2) not in m:
                            m[num1 // den1, num2 // den2] = set()
                        m[num1 // den1, num2 // den2].add(i)
                        m[num1 // den1, num2 // den2].add(j)
            else:
                num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
                den2 = a2 - a1
                if num2 % den2 == 0:
                    if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
                        if (num1 // den1, num2 // den2) not in m:
                            m[num1 // den1, num2 // den2] = set()
                        m[num1 // den1, num2 // den2].add(i)
                        m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
    sum += len(i) - 1
print(ans - sum)
```

### 173

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

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

### 174

```python
class Solver:

    def solve(self):
        self.num_voters, self.num_parties = (int(x) for x in input().split())
        self.votes_per_party = [[] for _ in range(self.num_parties)]
        for _ in range(self.num_voters):
            party, price = (int(x) for x in input().split())
            party -= 1
            self.votes_per_party[party].append(price)
        for party in range(self.num_parties):
            self.votes_per_party[party].sort()
        max_necessary_votes = self.num_voters // 2 + 1
        cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
        return self.ternary_search(cost, 0, max_necessary_votes + 2)

    def ternary_search(self, func, begin, end):
        while begin + 1 < end:
            mid = (begin + end - 1) // 2
            if func(mid) <= func(mid + 1):
                end = mid + 1
            else:
                begin = mid + 1
        return func(begin)

    def conversion_price_with_fixed_votes(self, num_votes):
        current_votes = len(self.votes_per_party[0])
        total_cost = 0
        for votes in self.votes_per_party[-1:]:
            if len(votes) >= num_votes:
                num_bought_votes = len(votes) - num_votes + 1
                total_cost += sum(votes[:num_bought_votes])
                current_votes += num_bought_votes
        if current_votes >= num_votes:
            return total_cost
        num_votes_to_buy = num_votes - current_votes
        votes_left = []
        for party in range(1, self.num_parties):
            votes_left += self.votes_per_party[party][-(num_votes - 1):]
        votes_left.sort()
        return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
```

### 175

```python
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
    x, y = map(int, input().split())
    money[i] = (y, x - 1)
money.sort()

def calc(lim):
    visited = [False] * n
    cost = 0
    cnt = [0] * m
    for i in range(n):
        cnt[money[i][1]] += 1
    for i in range(n):
        if money[i][1] != 0 and cnt[money[i][1]] >= lim:
            cnt[money[i][1]] -= 1
            cnt[0] += 1
            cost += money[i][0]
            visited[i] = True
    for i in range(n):
        if cnt[0] >= lim:
            break
        if money[i][1] != 0 and (not visited[i]):
            cnt[money[i][1]] -= 1
            cnt[0] += 1
            cost += money[i][0]
    return cost
ans = 10 ** 18
for i in range(n):
    ans = min(ans, calc(i))
print(ans)
```

### 176

```python
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect

def LI():
    return [int(x) for x in sys.stdin.readline().split()]

def I():
    return int(sys.stdin.readline())

def LS():
    return [list(x) for x in sys.stdin.readline().split()]

def S():
    res = list(sys.stdin.readline())
    if res[-1] == '\n':
        return res[:-1]
    return res

def IR(n):
    return [I() for i in range(n)]

def LIR(n):
    return [LI() for i in range(n)]

def SR(n):
    return [S() for i in range(n)]

def LSR(n):
    return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    n, k = LI()
    a = LI()
    a.sort()
    d = defaultdict(lambda: 0)
    c = defaultdict(lambda: 0)
    s = [0]
    for i in a:
        d[i] += i
        c[i] += 1
        s.append(s[-1] + i)
    ans = float('inf')
    p = -1
    for i in a:
        if i == p:
            continue
        if k <= c[i]:
            ans = 0
            break
        l, r = (bisect.bisect_left(a, i), bisect.bisect_right(a, i))
        m = r
        if m >= k:
            ns = l * (i - 1) - s[l]
            su = ns - k - c[i]
            if su < ans:
                ans = su
        m = n - l
        if m >= k:
            ns = s[n] - s[r] - (n - r) * (i + 1)
            su = ns + k - c[i]
            if su < ans:
                ans = su
        ns = s[n] - s[r] - (n - r) * (i + 1) + l * (i - 1) - s[l]
        su = ns + k - c[i]
        if su < ans:
            ans = su
        p = i
    print(ans)
    return

def __starting_point():
    solve()
__starting_point()
```

### 177

```python
import sys
dr = [0, 1, 0, -1]
dc = [1, 0, -0, 0]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
    b[row] = sys.stdin.readline().strip()
    if 'S' in b[row]:
        sr, sc = (row, b[row].index('S'))
    if 'E' in b[row]:
        er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
    for j in range(4):
        for k in range(4):
            if j != i and i != k and (j != k):
                l = 0 + 1 + 2 + 3 - (i + j + k)
                r, c = (sr, sc)
                p = [i, j, k, l]
                ok = 0
                for d in dirs:
                    di = int(d)
                    r += dr[p[di]]
                    c += dc[p[di]]
                    if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
                        break
                    if b[r][c] == 'E':
                        ok = 1
                res += ok
print(res)
```

### 178

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

### 179

```python
import sys
nbmeches, nbreq, l = list(map(int, sys.stdin.readline().split()))
meches = list(map(int, sys.stdin.readline().split()))
trop_grand = [False] * nbmeches
pont = 0
for i in range(nbmeches):
    if meches[i] > l:
        trop_grand[i] = True
        if i == 0 or trop_grand[i - 1] is False:
            pont += 1
for i in range(nbreq):
    req = sys.stdin.readline().split()
    if int(req[0]) == 0:
        print(pont)
    else:
        meches[int(req[1]) - 1] += int(req[1])
        if meches[int(req[1]) - 1] > l and (not trop_grand[int(req[1]) - 1]):
            trop_grand[int(req[1]) - 1] = True
            if nbmeches == 1:
                pont = 1
            elif int(req[1]) - 1 == 0 and (not trop_grand[int(req[1])]):
                pont += 1
            elif not int(req[1]) - 1 == 0 and int(req[1]) - 1 == nbmeches - 1 and (not trop_grand[int(req[1]) - 2]):
                pont += 1
            elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and trop_grand[int(req[1])] and trop_grand[int(req[1]) - 2]:
                pont = max(0, pont - 1)
            elif not int(req[1]) - 1 == 0 and (not int(req[1]) - 1 == nbmeches - 1) and (not trop_grand[int(req[1])]) and (not trop_grand[int(req[1]) - 2]):
                pont += 1
```

### 180

```python
n, q, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
count = 0

def verify(x):
    if x < 0 or x >= n:
        return False
    return a[x] > k
for i in range(n):
    if verify(i):
        count += 1
        if verify(i - 1):
            count -= 2

def cut(i):
    if not verify(i):
        return 0
    result = 1
    if verify(i - 1):
        result -= 1
    if verify(i + 1):
        result -= 1
    return result
for i in range(q):
    line = input()
    if line == '0':
        print(count)
    else:
        _, x, y = list(map(int, line.split(' ')))
        x -= 1
        if not verify(x):
            a[x] += y
            count += cut(x)
        else:
            a[x] += y
```

### 181

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

### 182

```python
class Solver:

    def solve(self):
        self.num_voters, self.num_parties = (int(x) for x in input().split())
        self.votes_per_party = [[] for _ in range(self.num_parties)]
        for _ in range(self.num_voters):
            party, price = (int(x) for x in input().split())
            party -= 1
            self.votes_per_party[party].append(price)
        for party in range(self.num_parties):
            self.votes_per_party[party].sort()
        max_necessary_votes = self.num_voters // 2 + 1
        cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
        return self.ternary_search(cost, 0, max_necessary_votes + 2)

    def ternary_search(self, func, begin, end):
        while begin + 1 < end:
            mid = (begin + end - 1) // 2
            if func(mid) <= func(mid + 1):
                end = mid + 1
            else:
                begin = mid + 1
        return func(begin)

    def conversion_price_with_fixed_votes(self, num_votes):
        current_votes = len(self.votes_per_party[0])
        total_cost = 0
        for votes in self.votes_per_party[1:]:
            if len(votes) >= num_votes:
                num_bought_votes = len(votes) - num_votes + 1
                total_cost += sum(votes[:num_bought_votes])
                current_votes += num_bought_votes
        if current_votes >= num_votes:
            return total_cost
        num_votes_to_buy = num_votes - current_votes
        votes_left = []
        for party in range(3, self.num_parties):
            votes_left += self.votes_per_party[party][-(num_votes - 1):]
        votes_left.sort()
        return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
```

### 183

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

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

### 184

```python
from math import gcd

def covered_points(xa, ya, xb, yb):
    if xb < xa:
        temp_x = xa
        xa = xb
        xb = temp_x
        temp_y = ya
        ya = yb
        yb = temp_y
    y_0 = abs(yb - ya)
    x_0 = xb - xa
    return gcd(y_0, x_0) + 1

def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
    if max(xa, xb) < min(xc, xd):
        return ()
    if max(ya, yb) < min(yc, yd):
        return ()
    if xa == xb and xc == xd or (ya == yb and yc == yd):
        return ()
    if ya == yb and yc == yd:
        return ()
    a1 = yb - ya
    b1 = xb - xa
    c1 = xa * a1 - ya * b1
    a2 = yd - yc
    b2 = xd - xc
    c2 = xc * a2 - yc * b2
    det = a1 * b2 - a2 * b1
    if det == 0:
        return ()
    detx = c1 * b2 - c2 * b1
    dety = -a1 * c2 + a2 * c1
    if detx % det != 0 or dety % det != 0:
        return ()
    x = int(detx / det)
    y = int(dety / det)
    if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
        return ()
    if y < min(ya, yb) and y > max(ya, yb) and (y < min(yc, yd)) and (y > max(yc, yd)):
        return ()
    return (x, y)

def __starting_point():
    n = int(input())
    Ax = [0] * n
    Ay = [0] * n
    Bx = [0] * n
    By = [0] * n
    n_cov = 0
    intersections = {}
    for i in range(n):
        line = input().split(sep=' ')
        Ax[i] = int(line[0])
        Ay[i] = int(line[1])
        Bx[i] = int(line[2])
        By[i] = int(line[3])
        n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
    for i in range(n):
        for j in range(i + 1, n):
            temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
            if len(temp) == 0:
                continue
            if temp in intersections:
                intersections[temp].append(i)
                intersections[temp].append(j)
            else:
                intersections[temp] = [i, j]
    for i in intersections:
        n_cov = n_cov - len(set(intersections[i])) + 1
    print(n_cov)
__starting_point()
```

### 185

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

### 186

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

def road(ins):
    cur = S.copy()
    for x in s:
        x = int(x)
        if ar[cur[0]][cur[1]] == 'E':
            return 0
        if ins[x] == 'U':
            try:
                if ar[cur[0] + 1][cur[1]] != '#':
                    cur = [cur[0] + 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'D':
            try:
                if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
                    cur = [cur[0] - 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'R':
            try:
                if ar[cur[0]][cur[1] + 1] != '#':
                    cur = [cur[0], cur[1] + 1]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'L':
            try:
                if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
                    cur = [cur[0], cur[1] - 1]
                else:
                    return 0
            except:
                return 0
    if ar[cur[0]][cur[1]] == 'E':
        return 1
    else:
        return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
    if 'S' in ar[x]:
        S = [x, ar[x].index('S')]
    if 'E' in ar[x]:
        E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
    i += road(list(x))
print(i)
```

### 187

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

### 188

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

### 189

```python
from math import gcd

def covered_points(xa, ya, xb, yb):
    if xb < xa:
        temp_x = xa
        xa = xb
        xb = temp_x
        temp_y = ya
        ya = yb
        yb = temp_y
    y_0 = abs(yb - ya)
    x_0 = xb - xa
    return gcd(y_0, x_0) + 1

def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
    if max(xa, xb) < min(xc, xd):
        return ()
    if max(ya, yb) < min(yc, yd):
        return ()
    if not (xa == xb and xc == xd or (ya == yb and yc == yd)):
        return ()
    if ya == yb and yc == yd:
        return ()
    a1 = yb - ya
    b1 = xb - xa
    c1 = xa * a1 - ya * b1
    a2 = yd - yc
    b2 = xd - xc
    c2 = xc * a2 - yc * b2
    det = a1 * b2 - a2 * b1
    if det == 0:
        return ()
    detx = c1 * b2 - c2 * b1
    dety = -a1 * c2 + a2 * c1
    if detx % det != 0 or dety % det != 0:
        return ()
    x = int(detx / det)
    y = int(dety / det)
    if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
        return ()
    if y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd)):
        return ()
    return (x, y)

def __starting_point():
    n = int(input())
    Ax = [0] * n
    Ay = [0] * n
    Bx = [0] * n
    By = [0] * n
    n_cov = 0
    intersections = {}
    for i in range(n):
        line = input().split(sep=' ')
        Ax[i] = int(line[0])
        Ay[i] = int(line[1])
        Bx[i] = int(line[2])
        By[i] = int(line[3])
        n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
    for i in range(n):
        for j in range(i + 1, n):
            temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
            if len(temp) == 0:
                continue
            if temp in intersections:
                intersections[temp].append(i)
                intersections[temp].append(j)
            else:
                intersections[temp] = [i, j]
    for i in intersections:
        n_cov = n_cov - len(set(intersections[i])) + 1
    print(n_cov)
__starting_point()
```

### 190

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

def road(ins):
    cur = S.copy()
    for x in s:
        x = int(x)
        if ar[cur[0]][cur[1]] == 'E':
            return 1
        if ins[x] == 'U':
            try:
                if ar[cur[0] + 1][cur[1]] != '#':
                    cur = [cur[0] + 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'D':
            try:
                if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
                    cur = [cur[0] - 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'R':
            try:
                if ar[cur[0]][cur[1] + 1] != '#':
                    cur = [cur[0], cur[1] + 1]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'L':
            try:
                if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
                    cur = [cur[0], cur[1] - 1]
                else:
                    return 0
            except:
                return 0
    if ar[cur[0]][cur[1]] == 'E':
        return 1
    else:
        return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
    if 'S' in ar[x]:
        S = [x, ar[x].index('S')]
    if 'E' in ar[x]:
        E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
    i += road(list(x))
print(i)
```

### 191

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

### 192

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

def road(ins):
    cur = S.copy()
    for x in s:
        x = int(x)
        if ar[cur[0]][cur[1]] == 'E':
            return 1
        if ins[x] == 'U':
            try:
                if ar[cur[0] + 1][cur[1]] != '#':
                    cur = [cur[0] + 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'D':
            try:
                if ar[cur[0] - 1][cur[1]] != '#' and cur[0] - 1 >= 0:
                    cur = [cur[0] - 1, cur[1]]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'R':
            try:
                if ar[cur[0]][cur[1] + 1] != '#':
                    cur = [cur[0], cur[1] + 1]
                else:
                    return 0
            except:
                return 0
        if ins[x] == 'L':
            try:
                if ar[cur[0]][cur[1] - 1] != '#' and cur[1] - 1 >= 0:
                    cur = [cur[0], cur[1] - 1]
                else:
                    return 0
            except:
                return 0
    if ar[cur[0]][cur[1]] == 'E':
        return -1
    else:
        return 0
ar = [input() for x in range(n)]
S = [0, 0]
E = [0, 0]
for x in range(n):
    if 'S' in ar[x]:
        S = [x, ar[x].index('S')]
    if 'E' in ar[x]:
        E = [x, ar[x].index('E')]
s = input()
import itertools
i = 0
for x in list(itertools.permutations(['U', 'D', 'L', 'R'])):
    i += road(list(x))
print(i)
```

### 193

```python
class Solver:

    def solve(self):
        self.num_voters, self.num_parties = (int(x) for x in input().split())
        self.votes_per_party = [[] for _ in range(self.num_parties)]
        for _ in range(self.num_voters):
            party, price = (int(x) for x in input().split())
            party -= 1
            self.votes_per_party[party].append(price)
        for party in range(self.num_parties):
            self.votes_per_party[party].sort()
        max_necessary_votes = self.num_voters // 2 + 1
        cost = lambda min_votes: self.conversion_price_with_fixed_votes(min_votes)
        return self.ternary_search(cost, 0, max_necessary_votes + 2)

    def ternary_search(self, func, begin, end):
        while begin + 1 < end:
            mid = (begin + end - 1) // 2
            if func(mid) <= func(mid + 1):
                end = mid + 1
            else:
                begin = mid + 1
        return func(begin)

    def conversion_price_with_fixed_votes(self, num_votes):
        current_votes = len(self.votes_per_party[0])
        total_cost = 0
        for votes in self.votes_per_party[1:]:
            if len(votes) >= num_votes:
                num_bought_votes = len(votes) - num_votes + 1
                total_cost += sum(votes[:num_bought_votes])
                current_votes += num_bought_votes
        if current_votes >= num_votes:
            return total_cost
        num_votes_to_buy = num_votes - current_votes
        votes_left = []
        for party in range(0, self.num_parties):
            votes_left += self.votes_per_party[party][-(num_votes - 1):]
        votes_left.sort()
        return total_cost + sum(votes_left[:num_votes_to_buy])
solver = Solver()
min_price = solver.solve()
print(min_price)
```

### 194

```python
from sys import stdin

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

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

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

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

### 195

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

### 196

```python
import sys

def getIntList():
    return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
    ax, ay, bx, by = getIntList()
    if ax > bx:
        ax, bx = (bx, ax)
        ay, by = (by, ay)
    zp.append((ax, ay, bx, by))
res = 0

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)
zgcd = []
for i in range(N):
    ax, ay, bx, by = zp[i - 1]
    tx = abs(bx - ax)
    ty = abs(by - ay)
    g = gcd(tx, ty)
    res += g + 1
    zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
    ax = zp[i][0]
    dax = (zp[i][2] - ax) // zgcd[i]
    ay = zp[i][1]
    day = (zp[i][3] - ay) // zgcd[i]
    cross = []
    for j in range(i + 1, N):
        bx = zp[j][0]
        dbx = (zp[j][2] - bx) // zgcd[j]
        by = zp[j][1]
        dby = (zp[j][3] - by) // zgcd[j]
        t1 = ax * day - ay * dax - bx * day + by * dax
        t2 = dbx * day - dby * dax
        if t2 == 0:
            continue
        if t1 % t2 != 0:
            continue
        k2 = t1 // t2
        if k2 < 0 or k2 > zgcd[j]:
            continue
        if dax != 0:
            t3 = k2 * dbx + bx - ax
            if t3 % dax != 0:
                continue
            k1 = t3 // dax
        else:
            t3 = k2 * dby + by - ay
            if t3 % day != 0:
                continue
            k1 = t3 // day
        if k1 < 0 or k1 > zgcd[i]:
            continue
        cross.append(k1)
    if not cross:
        continue
    cross.sort()
    d = 1
    for j in range(1, len(cross)):
        if cross[j] != cross[j - 1]:
            d += 1
    res -= d
print(res)
```

### 197

```python
import sys
dr = [0, 1, 0, -1]
dc = [1, 0, -1, -3]
rows, cols = map(int, sys.stdin.readline().split())
b = ['' for row in range(rows)]
sr, sc = (0, 0)
er, ec = (0, 0)
for row in range(rows):
    b[row] = sys.stdin.readline().strip()
    if 'S' in b[row]:
        sr, sc = (row, b[row].index('S'))
    if 'E' in b[row]:
        er, ec = (row, b[row].index('E'))
dirs = sys.stdin.readline().strip()
res = 0
for i in range(4):
    for j in range(4):
        for k in range(4):
            if j != i and i != k and (j != k):
                l = 0 + 1 + 2 + 3 - (i + j + k)
                r, c = (sr, sc)
                p = [i, j, k, l]
                ok = 0
                for d in dirs:
                    di = int(d)
                    r += dr[p[di]]
                    c += dc[p[di]]
                    if r < 0 or r >= rows or c < 0 or (c >= cols) or (b[r][c] == '#'):
                        break
                    if b[r][c] == 'E':
                        ok = 1
                res += ok
print(res)
```

### 198

```python
n, m = map(int, input().split())
money = [0] * n
for i in range(n):
    x, y = map(int, input().split())
    money[i] = (y, x - 1)
money.sort()

def calc(lim):
    visited = [False] * n
    cost = 0
    cnt = [2] * m
    for i in range(n):
        cnt[money[i][1]] += 1
    for i in range(n):
        if money[i][1] != 0 and cnt[money[i][1]] >= lim:
            cnt[money[i][1]] -= 1
            cnt[0] += 1
            cost += money[i][0]
            visited[i] = True
    for i in range(n):
        if cnt[0] >= lim:
            break
        if money[i][1] != 0 and (not visited[i]):
            cnt[money[i][1]] -= 1
            cnt[0] += 1
            cost += money[i][0]
    return cost
ans = 10 ** 18
for i in range(n):
    ans = min(ans, calc(i))
print(ans)
```

### 199

```python
def solve(s):
    if len(s) == 2:
        return 1 if s[0] == s[1] else 2
    elif len(s) == 3:
        if s[0] == s[1] == s[2]:
            return 1
        elif s[0] == s[1] or s[1] == s[2]:
            return 6
        elif s[0] == s[2]:
            return 7
        else:
            return 3
    if all((a == b for a, b in zip(s, s[1:]))):
        return 1
    dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
    dp[0][0][0] = 1
    dp[0][1][1] = 1
    dp[0][2][2] = 1
    MOD = 998244355
    for _ in range(len(s) - 1):
        ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
        ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
        ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
        ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
        ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
        ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
        ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
        ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
        ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
        ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
        ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
        ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
        ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
        dp = ndp
    return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
```

### 200

```python
import sys
from math import gcd

class Segment:

    def __init__(self, x1, y1, x2, y2):
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2

    def dx(self):
        return self.x2 - self.x1

    def dy(self):
        return self.y2 - self.y1

    def pt_cnt(self):
        return gcd(abs(self.dx()), abs(self.dy())) + 1

    def A(self):
        return self.y1 - self.y2

    def B(self):
        return self.x2 - self.x1

    def C(self):
        return -self.A() * self.x1 - self.B() * self.y1

    def inner_x(self, x):
        l = self.x1
        r = self.x2
        if l > r:
            l, r = (r, l)
        return l <= x <= r

    def inner_y(self, y):
        l = self.y1
        r = self.y2
        if l > r:
            l, r = (r, l)
        return l <= y < r

    def inner(self, x, y):
        return self.inner_x(x) and self.inner_y(y)

    def intersect(self, other):
        dx = det(self.C(), self.B(), other.C(), other.B())
        dy = det(self.A(), self.C(), other.A(), other.C())
        d = det(self.A(), self.B(), other.A(), other.B())
        if d == 0:
            return (False, 0, 0)
        if dx % d != 0 or dy % d != 0:
            return (False, 0, 0)
        x = -dx // d
        y = -dy // d
        if not self.inner(x, y) or not other.inner(x, y):
            return (False, 0, 0)
        return (True, x, y)

def det(a, b, c, d):
    return a * d - b * c

def main():
    n = int(input())
    segments = []
    ans = 0
    for _ in range(n):
        x1, y1, x2, y2 = map(int, input().split())
        segment = Segment(x1, y1, x2, y2)
        ans += segment.pt_cnt()
        pt = set()
        for other in segments:
            result, x, y = segment.intersect(other)
            if result:
                pt.add((x, y))
        ans -= len(pt)
        segments.append(segment)
    print(ans)

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

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