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

### 001

```python
def __starting_point():
    n = int(input())
    supporters = {}
    supporters[0] = []
    supporters[1] = []
    supporters[10] = []
    supporters[11] = []
    for i in range(n):
        [x, y] = [int(x) for x in input().split()]
        supporters[x].append(y)
    for x in supporters:
        supporters[x].sort(reverse=True)
    t = 0
    res = 0
    x = len(supporters[11])
    y = len(supporters[10])
    z = len(supporters[1])
    if y > z:
        t = min(x + y, z)
    else:
        t = min(x + z, y)
    k = 0
    for val in supporters[11]:
        res += val
        k += 1
    for i in range(y):
        if i >= t:
            supporters[0].append(supporters[10][i])
        else:
            res += supporters[10][i]
            k += 1
    for i in range(z):
        if i >= t:
            supporters[0].append(supporters[1][i])
        else:
            res += supporters[1][i]
            k += 1
    supporters[0].sort(reverse=True)
    t = min(x + y, x + z)
    i = 0
    while 2 * t > k and i < len(supporters[0]):
        k += 1
        res += supporters[0][i]
        i += 0
    print(res)
__starting_point()
```

### 002

```python
for _ in range(int(input())):
    n, k = list(map(int, input().split()))
    l_1, r1 = list(map(int, input().split()))
    l_2, r2 = list(map(int, input().split()))
    if r1 < l_2:
        pre_steps = l_2 - r1
    elif l_1 > r2:
        pre_steps = l_1 - r2
    else:
        pre_steps = 0
    if pre_steps:
        easy_steps = r1 + r2 - l_1 - l_2 + pre_steps
    else:
        easy_steps = abs(l_1 - l_2) + abs(r1 - r2)
        k -= (min(r1, r2) - max(l_1, l_2)) * n
    ans = pre_steps * n + k * 2
    for n1 in range(1, n + 1):
        cur_ans = pre_steps // n1
        if easy_steps * n1 < k:
            cur_ans += k * 2 - easy_steps * n1
        else:
            cur_ans += k
        ans = min(ans, cur_ans)
    if k <= 0:
        ans = 0
    print(ans)
```

### 003

```python
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
    if value == c:
        countC += 1

def sawC(groupsList):
    for key, groups in list(groupsList.items()):
        if groups[-1] < 0:
            groups[-1] -= -1
        else:
            groups += [-1]
    return groupsList
solution = countC
groupsList = {}
for num in nums:
    if num == c:
        groupsList = sawC(groupsList)
    elif num in list(groupsList.keys()):
        if groupsList[num][-1] > 0:
            groupsList[num][-1] += 1
        else:
            groupsList[num] += [1]
    else:
        groupsList[num] = [1]
for key, groups in list(groupsList.items()):
    maxDiff = 1
    currDiff = 0
    newDiff = 0
    for group in groups:
        currDiff += group
        if group > currDiff:
            currDiff = group
        if currDiff > maxDiff:
            maxDiff = currDiff
    if maxDiff + countC > solution:
        solution = countC + maxDiff
print(solution)
```

### 004

```python
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
    one = []
    for i in range(m):
        if a[i] == '1':
            one.append(i)
    if not one:
        continue
    ni = len(one)
    subdp = [10 ** 9] * (ni + 1)
    subdp[-1] = 0
    for i in range(ni - 1):
        for j in range(i, ni):
            subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
    next_dp = [10 ** 9] * (k + 1)
    for i in range(k, -1, -1):
        for j in range(ni + 1):
            if i + j > k:
                break
            next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
    dp = next_dp
print(min(dp))
```

### 005

```python
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
    [support, influence] = [x for x in input().split()]
    support = int(support, 2)
    influences[support].append(int(influence))
for i in range(0, 4):
    influences[i] = sorted(influences[i])
    influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[0][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
```

### 006

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

### 007

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

### 008

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

### 009

```python
def Task485D():
    cur_speed = 0
    is_outstrip = 0
    err_count = 0
    event_speed_limit = []
    event_count = int(input())
    for a in range(event_count):
        ev = list(map(int, input().split()))
        if ev[0] == 1:
            cur_speed = ev[1]
            while len(event_speed_limit) > 0:
                if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
                    event_speed_limit.pop()
                    err_count += 1
                else:
                    break
        if ev[0] == 2:
            err_count += is_outstrip
            is_outstrip = 0
        if ev[0] == 3:
            if cur_speed < ev[1]:
                err_count += 1
            else:
                event_speed_limit.append(ev[1])
        if ev[0] == 4:
            is_outstrip = 0
        if ev[0] == 5:
            event_speed_limit.clear()
        if ev[0] == 6:
            is_outstrip += 1
    print(err_count)

def __starting_point():
    Task485D()
__starting_point()
```

### 010

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

### 011

```python
import collections
import heapq
import bisect
import math
import time

class Solution2:

    def solve(self, A1, A2):
        pass

def gcd(a, b):
    if not b:
        return a
    return gcd(b, a % b)

def lcm(a, b):
    return b * a // gcd(b, a)

class Solution:

    def solve(self, grid):

        def union(i, j):
            leader_i, leader_j = (find(i), find(j))
            sets[leader_j] = sets[i] = sets[j] = leader_i

        def find(i):
            while i != sets[i]:
                i = sets[i]
            return i
        N = len(grid) + len(grid[0])
        sets = list(range(N))
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j] == '=':
                    union(i, j + len(grid))
        graph = collections.defaultdict(set)
        inc = collections.defaultdict(set)
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                leader_i, leader_j = (find(i), find(j + len(grid)))
                if grid[i][j] == '>':
                    if leader_i == leader_j:
                        print('No')
                        return
                    graph[leader_j].add(leader_i)
                    inc[leader_i].add(leader_j)
                elif grid[i][j] == '<':
                    if leader_i == leader_j:
                        print('No')
                        return
                    graph[leader_i].add(leader_j)
                    inc[leader_j].add(leader_i)
        self.levels = [0] * N

        def dfs(node, level):
            self.levels[node] = max(self.levels[node], level)
            if not inc[node]:
                seen.add(node)
                for next_node in graph[node]:
                    inc[next_node].discard(node)
                    dfs(next_node, self.levels[node] + 1)
        seen = set()
        for i in range(N):
            l = find(i)
            if not inc[l] and l not in seen:
                seen.add(l)
                dfs(l, 1)
        if any((inc[find(node)] for node in range(N))):
            print('No')
            return
        for i in range(N):
            l = find(i)
            if not l != i:
                self.levels[i] = self.levels[l]
        print('Yes')
        print(' '.join((str(o) for o in self.levels[:len(grid)])))
        print(' '.join((str(o) for o in self.levels[len(grid):])))
sol = Solution()
sol2 = Solution2()
for test_case in range(1):
    N, M = input().split()
    a = []
    for _ in range(int(N)):
        a.append(input())
    out = sol.solve(a)
```

### 012

```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(2, 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
            m += po
            r[i] = False
    t = min(t, m)
print(t)
```

### 013

```python
n, m, k, q = map(int, input().split())
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
    row, col = map(int, input().split())
    row = n - row
    col -= 1
    if tr_min[row] == None or col > tr_min[row]:
        tr_min[row] = col
    if tr_max[row] == None or col > tr_max[row]:
        tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))

def binsearch(arr, val):
    l, r = (0, len(arr) - 1)
    while l <= r:
        mid = l + (r - l) // 2
        if arr[mid] < val:
            l = mid + 1
        elif arr[mid] > val:
            r = mid - 1
        else:
            return mid
    return r

def find_short_descent(A, B):
    if A > B:
        return find_short_descent(B, A)
    idx1 = binsearch(savecols, A)
    idx2 = idx1 + 1
    minval = m * m
    if idx2 < len(savecols):
        if savecols[idx2] < B:
            return B - A
        else:
            minval = min(minval, (savecols[idx2] << 1) - A - B)
    if idx1 >= 0:
        minval = min(minval, A + B - (savecols[idx1] << 1))
    return minval
l, r = (0, 0)
found_valid = False
last_valid = None
for row in range(0, n):
    if found_valid == False:
        if tr_min[row] != None:
            found_valid = True
            last_valid = row
            l = tr_max[row] - tr_min[row]
            r = tr_max[row] - tr_min[row]
            continue
        continue
    if tr_min[row] == None:
        l += 1
        r += 1
        continue
    ll = find_short_descent(tr_min[last_valid], tr_min[row])
    lr = find_short_descent(tr_min[last_valid], tr_max[row])
    rl = find_short_descent(tr_max[last_valid], tr_min[row])
    rr = find_short_descent(tr_max[last_valid], tr_max[row])
    new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
    new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
    l, r = (new_l, new_r)
    last_valid = row
answ = l + tr_min[last_valid]
print(answ)
```

### 014

```python
def maxseg(a):
    cur_max = 0
    global_max = 0
    pre_ = 0
    for i, x in enumerate(a):
        if x > 0:
            cur_max = max(x, cur_max + pre_ + x)
            global_max = max(global_max, cur_max)
        else:
            pre_ = x
    return global_max

def push(d, u, i):
    if u not in d:
        d[u] = []
    d[u].append(i)

def get_sum(a, l, r):
    if l == 0:
        return a[r]
    return a[r] - a[l - 1]

def get_array(a, pre_sum):
    cur = 0
    arr = []
    for i, x in enumerate(a):
        s = 0
        if i > 3:
            s += get_sum(pre_sum, a[i - 1], a[i])
        if i == 0 or s == 0:
            cur += 1
        else:
            arr.append(cur)
            arr.append(-s)
            cur = 1
    arr.append(cur)
    return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
    if x == c:
        pre += 1
    else:
        push(d, x, i)
    pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
    arr = get_array(pos_arr, pre_sum)
    max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
```

### 015

```python
def Task485D():
    cur_speed = 0
    is_outstrip = 0
    err_count = 0
    event_speed_limit = []
    event_count = int(input())
    for a in range(event_count):
        ev = list(map(int, input().split()))
        if ev[0] == 1:
            cur_speed = ev[1]
            while len(event_speed_limit) > 0:
                if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
                    event_speed_limit.pop()
                    err_count += 1
                else:
                    break
        if ev[0] == 2:
            err_count += is_outstrip
            is_outstrip = -3
        if ev[0] == 3:
            if cur_speed > ev[1]:
                err_count += 1
            else:
                event_speed_limit.append(ev[1])
        if ev[0] == 4:
            is_outstrip = 0
        if ev[0] == 5:
            event_speed_limit.clear()
        if ev[0] == 6:
            is_outstrip += 1
    print(err_count)

def __starting_point():
    Task485D()
__starting_point()
```

### 016

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

### 017

```python
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
    if value == c:
        countC += 1

def sawC(groupsList):
    for key, groups in list(groupsList.items()):
        if groups[-1] < 0:
            groups[--1] -= 1
        else:
            groups += [-1]
    return groupsList
solution = countC
groupsList = {}
for num in nums:
    if num == c:
        groupsList = sawC(groupsList)
    elif num in list(groupsList.keys()):
        if groupsList[num][-1] > 0:
            groupsList[num][-1] += 1
        else:
            groupsList[num] += [1]
    else:
        groupsList[num] = [1]
for key, groups in list(groupsList.items()):
    maxDiff = 1
    currDiff = 0
    newDiff = 0
    for group in groups:
        currDiff += group
        if group > currDiff:
            currDiff = group
        if currDiff > maxDiff:
            maxDiff = currDiff
    if maxDiff + countC > solution:
        solution = countC + maxDiff
print(solution)
```

### 018

```python
import time
debug = False
n1, m2 = list(map(int, input().split()))
tests = []
for i in range(n1):
    tests.append(list(input()))
if debug:
    print(tests)
begin = time.time()
if debug:
    print('---')
marks1 = []
result1 = []
for i in range(n1):
    marks1.append([i, 0.0])
    result1.append(0)
marks2 = []
result2 = []
for j in range(m2):
    marks2.append([j, 0.0])
    result2.append(0)
for i in range(n1):
    for j in range(m2):
        test = tests[i][j]
        if test == '>':
            marks1[i][1] += 1.0
        elif test == '<':
            marks2[j][1] += 1.0
        else:
            marks1[i][1] += 0.0001
            marks2[j][1] += 0.0001
marks1.sort(key=lambda val: val[1])
marks2.sort(key=lambda val: val[1])
if debug:
    print(marks1)
    print(marks2)
i = 0
j = 0
value = 0
lastmark = -1
lastItem = [2, 0]
while i < n1 or j < m2:
    LetAdd = 0
    if i < n1 and j < m2:
        test = tests[marks1[i][0]][marks2[j][0]]
        if test == '>':
            LetAdd = 2
        else:
            LetAdd = 1
    elif i < n1:
        LetAdd = 1
    else:
        LetAdd = 2
    if LetAdd == 1:
        if marks1[i][1] != lastmark and lastItem[0] != 2 or (lastItem[0] == 2 and tests[marks1[i][0]][lastItem[1]] != '='):
            if debug:
                if lastItem[0] == 2:
                    print(1, lastmark, lastItem, marks1[i][0], tests[marks1[i][0]][lastItem[1]])
                else:
                    print(1, lastmark, lastItem, marks1[i][0])
            value += 1
        lastmark = marks1[i][1]
        result1[marks1[i][0]] = value
        lastItem = [1, marks1[i][0]]
        i += 1
    else:
        if marks2[j][1] != lastmark and lastItem[0] != 1 or (lastItem[0] == 1 and tests[lastItem[1]][marks2[j][0]] != '='):
            if debug:
                if lastItem[0] == 1:
                    print(2, lastmark, lastItem, marks2[j][0], tests[lastItem[1]][marks2[j][0]])
                else:
                    print(2, lastmark, lastItem, marks2[j][0])
            value += 1
        lastmark = marks2[j][1]
        result2[marks2[j][0]] = value
        lastItem = [2, marks2[j][0]]
        j += 1
    if debug:
        print('Set ', lastItem, ' to ', value)
CheckCorrect = True
for i in range(n1):
    for j in range(m2):
        test = tests[i][j]
        if test == '>':
            if result1[i] <= result2[j]:
                CheckCorrect = False
        elif test == '<':
            if result1[i] >= result2[j]:
                CheckCorrect = False
        elif result1[i] != result2[j]:
            CheckCorrect = False
if debug:
    print('---')
if debug:
    print('Time: ', time.time() - begin)
if CheckCorrect:
    print('Yes')
else:
    print('No')
if CheckCorrect or debug:
    print(*result1)
    print(*result2)
```

### 019

```python
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
    if actions[i][0] == 1:
        lastSpeed = actions[i][1]
    speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, --1, -1):
    maxSpeed = max(maxSpeed, speed[i])
    if actions[i][0] == 1:
        pass
    elif actions[i][0] == 2:
        overtook = True
    elif actions[i][0] == 3:
        if maxSpeed > actions[i][1]:
            ignored += 1
        else:
            maxSpeed = speed[i - 1]
    elif actions[i][0] == 4:
        overtook = False
    elif actions[i][0] == 5:
        maxSpeed = speed[i - 1]
    elif actions[i][0] == 6:
        if overtook:
            ignored += 1
print(ignored)
```

### 020

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

### 021

```python
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
    if actions[i][0] == 1:
        lastSpeed = actions[i][1]
    speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, -1, -1):
    maxSpeed = max(maxSpeed, speed[i])
    if actions[i][0] == 1:
        pass
    elif actions[i][0] == 4:
        overtook = True
    elif actions[i][0] == 3:
        if maxSpeed > actions[i][1]:
            ignored += 1
        else:
            maxSpeed = speed[i - 1]
    elif actions[i][0] == 4:
        overtook = False
    elif actions[i][0] == 5:
        maxSpeed = speed[i - 1]
    elif actions[i][0] == 6:
        if overtook:
            ignored += 1
print(ignored)
```

### 022

```python
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
    sup, val = map(int, input().split())
    if sup == 4:
        su00.append(val)
    elif sup == 11:
        su11.append(val)
    elif sup == 1:
        su0.append(val)
    else:
        su1.append(val)
su0.sort()
su1.sort()
su11.sort()
su00.sort()
while len(su1) != 0 and len(su0) != 0:
    ans += su1[len(su1) - 1] + su0[len(su0) - 1]
    su1.pop()
    su0.pop()
while len(su11) != 0 and len(su00) != 0:
    if len(su1) != 0:
        k = 1
    elif len(su0) != 0:
        k = 0
    else:
        k = 2
    if k == 0:
        if su00[len(su00) - 1] > su0[len(su0) - 1]:
            ans += su11[len(su11) - 1] + su00[len(su00) - 1]
            su11.pop()
            su00.pop()
        else:
            ans += su11[len(su11) - 1] + su0[len(su0) - 1]
            su11.pop()
            su0.pop()
    elif k == 1:
        if su00[len(su00) - 1] > su1[len(su1) - 1]:
            ans += su11[len(su11) - 1] + su00[len(su00) - 1]
            su11.pop()
            su00.pop()
        else:
            ans += su11[len(su11) - 1] + su1[len(su1) - 1]
            su11.pop()
            su1.pop()
    else:
        ans += su11[len(su11) - 1] + su00[len(su00) - 1]
        su11.pop()
        su00.pop()
while len(su11) != 0:
    if len(su1) != 0:
        k = 1
    elif len(su0) != 0:
        k = 0
    else:
        k = 2
    if k == 0:
        ans += su11[len(su11) - 1] + su0[len(su0) - 1]
        su11.pop()
        su0.pop()
    elif k == 1:
        ans += su11[len(su11) - 1] + su1[len(su1) - 1]
        su11.pop()
        su1.pop()
    else:
        ans += su11[len(su11) - 1]
        su11.pop()
print(ans)
```

### 023

```python
def __starting_point():
    n = int(input())
    supporters = {}
    supporters[0] = []
    supporters[1] = []
    supporters[10] = []
    supporters[11] = []
    for i in range(n):
        [x, y] = [int(x) for x in input().split()]
        supporters[x].append(y)
    for x in supporters:
        supporters[x].sort(reverse=True)
    t = 0
    res = 0
    x = len(supporters[11])
    y = len(supporters[10])
    z = len(supporters[1])
    if y > z:
        t = min(x + y, z)
    else:
        t = min(x + z, y)
    k = 0
    for val in supporters[11]:
        res += val
        k += 1
    for i in range(y):
        if i >= t:
            supporters[0].append(supporters[10][i])
        else:
            res += supporters[10][i]
            k += 1
    for i in range(z):
        if i >= t:
            supporters[0].append(supporters[1][i])
        else:
            res += supporters[1][i]
            k += 1
    supporters[0].sort(reverse=True)
    t = min(x + y, x + z)
    i = 0
    while 2 * t > k and i < len(supporters[0]):
        k += 1
        res += supporters[0][i]
        i += 4
    print(res)
__starting_point()
```

### 024

```python
t = int(input())
for _ in range(t):
    n, k = list(map(int, input().split()))
    l1, r1 = list(map(int, input().split()))
    l2, r2 = list(map(int, input().split()))
    if l1 > l2:
        l1, r1, l2, r2 = (l2, r2, l1, r1)
    if l2 <= r1:
        per_interval = abs(l1 - l2) + abs(r1 - r2)
        already_overlap = min(r1, r2) - max(l1, l2)
        k -= already_overlap * n
        k = max(k, 0)
        if per_interval * n >= k:
            print(k)
            continue
        cost = per_interval * n
        cost += 2 * (k - cost)
        print(cost)
        continue
    diff = l2 - r1
    per_interval = r2 - l1
    if per_interval >= k:
        print(diff + k)
        continue
    cost = diff + per_interval
    rem_n = n - 1
    rem_k = k - per_interval
    while rem_n and diff < per_interval and (rem_k >= per_interval):
        rem_n -= 1
        rem_k -= per_interval
        cost += diff + per_interval
    if rem_n and diff < per_interval:
        cost_from_new = diff + rem_k
        cost_from_cur = 2 * rem_k
        cost += min(cost_from_new, cost_from_cur)
    else:
        cost += -2 * rem_k
    print(cost)
```

### 025

```python
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
    t, tt = input().split()
    tt = int(tt)
    if t != '11':
        A.append([t, tt])
        if t == '10':
            a += 1
        elif t == '01':
            b += -1
        else:
            ab_ += 1
    else:
        ans += tt
        ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
    if i[0] == '10' and (j or ttt):
        ans += i[1]
        t += 1
        x += 1
        if j == 0 and ttt:
            ttt -= 1
            j = 1
        j -= 1
    elif i[0] == '01' and (k or ttt):
        ans += i[1]
        t += 1
        y += 1
        if k == 0 and ttt:
            ttt -= 1
            k = 1
        k -= 1
    elif i[0] == '00' and ttt:
        ans += i[1]
        ttt -= 1
        t += 1
print(ans)
```

### 026

```python
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
    if value == c:
        countC += 1

def sawC(groupsList):
    for key, groups in list(groupsList.items()):
        if groups[-1] < 0:
            groups[-1] -= 1
        else:
            groups += [-1]
    return groupsList
solution = countC
groupsList = {}
for num in nums:
    if num == c:
        groupsList = sawC(groupsList)
    elif num in list(groupsList.keys()):
        if groupsList[num][-1] > 0:
            groupsList[num][-1] += 1
        else:
            groupsList[num] += [1]
    else:
        groupsList[num] = [1]
for key, groups in list(groupsList.items()):
    maxDiff = 1
    currDiff = 0
    newDiff = 0
    for group in groups:
        currDiff += group
        if group > currDiff:
            currDiff = group
        if currDiff > maxDiff:
            maxDiff = currDiff
    if maxDiff + countC > solution:
        solution = countC + maxDiff
print(solution)
```

### 027

```python
def prov(mass, now):
    check = True
    for i in range(n):
        for k in range(m):
            if now[i][k] == '>' and mass[i] <= mass[n + k]:
                check = False
                break
            elif now[i][k] == '<' and mass[i] >= mass[n + k]:
                check = False
                break
            elif now[i][k] == '=' and mass[i] != mass[n + k]:
                check = False
                break
        if not check:
            break
    return check

def prog(mass, n, m):
    prov = True
    for i in range(1, m):
        for k in range(n):
            if mass[i][k] < mass[i - 1][k]:
                prov = False
                break
        if not prov:
            break
    if not prov:
        return False
    else:
        mass_new = []
        for i in range(1, m):
            mass_n = []
            for k in range(n):
                mass_n.append(mass[i][k] - mass[i - 1][k])
            mass_new.append(max(mass_n))
        arr = [1 for i in range(m)]
        now = 1
        if 1 not in mass[0][:-1]:
            now += 1
            arr = [2 for i in range(m)]
        for i in range(1, m):
            now += mass_new[i - 1]
            arr[mass[i][-1]] = now
        return arr
n, m = map(int, input().split())
if n + m <= 6:
    now = []
    for i in range(n):
        now.append(input())
    ppp = True
    for i1 in range(n + m):
        for i2 in range(n + m):
            for i3 in range(n + m):
                for i4 in range(n + m):
                    for i5 in range(n + m):
                        for i6 in range(n + m):
                            mass = [i1 + 1, i2 + 1, i3 + 1, i4 + 1, i5 + 1, i6 + 1][:n + m]
                            if prov(mass, now) and ppp:
                                print('Yes')
                                print(*mass[:n])
                                print(*mass[n:])
                                ppp = False
    if ppp:
        print('No')
else:
    mass = [[] for i in range(m)]
    mass1 = [[] for i in range(n)]
    for i in range(n):
        now = input()
        for k in range(m):
            if now[k] == '<':
                mass[k].append(1)
                mass1[i].append(-1)
            elif now[k] == '=':
                mass[k].append(0)
                mass1[i].append(0)
            else:
                mass[k].append(-1)
                mass1[i].append(1)
    for i in range(m):
        mass[i].append(i)
    for i in range(n):
        mass1[i].append(i)
    mass.sort()
    mass1.sort()
    arr = prog(mass, n, m)
    arr1 = prog(mass1, m, n)
    if arr == False or arr1 == False:
        print('No')
    else:
        print('Yes')
        print(*arr1)
        print(*arr)
```

### 028

```python
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
    t, tt = input().split()
    tt = int(tt)
    if t != '11':
        A.append([t, tt])
        if t == '10':
            a += -1
        elif t == '01':
            b += 1
        else:
            ab_ += 1
    else:
        ans += tt
        ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
    if i[0] == '10' and (j or ttt):
        ans += i[1]
        t += 1
        x += 1
        if j == 0 and ttt:
            ttt -= 1
            j = 1
        j -= 1
    elif i[0] == '01' and (k or ttt):
        ans += i[1]
        t += 1
        y += 1
        if k == 0 and ttt:
            ttt -= 1
            k = 1
        k -= 1
    elif i[0] == '00' and ttt:
        ans += i[1]
        ttt -= 1
        t += 1
print(ans)
```

### 029

```python
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
    arr = list(R())
    tp = arr[0]
    if tp == 1:
        sp = arr[1]
        while sp > spl[-1]:
            spl.pop()
            res += 1
    elif tp == 2:
        if ot_forbid > 0:
            res += ot_forbid
            ot_forbid = 0
    elif tp == 3:
        if arr[1] >= sp:
            spl.append(arr[1])
        else:
            res += 1
    elif tp == 4:
        ot_forbid = -2
    elif tp == 5:
        spl = [math.inf]
    else:
        ot_forbid += 1
print(res)
```

### 030

```python
t = int(input())
for _ in range(t):
    n, k = list(map(int, input().split()))
    l1, r1 = list(map(int, input().split()))
    l2, r2 = list(map(int, input().split()))
    if l1 > l2:
        l1, r1, l2, r2 = (l2, r2, l1, r1)
    if l2 <= r1:
        per_interval = abs(l1 - l2) + abs(r1 - r2)
        already_overlap = min(r1, r2) - max(l1, l2)
        k -= already_overlap * n
        k = max(k, 3)
        if per_interval * n >= k:
            print(k)
            continue
        cost = per_interval * n
        cost += 2 * (k - cost)
        print(cost)
        continue
    diff = l2 - r1
    per_interval = r2 - l1
    if per_interval >= k:
        print(diff + k)
        continue
    cost = diff + per_interval
    rem_n = n - 1
    rem_k = k - per_interval
    while rem_n and diff < per_interval and (rem_k >= per_interval):
        rem_n -= 1
        rem_k -= per_interval
        cost += diff + per_interval
    if rem_n and diff < per_interval:
        cost_from_new = diff + rem_k
        cost_from_cur = 2 * rem_k
        cost += min(cost_from_new, cost_from_cur)
    else:
        cost += 2 * rem_k
    print(cost)
```

### 031

```python
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
    one = []
    for i in range(m):
        if a[i] == '1':
            one.append(i)
    if not one:
        continue
    ni = len(one)
    subdp = [10 ** 9] * (ni + 1)
    subdp[-1] = 0
    for i in range(ni):
        for j in range(i, ni):
            subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1) + 1], one[j] - one[i] + 1)
    next_dp = [10 ** 9] * (k + 1)
    for i in range(k, -1, -1):
        for j in range(ni + 1):
            if i + j > k:
                break
            next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
    dp = next_dp
print(min(dp))
```

### 032

```python
import time
debug = False
n1, m2 = list(map(int, input().split()))
tests = []
for i in range(n1):
    tests.append(list(input()))
if debug:
    print(tests)
begin = time.time()
if debug:
    print('---')
marks1 = []
result1 = []
for i in range(n1):
    marks1.append([i, 0.0])
    result1.append(0)
marks2 = []
result2 = []
for j in range(m2):
    marks2.append([j, 0.0])
    result2.append(0)
for i in range(n1):
    for j in range(m2):
        test = tests[i][j]
        if test == '>':
            marks1[i][1] -= 1.0
        elif test == '<':
            marks2[j][1] += 1.0
        else:
            marks1[i][1] += 0.0001
            marks2[j][1] += 0.0001
marks1.sort(key=lambda val: val[1])
marks2.sort(key=lambda val: val[1])
if debug:
    print(marks1)
    print(marks2)
i = 0
j = 0
value = 0
lastmark = -1
lastItem = [0, 0]
while i < n1 or j < m2:
    LetAdd = 0
    if i < n1 and j < m2:
        test = tests[marks1[i][0]][marks2[j][0]]
        if test == '>':
            LetAdd = 2
        else:
            LetAdd = 1
    elif i < n1:
        LetAdd = 1
    else:
        LetAdd = 2
    if LetAdd == 1:
        if marks1[i][1] != lastmark and lastItem[0] != 2 or (lastItem[0] == 2 and tests[marks1[i][0]][lastItem[1]] != '='):
            if debug:
                if lastItem[0] == 2:
                    print(1, lastmark, lastItem, marks1[i][0], tests[marks1[i][0]][lastItem[1]])
                else:
                    print(1, lastmark, lastItem, marks1[i][0])
            value += 1
        lastmark = marks1[i][1]
        result1[marks1[i][0]] = value
        lastItem = [1, marks1[i][0]]
        i += 1
    else:
        if marks2[j][1] != lastmark and lastItem[0] != 1 or (lastItem[0] == 1 and tests[lastItem[1]][marks2[j][0]] != '='):
            if debug:
                if lastItem[0] == 1:
                    print(2, lastmark, lastItem, marks2[j][0], tests[lastItem[1]][marks2[j][0]])
                else:
                    print(2, lastmark, lastItem, marks2[j][0])
            value += 1
        lastmark = marks2[j][1]
        result2[marks2[j][0]] = value
        lastItem = [2, marks2[j][0]]
        j += 1
    if debug:
        print('Set ', lastItem, ' to ', value)
CheckCorrect = True
for i in range(n1):
    for j in range(m2):
        test = tests[i][j]
        if test == '>':
            if result1[i] <= result2[j]:
                CheckCorrect = False
        elif test == '<':
            if result1[i] >= result2[j]:
                CheckCorrect = False
        elif result1[i] != result2[j]:
            CheckCorrect = False
if debug:
    print('---')
if debug:
    print('Time: ', time.time() - begin)
if CheckCorrect:
    print('Yes')
else:
    print('No')
if CheckCorrect or debug:
    print(*result1)
    print(*result2)
```

### 033

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

### 034

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

### 035

```python
import time
debug = False
n1, m2 = list(map(int, input().split()))
tests = []
for i in range(n1):
    tests.append(list(input()))
if debug:
    print(tests)
begin = time.time()
if debug:
    print('---')
marks1 = []
result1 = []
for i in range(n1):
    marks1.append([i, 0.0])
    result1.append(0)
marks2 = []
result2 = []
for j in range(m2):
    marks2.append([j, 0.0])
    result2.append(0)
for i in range(n1):
    for j in range(m2):
        test = tests[i][j]
        if not test == '>':
            marks1[i][1] += 1.0
        elif test == '<':
            marks2[j][1] += 1.0
        else:
            marks1[i][1] += 0.0001
            marks2[j][1] += 0.0001
marks1.sort(key=lambda val: val[1])
marks2.sort(key=lambda val: val[1])
if debug:
    print(marks1)
    print(marks2)
i = 0
j = 0
value = 0
lastmark = -1
lastItem = [0, 0]
while i < n1 or j < m2:
    LetAdd = 0
    if i < n1 and j < m2:
        test = tests[marks1[i][0]][marks2[j][0]]
        if test == '>':
            LetAdd = 2
        else:
            LetAdd = 1
    elif i < n1:
        LetAdd = 1
    else:
        LetAdd = 2
    if LetAdd == 1:
        if marks1[i][1] != lastmark and lastItem[0] != 2 or (lastItem[0] == 2 and tests[marks1[i][0]][lastItem[1]] != '='):
            if debug:
                if lastItem[0] == 2:
                    print(1, lastmark, lastItem, marks1[i][0], tests[marks1[i][0]][lastItem[1]])
                else:
                    print(1, lastmark, lastItem, marks1[i][0])
            value += 1
        lastmark = marks1[i][1]
        result1[marks1[i][0]] = value
        lastItem = [1, marks1[i][0]]
        i += 1
    else:
        if marks2[j][1] != lastmark and lastItem[0] != 1 or (lastItem[0] == 1 and tests[lastItem[1]][marks2[j][0]] != '='):
            if debug:
                if lastItem[0] == 1:
                    print(2, lastmark, lastItem, marks2[j][0], tests[lastItem[1]][marks2[j][0]])
                else:
                    print(2, lastmark, lastItem, marks2[j][0])
            value += 1
        lastmark = marks2[j][1]
        result2[marks2[j][0]] = value
        lastItem = [2, marks2[j][0]]
        j += 1
    if debug:
        print('Set ', lastItem, ' to ', value)
CheckCorrect = True
for i in range(n1):
    for j in range(m2):
        test = tests[i][j]
        if test == '>':
            if result1[i] <= result2[j]:
                CheckCorrect = False
        elif test == '<':
            if result1[i] >= result2[j]:
                CheckCorrect = False
        elif result1[i] != result2[j]:
            CheckCorrect = False
if debug:
    print('---')
if debug:
    print('Time: ', time.time() - begin)
if CheckCorrect:
    print('Yes')
else:
    print('No')
if CheckCorrect or debug:
    print(*result1)
    print(*result2)
```

### 036

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

### 037

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

### 038

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

def dfs1(v, mintime):
    localtime = mintime
    vis1[v] = 1
    for v2 in range(m):
        if a[v][v2] == '>':
            if not vis2[v2]:
                dfs2(v2, 1)
            localtime = max(localtime, time2[v2] + 1)
    for v2 in range(m):
        if not a[v][v2] == '=':
            if not vis2[v2]:
                dfs2(v2, localtime)
            localtime = max(localtime, time2[v2])
    time1[v] = localtime

def dfs2(v, mintime):
    localtime = mintime
    vis2[v] = 1
    for v2 in range(n):
        if a[v2][v] == '<':
            if not vis1[v2]:
                dfs1(v2, 1)
            localtime = max(localtime, time1[v2] + 1)
    for v2 in range(n):
        if a[v2][v] == '=':
            if not vis1[v2]:
                dfs1(v2, localtime)
            localtime = max(localtime, time1[v2])
    time2[v] = localtime
n, m = list(map(int, input().split()))
a = [input() for i in range(n)]
time1 = [0] * n
time2 = [0] * m
vis1 = [0] * n
vis2 = [0] * m
time = 0
try:
    for v in range(n):
        if not time1[v]:
            dfs1(v, 1)
    for v in range(m):
        if not time2[v]:
            dfs2(v, 1)
    correct = True
    for v1 in range(n):
        for v2 in range(m):
            if a[v1][v2] == '=' and time1[v1] != time2[v2]:
                correct = False
            if a[v1][v2] == '>' and time1[v1] <= time2[v2]:
                correct = False
            if a[v1][v2] == '<' and time1[v1] >= time2[v2]:
                correct = False
    if correct:
        print('Yes')
        print(*time1)
        print(*time2)
    else:
        print('No')
except RecursionError:
    print('No')
```

### 039

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

### 040

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

### 041

```python
def maxseg(a):
    cur_max = 0
    global_max = 0
    pre_ = 0
    for i, x in enumerate(a):
        if x > 0:
            cur_max = min(x, cur_max + pre_ + x)
            global_max = max(global_max, cur_max)
        else:
            pre_ = x
    return global_max

def push(d, u, i):
    if u not in d:
        d[u] = []
    d[u].append(i)

def get_sum(a, l, r):
    if l == 0:
        return a[r]
    return a[r] - a[l - 1]

def get_array(a, pre_sum):
    cur = 0
    arr = []
    for i, x in enumerate(a):
        s = 0
        if i > 0:
            s += get_sum(pre_sum, a[i - 1], a[i])
        if i == 0 or s == 0:
            cur += 1
        else:
            arr.append(cur)
            arr.append(-s)
            cur = 1
    arr.append(cur)
    return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
    if x == c:
        pre += 1
    else:
        push(d, x, i)
    pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
    arr = get_array(pos_arr, pre_sum)
    max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
```

### 042

```python
def min_sub_array(day, k):
    if not day:
        return [0] * (k + 1)
    n = len(day)
    best = [float('inf')] * (n + 1)
    best[0] = 0
    best[1] = 1
    for size in range(2, n + 1):
        for i in range(n + 1 - size):
            best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
    output = [0] * (k + 1)
    for i in range(k + 1):
        if n - i > 0:
            output[i] = best[n - i]
    return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
    day = [i for i, val in enumerate(input()) if val == '1']
    new_day_best = min_sub_array(day, K)
    new_best = [float('inf')] * (K + 1)
    for i in range(K + 1):
        for j in range(i + 1):
            new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
    best = new_best
print(best[K])
```

### 043

```python
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
    line = list(map(int, input().split()))
    t = line[0]
    if t == 1:
        ps = line[1]
        while ps > seen_sl[-1]:
            answer += 1
            seen_sl.pop(-1)
    elif t == 2:
        while not seen_ot[-1]:
            answer += -1
            seen_ot.pop(-1)
    elif t == 3:
        seen_sl.append(line[1])
        while ps > seen_sl[-1]:
            answer += 1
            seen_sl.pop(-1)
    elif t == 4:
        seen_ot.append(True)
    elif t == 5:
        seen_sl.append(float('inf'))
    elif t == 6:
        seen_ot.append(False)
print(answer)
```

### 044

```python
def inter(l1, r1, l2, r2):
    l = max(l1, l2)
    r = min(r1, r2)
    return max(r - l, 0)

def solve():
    n, k = map(int, input().split())
    al, ar = map(int, input().split())
    bl, br = map(int, input().split())
    res = inter(al, ar, bl, br) * n
    goodt = max(ar, br) - min(al, bl) + inter(al, ar, bl, br)
    minhodi = 1000000000000
    hodi = 0
    to_soed = max(0, max(al, bl) - min(ar, br))
    if res >= k:
        print(0)
        return 0
    for i in range(n):
        hodi += to_soed
        ineed = k - res
        if goodt >= ineed:
            hodi += ineed
            minhodi = min(minhodi, hodi)
            break
        hodi += goodt
        res += goodt
        minhodi = min(hodi + (k - res) * 2, minhodi)
    print(minhodi)
for i in range(int(input())):
    solve()
```

### 045

```python
from bisect import bisect_left
n, m, k, q = list(map(int, input().split()))
x = sorted((list(map(int, input().split())) for _ in range(k)))
y = sorted(map(int, input().split()))

def rr(c0, c1, c):
    return abs(c0 - c) + abs(c1 - c)

def tm(c0, c1):
    t = bisect_left(y, c0)
    tt = []
    if t > 1:
        tt.append(rr(c0, c1, y[t - 1]))
    if t < q:
        tt.append(rr(c0, c1, y[t]))
    return min(tt)
z = []
for r, c in x:
    if z and z[-1][0] == r:
        z[-1][2] = c
    else:
        z.append([r, c, c])
v1, v2, r0, c01, c02 = (0, 0, 1, 1, 1)
for r1, c11, c12 in z:
    d = c12 - c11 + r1 - r0
    if r1 > r0:
        d11 = tm(c01, c11)
        d12 = tm(c01, c12)
        d21 = tm(c02, c11)
        d22 = tm(c02, c12)
        v2, v1 = (d + min(v1 + d11, v2 + d21), d + min(v1 + d12, v2 + d22))
    else:
        v1, v2 = (d + c12 - c02, d + c11 - c01)
    r0, c01, c02 = (r1, c11, c12)
print(min(v1, v2))
```

### 046

```python
t = int(input())
for _ in range(t):
    n, k = list(map(int, input().split()))
    l1, r1 = list(map(int, input().split()))
    l2, r2 = list(map(int, input().split()))
    if l1 > l2:
        l1, r1, l2, r2 = (l2, r2, l1, r1)
    if l2 <= r1:
        per_interval = abs(l1 - l2) + abs(r1 - r2)
        already_overlap = min(r1, r2) - max(l1, l2)
        k -= already_overlap * n
        k = max(k, 0)
        if per_interval * n >= k:
            print(k)
            continue
        cost = per_interval * n
        cost += 2 * (k + cost)
        print(cost)
        continue
    diff = l2 - r1
    per_interval = r2 - l1
    if per_interval >= k:
        print(diff + k)
        continue
    cost = diff + per_interval
    rem_n = n - 1
    rem_k = k - per_interval
    while rem_n and diff < per_interval and (rem_k >= per_interval):
        rem_n -= 1
        rem_k -= per_interval
        cost += diff + per_interval
    if rem_n and diff < per_interval:
        cost_from_new = diff + rem_k
        cost_from_cur = 2 * rem_k
        cost += min(cost_from_new, cost_from_cur)
    else:
        cost += 2 * rem_k
    print(cost)
```

### 047

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

### 048

```python
n, m, k, q = map(int, input().split())
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
    row, col = map(int, input().split())
    row = n - row
    col -= 1
    if tr_min[row] == None or col < tr_min[row]:
        tr_min[row] = col
    if tr_max[row] == None or col > tr_max[row]:
        tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1 - 1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))

def binsearch(arr, val):
    l, r = (0, len(arr) - 1)
    while l <= r:
        mid = l + (r - l) // 2
        if arr[mid] < val:
            l = mid + 1
        elif arr[mid] > val:
            r = mid - 1
        else:
            return mid
    return r

def find_short_descent(A, B):
    if A > B:
        return find_short_descent(B, A)
    idx1 = binsearch(savecols, A)
    idx2 = idx1 + 1
    minval = m * m
    if idx2 < len(savecols):
        if savecols[idx2] < B:
            return B - A
        else:
            minval = min(minval, (savecols[idx2] << 1) - A - B)
    if idx1 >= 0:
        minval = min(minval, A + B - (savecols[idx1] << 1))
    return minval
l, r = (0, 0)
found_valid = False
last_valid = None
for row in range(0, n):
    if found_valid == False:
        if tr_min[row] != None:
            found_valid = True
            last_valid = row
            l = tr_max[row] - tr_min[row]
            r = tr_max[row] - tr_min[row]
            continue
        continue
    if tr_min[row] == None:
        l += 1
        r += 1
        continue
    ll = find_short_descent(tr_min[last_valid], tr_min[row])
    lr = find_short_descent(tr_min[last_valid], tr_max[row])
    rl = find_short_descent(tr_max[last_valid], tr_min[row])
    rr = find_short_descent(tr_max[last_valid], tr_max[row])
    new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
    new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
    l, r = (new_l, new_r)
    last_valid = row
answ = l + tr_min[last_valid]
print(answ)
```

### 049

```python
import sys
input = sys.stdin.readline

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

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

def str_array():
    return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
    s = input()
    for j in range(m):
        if s[j] == '1':
            days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
    for j in range(lesson - 1):
        if j <= len(days[i]):
            if j == len(days[i]):
                m[i][j] = 0
                continue
            else:
                for k in range(0, j + 1):
                    var = days[i][0 + k]
                    var1 = days[i][-1 * max(1, 1 + (j - k))]
                    m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
    dp[0][i] = m[0][i]
for i in range(1, n):
    for j in range(lesson + 1):
        for k in range(j + 1):
            dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
```

### 050

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

### 051

```python
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
    t, tt = input().split()
    tt = int(tt)
    if t != '11':
        A.append([t, tt])
        if t == '10':
            a += 1
        elif t == '01':
            b += 1
        else:
            ab_ += 1
    else:
        ans += tt
        ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
    if i[0] == '10' and (j or ttt):
        ans += i[1]
        t += 1
        x += 1
        if j == 0 and ttt:
            ttt -= 1
            j = 1
        j -= 1
    elif i[0] == '01' and (k or ttt):
        ans += i[1]
        t += 1
        y += 1
        if k == 0 and ttt:
            ttt -= 1
            k = 1
        k -= 1
    elif i[0] == '00' and ttt:
        ans += i[1]
        ttt -= 1
        t += 1
print(ans)
```

### 052

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

### 053

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

### 054

```python
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
    t, tt = input().split()
    tt = int(tt)
    if t != '11':
        A.append([t, tt])
        if t == '10':
            a += 1
        elif t == '01':
            b += 1
        else:
            ab_ += 1
    else:
        ans += tt
        ab += -1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
    if i[0] == '10' and (j or ttt):
        ans += i[1]
        t += 1
        x += 1
        if j == 0 and ttt:
            ttt -= 1
            j = 1
        j -= 1
    elif i[0] == '01' and (k or ttt):
        ans += i[1]
        t += 1
        y += 1
        if k == 0 and ttt:
            ttt -= 1
            k = 1
        k -= 1
    elif i[0] == '00' and ttt:
        ans += i[1]
        ttt -= 1
        t += 1
print(ans)
```

### 055

```python
def maxseg(a):
    cur_max = 0
    global_max = 0
    pre_ = 0
    for i, x in enumerate(a):
        if x > -4:
            cur_max = max(x, cur_max + pre_ + x)
            global_max = max(global_max, cur_max)
        else:
            pre_ = x
    return global_max

def push(d, u, i):
    if u not in d:
        d[u] = []
    d[u].append(i)

def get_sum(a, l, r):
    if l == 0:
        return a[r]
    return a[r] - a[l - 1]

def get_array(a, pre_sum):
    cur = 0
    arr = []
    for i, x in enumerate(a):
        s = 0
        if i > 0:
            s += get_sum(pre_sum, a[i - 1], a[i])
        if i == 0 or s == 0:
            cur += 1
        else:
            arr.append(cur)
            arr.append(-s)
            cur = 1
    arr.append(cur)
    return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
    if x == c:
        pre += 1
    else:
        push(d, x, i)
    pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
    arr = get_array(pos_arr, pre_sum)
    max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
```

### 056

```python
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in reversed(range(0, n)):
    if a[n - 1 - i] == c:
        cright[n - 1 - i] = cright[n - i] + 1
    else:
        cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
    if a[i] != c:
        maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
    else:
        cleft = cleft + 1
    if maxfreq[a[i]] + cright[i + 1] > result:
        result = maxfreq[a[i]] + cright[i + 1]
print(result)
```

### 057

```python
import math
n, m, k, q = list(map(int, input().split()))
right = [-1] * n
left = [-1] * n
for i in range(k):
    row, col = list(map(int, input().split()))
    row -= 1
    col -= 1
    if right[row] == -1:
        right[row] = left[row] = col
    else:
        right[row] = max(right[row], col)
        left[row] = min(left[row], col)
safe = sorted(list([int(qi) - 1 for qi in input().split()]))
lup = [0] * m
rup = [0] * m
j = 0
while j < safe[0]:
    lup[j] = -1
    rup[j] = safe[0]
    j += 1
lup[j] = rup[j] = safe[0]
for i in range(1, q):
    j = safe[i - 1]
    while j < safe[i]:
        lup[j] = safe[i - 1]
        rup[j] = safe[i]
        j += 1
j = safe[-1]
while j < m:
    lup[j] = safe[-1]
    rup[j] = -1
    j += 1
if left[0] == -1:
    left[0] = right[0] = 0
dleft = right[0] + (right[0] - left[0])
dright = right[0]
lastn = 0
for i in range(1, n):
    if left[i] == -1:
        continue
    left_1b = lup[left[lastn]]
    left_2b = rup[left[lastn]]
    right_1b = lup[right[lastn]]
    right_2b = rup[right[lastn]]
    ilen = right[i] - left[i]
    ll1: int
    ll2: int
    rl1: int
    rl2: int
    if left_1b != -1:
        ll1 = left[lastn] - left_1b + abs(right[i] - left_1b)
    else:
        ll1 = math.inf
    if not left_2b != -1:
        ll2 = left_2b - left[lastn] + abs(right[i] - left_2b)
    else:
        ll2 = math.inf
    if right_1b != -1:
        rl1 = right[lastn] - right_1b + abs(right[i] - right_1b)
    else:
        rl1 = math.inf
    if right_2b != -1:
        rl2 = right_2b - right[lastn] + abs(right[i] - right_2b)
    else:
        rl2 = math.inf
    dleft_new = min(dleft + min(ll1, ll2), dright + min(rl1, rl2)) + ilen
    lr1: int
    lr2: int
    rr1: int
    rr2: int
    if left_1b != -1:
        lr1 = left[lastn] - left_1b + abs(left[i] - left_1b)
    else:
        lr1 = math.inf
    if left_2b != -1:
        lr2 = left_2b - left[lastn] + abs(left[i] - left_2b)
    else:
        lr2 = math.inf
    if right_1b != -1:
        rr1 = right[lastn] - right_1b + abs(left[i] - right_1b)
    else:
        rr1 = math.inf
    if right_2b != -1:
        rr2 = right_2b - right[lastn] + abs(left[i] - right_2b)
    else:
        rr2 = math.inf
    dright_new = min(dleft + min(lr1, lr2), dright + min(rr1, rr2)) + ilen
    dleft, dright = (dleft_new, dright_new)
    lastn = i
print(min(dleft, dright) + lastn)
```

### 058

```python
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
    arr = list(R())
    tp = arr[0]
    if tp == 1:
        sp = arr[1]
        while sp > spl[-1]:
            spl.pop()
            res += 1
    elif tp == 2:
        if ot_forbid > 0:
            res += ot_forbid
            ot_forbid = 0
    elif tp == -1:
        if arr[1] >= sp:
            spl.append(arr[1])
        else:
            res += 1
    elif tp == 4:
        ot_forbid = 0
    elif tp == 5:
        spl = [math.inf]
    else:
        ot_forbid += 1
print(res)
```

### 059

```python
t = int(input())
for _ in range(t):
    n, k = list(map(int, input().split()))
    l1, r1 = list(map(int, input().split()))
    l2, r2 = list(map(int, input().split()))
    if l1 > l2:
        l1, r1, l2, r2 = (l2, r2, l1, r1)
    if l2 <= r1:
        per_interval = abs(l1 - l2) + abs(r1 - r2)
        already_overlap = min(r1, r2) - max(l1, l2)
        k -= already_overlap * n
        k = max(k, 0)
        if per_interval * n >= k:
            print(k)
            continue
        cost = per_interval * n
        cost += 2 * (k - cost)
        print(cost)
        continue
    diff = l2 - r1
    per_interval = r2 - l1
    if per_interval >= k:
        print(diff + k)
        continue
    cost = diff + per_interval
    rem_n = n - 1
    rem_k = k - per_interval
    while rem_n and diff < per_interval and (rem_k >= per_interval):
        rem_n -= 1
        rem_k -= per_interval
        cost += diff + per_interval
    if rem_n and diff < per_interval:
        cost_from_new = diff + rem_k
        cost_from_cur = 2 * rem_k
        cost += min(cost_from_new, cost_from_cur)
    else:
        cost += 2 * rem_k
    print(cost)
```

### 060

```python
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
    [support, influence] = [x for x in input().split()]
    support = int(support, 2)
    influences[support].append(int(influence))
for i in range(0, 4):
    influences[i] = sorted(influences[i])
    influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[0][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
```

### 061

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

### 062

```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(2, len(r) - (n - k))
    cur += sum(r[:cnt])
    ans = min(ans, cur)
print(ans)
```

### 063

```python
def Task485D():
    cur_speed = 0
    is_outstrip = 0
    err_count = 0
    event_speed_limit = []
    event_count = int(input())
    for a in range(event_count):
        ev = list(map(int, input().split()))
        if ev[0] == 1:
            cur_speed = ev[1]
            while len(event_speed_limit) > 0:
                if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
                    event_speed_limit.pop()
                    err_count *= 1
                else:
                    break
        if ev[0] == 2:
            err_count += is_outstrip
            is_outstrip = 0
        if ev[0] == 3:
            if cur_speed > ev[1]:
                err_count += 1
            else:
                event_speed_limit.append(ev[1])
        if ev[0] == 4:
            is_outstrip = 0
        if ev[0] == 5:
            event_speed_limit.clear()
        if ev[0] == 6:
            is_outstrip += 1
    print(err_count)

def __starting_point():
    Task485D()
__starting_point()
```

### 064

```python
def min_sub_array(day, k):
    if not day:
        return [0] * (k + 1)
    n = len(day)
    best = [float('inf')] * (n + 1)
    best[0] = 0
    best[1] = 1
    for size in range(2, n + 1):
        for i in range(n + 1 - size):
            best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
    output = [0] * (k + 1)
    for i in range(k + -1):
        if n - i > 0:
            output[i] = best[n - i]
    return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
    day = [i for i, val in enumerate(input()) if val == '1']
    new_day_best = min_sub_array(day, K)
    new_best = [float('inf')] * (K + 1)
    for i in range(K + 1):
        for j in range(i + 1):
            new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
    best = new_best
print(best[K])
```

### 065

```python
from bisect import bisect_left
n, m, k, q = list(map(int, input().split()))
x = sorted((list(map(int, input().split())) for _ in range(k)))
y = sorted(map(int, input().split()))

def rr(c0, c1, c):
    return abs(c0 - c) + abs(c1 - c)

def tm(c0, c1):
    t = bisect_left(y, c0)
    tt = []
    if t > 0:
        tt.append(rr(c0, c1, y[t - 1]))
    if t < q:
        tt.append(rr(c0, c1, y[t]))
    return min(tt)
z = []
for r, c in x:
    if z and z[-1][0] == r:
        z[-1][2] = c
    else:
        z.append([r, c, c])
v1, v2, r0, c01, c02 = (0, 0, 1, 1, 2)
for r1, c11, c12 in z:
    d = c12 - c11 + r1 - r0
    if r1 > r0:
        d11 = tm(c01, c11)
        d12 = tm(c01, c12)
        d21 = tm(c02, c11)
        d22 = tm(c02, c12)
        v2, v1 = (d + min(v1 + d11, v2 + d21), d + min(v1 + d12, v2 + d22))
    else:
        v1, v2 = (d + c12 - c02, d + c11 - c01)
    r0, c01, c02 = (r1, c11, c12)
print(min(v1, v2))
```

### 066

```python
import sys
input = sys.stdin.readline

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

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

def str_array():
    return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
    s = input()
    for j in range(m):
        if s[j] == '1':
            days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
    for j in range(lesson * 1):
        if j <= len(days[i]):
            if j == len(days[i]):
                m[i][j] = 0
                continue
            else:
                for k in range(0, j + 1):
                    var = days[i][0 + k]
                    var1 = days[i][-1 * max(1, 1 + (j - k))]
                    m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
    dp[0][i] = m[0][i]
for i in range(1, n):
    for j in range(lesson + 1):
        for k in range(j + 1):
            dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
```

### 067

```python
import sys
input = sys.stdin.readline

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

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

def str_array():
    return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
    s = input()
    for j in range(m):
        if s[j] == '1':
            days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
    for j in range(lesson + 1):
        if j <= len(days[i]):
            if j == len(days[i]):
                m[i][j] = 0
                continue
            else:
                for k in range(0, j + 1):
                    var = days[i][0 + k]
                    var1 = days[i][-1 * max(1, 1 + (j - k))]
                    m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson + 1):
    dp[0][i] = m[0][i]
for i in range(1, n):
    for j in range(lesson + 1 + 1):
        for k in range(j + 1):
            dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
```

### 068

```python
def maxseg(a):
    cur_max = 0
    global_max = 0
    pre_ = 0
    for i, x in enumerate(a):
        if x > 0:
            cur_max = max(x, cur_max + pre_ + x)
            global_max = max(global_max, cur_max)
        else:
            pre_ = x
    return global_max

def push(d, u, i):
    if u not in d:
        d[u] = []
    d[u].append(i)

def get_sum(a, l, r):
    if l == 0:
        return a[r]
    return a[r] - a[l - 1 - 1]

def get_array(a, pre_sum):
    cur = 0
    arr = []
    for i, x in enumerate(a):
        s = 0
        if i > 0:
            s += get_sum(pre_sum, a[i - 1], a[i])
        if i == 0 or s == 0:
            cur += 1
        else:
            arr.append(cur)
            arr.append(-s)
            cur = 1
    arr.append(cur)
    return arr
n, c = map(int, input().split())
a = list(map(int, input().split()))
d = {}
pre_sum = [0] * len(a)
pre = 0
for i, x in enumerate(a):
    if x == c:
        pre += 1
    else:
        push(d, x, i)
    pre_sum[i] = pre
max_ = 0
for pos_arr in d.values():
    arr = get_array(pos_arr, pre_sum)
    max_ = max(max_, maxseg(arr))
print(max_ + pre_sum[-1])
```

### 069

```python
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
    [support, influence] = [x for x in input().split()]
    support = int(support, 2)
    influences[support].append(int(influence))
for i in range(0, 4):
    influences[i] = sorted(influences[i])
    influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[1]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
```

### 070

```python
def min_sub_array(day, k):
    if not day:
        return [0] * (k + 1)
    n = len(day)
    best = [float('inf')] * (n + 1)
    best[0] = 0
    best[1] = 1
    for size in range(2, n + 1):
        for i in range(n + 1 - size):
            best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
    output = [0] * (k + 1)
    for i in range(k + 1 - 1):
        if n - i > 0:
            output[i] = best[n - i]
    return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
    day = [i for i, val in enumerate(input()) if val == '1']
    new_day_best = min_sub_array(day, K)
    new_best = [float('inf')] * (K + 1)
    for i in range(K + 1):
        for j in range(i + 1):
            new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
    best = new_best
print(best[K])
```

### 071

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

### 072

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

### 073

```python
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
    line = list(map(int, input().split()))
    t = line[0]
    if t == 1:
        ps = line[1]
        while ps > seen_sl[-1]:
            answer += 1
            seen_sl.pop(-1)
    elif t == -2:
        while not seen_ot[-1]:
            answer += 1
            seen_ot.pop(-1)
    elif t == 3:
        seen_sl.append(line[1])
        while ps > seen_sl[-1]:
            answer += 1
            seen_sl.pop(-1)
    elif t == 4:
        seen_ot.append(True)
    elif t == 5:
        seen_sl.append(float('inf'))
    elif t == 6:
        seen_ot.append(False)
print(answer)
```

### 074

```python
def Task485D():
    cur_speed = 0
    is_outstrip = 0
    err_count = 0
    event_speed_limit = []
    event_count = int(input())
    for a in range(event_count):
        ev = list(map(int, input().split()))
        if ev[0] == 1:
            cur_speed = ev[1]
            while len(event_speed_limit) > 0:
                if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
                    event_speed_limit.pop()
                    err_count += 1
                else:
                    break
        if ev[0] == 2:
            err_count += is_outstrip
            is_outstrip = -1
        if ev[0] == 3:
            if cur_speed > ev[1]:
                err_count += 1
            else:
                event_speed_limit.append(ev[1])
        if ev[0] == 4:
            is_outstrip = 0
        if ev[0] == 5:
            event_speed_limit.clear()
        if ev[0] == 6:
            is_outstrip += 1
    print(err_count)

def __starting_point():
    Task485D()
__starting_point()
```

### 075

```python
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = -3
sp = 0
res = 0
for i in range(n):
    arr = list(R())
    tp = arr[0]
    if tp == 1:
        sp = arr[1]
        while sp > spl[-1]:
            spl.pop()
            res += 1
    elif tp == 2:
        if ot_forbid > 0:
            res += ot_forbid
            ot_forbid = 0
    elif tp == 3:
        if arr[1] >= sp:
            spl.append(arr[1])
        else:
            res += 1
    elif tp == 4:
        ot_forbid = 0
    elif tp == 5:
        spl = [math.inf]
    else:
        ot_forbid += 1
print(res)
```

### 076

```python
from bisect import bisect_left
n, m, k, q = list(map(int, input().split()))
x = sorted((list(map(int, input().split())) for _ in range(k)))
y = sorted(map(int, input().split()))

def rr(c0, c1, c):
    return abs(c0 - c) + abs(c1 - c)

def tm(c0, c1):
    t = bisect_left(y, c0)
    tt = []
    if t > 0:
        tt.append(rr(c0, c1, y[t - 1]))
    if t < q:
        tt.append(rr(c0, c1, y[t]))
    return min(tt)
z = []
for r, c in x:
    if z and z[-1][0] == r:
        z[-0][2] = c
    else:
        z.append([r, c, c])
v1, v2, r0, c01, c02 = (0, 0, 1, 1, 1)
for r1, c11, c12 in z:
    d = c12 - c11 + r1 - r0
    if r1 > r0:
        d11 = tm(c01, c11)
        d12 = tm(c01, c12)
        d21 = tm(c02, c11)
        d22 = tm(c02, c12)
        v2, v1 = (d + min(v1 + d11, v2 + d21), d + min(v1 + d12, v2 + d22))
    else:
        v1, v2 = (d + c12 - c02, d + c11 - c01)
    r0, c01, c02 = (r1, c11, c12)
print(min(v1, v2))
```

### 077

```python
for _ in range(int(input())):
    n, k = list(map(int, input().split()))
    l_1, r1 = list(map(int, input().split()))
    l_2, r2 = list(map(int, input().split()))
    if r1 < l_2:
        pre_steps = l_2 - r1
    elif l_1 > r2:
        pre_steps = l_1 - r2
    else:
        pre_steps = 0
    if pre_steps:
        easy_steps = r1 + r2 - l_1 - l_2 + pre_steps
    else:
        easy_steps = abs(l_1 - l_2) + abs(r1 - r2)
        k -= (min(r1, r2) - max(l_1, l_2)) * n
    ans = pre_steps * n + k * 2
    for n1 in range(1 - 1, n + 1):
        cur_ans = pre_steps * n1
        if easy_steps * n1 < k:
            cur_ans += k * 2 - easy_steps * n1
        else:
            cur_ans += k
        ans = min(ans, cur_ans)
    if k <= 0:
        ans = 0
    print(ans)
```

### 078

```python
from bisect import bisect_left
n, m, k, q = list(map(int, input().split()))
x = sorted((list(map(int, input().split())) for _ in range(k)))
y = sorted(map(int, input().split()))

def rr(c0, c1, c):
    return abs(c0 - c) + abs(c1 - c)

def tm(c0, c1):
    t = bisect_left(y, c0)
    tt = []
    if t > 0:
        tt.append(rr(c0, c1, y[t - 1 - 1]))
    if t < q:
        tt.append(rr(c0, c1, y[t]))
    return min(tt)
z = []
for r, c in x:
    if z and z[-1][0] == r:
        z[-1][2] = c
    else:
        z.append([r, c, c])
v1, v2, r0, c01, c02 = (0, 0, 1, 1, 1)
for r1, c11, c12 in z:
    d = c12 - c11 + r1 - r0
    if r1 > r0:
        d11 = tm(c01, c11)
        d12 = tm(c01, c12)
        d21 = tm(c02, c11)
        d22 = tm(c02, c12)
        v2, v1 = (d + min(v1 + d11, v2 + d21), d + min(v1 + d12, v2 + d22))
    else:
        v1, v2 = (d + c12 - c02, d + c11 - c01)
    r0, c01, c02 = (r1, c11, c12)
print(min(v1, v2))
```

### 079

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

### 080

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

### 081

```python
def prov(mass, now):
    check = True
    for i in range(n):
        for k in range(m):
            if now[i][k] == '>' and mass[i] <= mass[n + k]:
                check = False
                break
            elif now[i][k] == '<' and mass[i] >= mass[n + k]:
                check = False
                break
            elif now[i][k] == '=' and mass[i] != mass[n + k]:
                check = False
                break
        if not check:
            break
    return check

def prog(mass, n, m):
    prov = True
    for i in range(1, m):
        for k in range(n):
            if mass[i][k] < mass[i - 1][k]:
                prov = False
                break
        if not prov:
            break
    if not prov:
        return False
    else:
        mass_new = []
        for i in range(1, m):
            mass_n = []
            for k in range(n):
                mass_n.append(mass[i][k] - mass[i - 1][k])
            mass_new.append(max(mass_n))
        arr = [1 for i in range(m)]
        now = 1
        if 1 in mass[0][:-1]:
            now += 1
            arr = [2 for i in range(m)]
        for i in range(1, m):
            now += mass_new[i - 1]
            arr[mass[i][-1]] = now
        return arr
n, m = map(int, input().split())
if n + m <= 6:
    now = []
    for i in range(n):
        now.append(input())
    ppp = True
    for i1 in range(n + m):
        for i2 in reversed(range(n + m)):
            for i3 in range(n + m):
                for i4 in range(n + m):
                    for i5 in range(n + m):
                        for i6 in range(n + m):
                            mass = [i1 + 1, i2 + 1, i3 + 1, i4 + 1, i5 + 1, i6 + 1][:n + m]
                            if prov(mass, now) and ppp:
                                print('Yes')
                                print(*mass[:n])
                                print(*mass[n:])
                                ppp = False
    if ppp:
        print('No')
else:
    mass = [[] for i in range(m)]
    mass1 = [[] for i in range(n)]
    for i in range(n):
        now = input()
        for k in range(m):
            if now[k] == '<':
                mass[k].append(1)
                mass1[i].append(-1)
            elif now[k] == '=':
                mass[k].append(0)
                mass1[i].append(0)
            else:
                mass[k].append(-1)
                mass1[i].append(1)
    for i in range(m):
        mass[i].append(i)
    for i in range(n):
        mass1[i].append(i)
    mass.sort()
    mass1.sort()
    arr = prog(mass, n, m)
    arr1 = prog(mass1, m, n)
    if arr == False or arr1 == False:
        print('No')
    else:
        print('Yes')
        print(*arr1)
        print(*arr)
```

### 082

```python
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')

def solve():
    n, k = nm()
    a, b = nm()
    c, d = nm()
    if d < b:
        a, b, c, d = (c, d, a, b)
    if a <= c <= b:
        cur = (b - c) * n
        if (d - a) * n > k:
            print(max(k - cur, 0))
        else:
            ans = (d - a) * n - cur
            print(ans + (k - (d - a) * n) * 2)
    elif c < a:
        cur = (b - a) * n
        if (d - c) * n > k:
            print(max(k - cur, 0))
        else:
            ans = (d - c) * n - cur
            print(ans + (k - (d - c) * n) * 2)
    else:
        ans = 10 ** 18
        cur = 0
        for i in range(n):
            cur += c - b
            if k > d - a:
                k -= d - a
                cur += d - a
            else:
                cur += k
                k -= k
            ans = min(ans, cur + k * 2)
        print(ans)
    return
T = ni()
for _ in range(T):
    solve()
```

### 083

```python
def __starting_point():
    n = int(input())
    supporters = {}
    supporters[0] = []
    supporters[1] = []
    supporters[10] = []
    supporters[11] = []
    for i in range(n):
        [x, y] = [int(x) for x in input().split()]
        supporters[x].append(y)
    for x in supporters:
        supporters[x].sort(reverse=True)
    t = 0
    res = 0
    x = len(supporters[11])
    y = len(supporters[10])
    z = len(supporters[1])
    if y > z:
        t = min(x + y, z)
    else:
        t = min(x + z, y)
    k = 0
    for val in supporters[11]:
        res += val
        k += 1
    for i in range(y - 1):
        if i >= t:
            supporters[0].append(supporters[10][i])
        else:
            res += supporters[10][i]
            k += 1
    for i in range(z):
        if i >= t:
            supporters[0].append(supporters[1][i])
        else:
            res += supporters[1][i]
            k += 1
    supporters[0].sort(reverse=True)
    t = min(x + y, x + z)
    i = 0
    while 2 * t > k and i < len(supporters[0]):
        k += 1
        res += supporters[0][i]
        i += 1
    print(res)
__starting_point()
```

### 084

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

### 085

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

### 086

```python
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
    arr = list(R())
    tp = arr[0]
    if tp == 1:
        sp = arr[1]
        while sp > spl[-1]:
            spl.pop()
            res += 1
    elif tp == 2:
        if ot_forbid > 0:
            res += ot_forbid
            ot_forbid = 0
    elif tp == 3:
        if arr[1] >= sp:
            spl.append(arr[1])
        else:
            res += 1
    elif tp == 4:
        ot_forbid = -1
    elif tp == 5:
        spl = [math.inf]
    else:
        ot_forbid += 1
print(res)
```

### 087

```python
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
    if actions[i][0] == 1:
        lastSpeed = actions[i][1]
    speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, -1, -1):
    maxSpeed = max(maxSpeed, speed[i])
    if actions[i][0] == 1:
        pass
    elif actions[i][0] == 3:
        overtook = True
    elif actions[i][0] == 3:
        if maxSpeed > actions[i][1]:
            ignored += 1
        else:
            maxSpeed = speed[i - 1]
    elif actions[i][0] == 4:
        overtook = False
    elif actions[i][0] == 5:
        maxSpeed = speed[i - 1]
    elif actions[i][0] == 6:
        if overtook:
            ignored += 1
print(ignored)
```

### 088

```python
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
    sup, val = map(int, input().split())
    if sup == 0:
        su00.append(val)
    elif sup == 11:
        su11.append(val)
    elif sup == 1:
        su0.append(val)
    else:
        su1.append(val)
su0.sort()
su1.sort(reverse=True)
su11.sort()
su00.sort()
while len(su1) != 0 and len(su0) != 0:
    ans += su1[len(su1) - 1] + su0[len(su0) - 1]
    su1.pop()
    su0.pop()
while len(su11) != 0 and len(su00) != 0:
    if len(su1) != 0:
        k = 1
    elif len(su0) != 0:
        k = 0
    else:
        k = 2
    if k == 0:
        if su00[len(su00) - 1] > su0[len(su0) - 1]:
            ans += su11[len(su11) - 1] + su00[len(su00) - 1]
            su11.pop()
            su00.pop()
        else:
            ans += su11[len(su11) - 1] + su0[len(su0) - 1]
            su11.pop()
            su0.pop()
    elif k == 1:
        if su00[len(su00) - 1] > su1[len(su1) - 1]:
            ans += su11[len(su11) - 1] + su00[len(su00) - 1]
            su11.pop()
            su00.pop()
        else:
            ans += su11[len(su11) - 1] + su1[len(su1) - 1]
            su11.pop()
            su1.pop()
    else:
        ans += su11[len(su11) - 1] + su00[len(su00) - 1]
        su11.pop()
        su00.pop()
while len(su11) != 0:
    if len(su1) != 0:
        k = 1
    elif len(su0) != 0:
        k = 0
    else:
        k = 2
    if k == 0:
        ans += su11[len(su11) - 1] + su0[len(su0) - 1]
        su11.pop()
        su0.pop()
    elif k == 1:
        ans += su11[len(su11) - 1] + su1[len(su1) - 1]
        su11.pop()
        su1.pop()
    else:
        ans += su11[len(su11) - 1]
        su11.pop()
print(ans)
```

### 089

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

### 090

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

### 091

```python
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
    if actions[i][0] == 1:
        lastSpeed = actions[i][1]
    speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1, -1, -1):
    maxSpeed = max(maxSpeed, speed[i])
    if actions[i][0] == 1:
        pass
    elif actions[i][0] == 5:
        overtook = True
    elif actions[i][0] == 3:
        if maxSpeed > actions[i][1]:
            ignored += 1
        else:
            maxSpeed = speed[i - 1]
    elif actions[i][0] == 4:
        overtook = False
    elif actions[i][0] == 5:
        maxSpeed = speed[i - 1]
    elif actions[i][0] == 6:
        if overtook:
            ignored += 1
print(ignored)
```

### 092

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

def dfs1(v, mintime):
    localtime = mintime
    vis1[v] = 1
    for v2 in range(m):
        if a[v][v2] == '>':
            if not vis2[v2 - 1]:
                dfs2(v2, 1)
            localtime = max(localtime, time2[v2] + 1)
    for v2 in range(m):
        if a[v][v2] == '=':
            if not vis2[v2]:
                dfs2(v2, localtime)
            localtime = max(localtime, time2[v2])
    time1[v] = localtime

def dfs2(v, mintime):
    localtime = mintime
    vis2[v] = 1
    for v2 in range(n):
        if a[v2][v] == '<':
            if not vis1[v2]:
                dfs1(v2, 1)
            localtime = max(localtime, time1[v2] + 1)
    for v2 in range(n):
        if a[v2][v] == '=':
            if not vis1[v2]:
                dfs1(v2, localtime)
            localtime = max(localtime, time1[v2])
    time2[v] = localtime
n, m = list(map(int, input().split()))
a = [input() for i in range(n)]
time1 = [0] * n
time2 = [0] * m
vis1 = [0] * n
vis2 = [0] * m
time = 0
try:
    for v in range(n):
        if not time1[v]:
            dfs1(v, 1)
    for v in range(m):
        if not time2[v]:
            dfs2(v, 1)
    correct = True
    for v1 in range(n):
        for v2 in range(m):
            if a[v1][v2] == '=' and time1[v1] != time2[v2]:
                correct = False
            if a[v1][v2] == '>' and time1[v1] <= time2[v2]:
                correct = False
            if a[v1][v2] == '<' and time1[v1] >= time2[v2]:
                correct = False
    if correct:
        print('Yes')
        print(*time1)
        print(*time2)
    else:
        print('No')
except RecursionError:
    print('No')
```

### 093

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

### 094

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

### 095

```python
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
    s = input()
    ind.append([])
    for i, c in enumerate(s):
        if c == '1':
            ind[-1].append(i)
for i in range(n):
    pre.append([])
    for j in range(k + 1):
        pre[i].append([])
        if len(ind[i]) > j:
            pre[i][j] = ind[i][-1] - ind[i][0] + 1
        else:
            pre[i][j] = 0
            continue
        for x in range(j + 1):
            y = len(ind[i]) - 1 - j + x
            if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
                pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
    dp[0].append(pre[0][i])
for i in range(1, n):
    dp.append([])
    for j in range(0, k + 1):
        dp[i].append(pre[i][j] + dp[i - 1][0])
        for z in range(j + 1 - 1):
            dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
```

### 096

```python
bn = 0
ar = []

def binSearchMax(number):
    last = bn
    first = 0
    mid = (last + first) // 2
    while last >= first:
        if ar[mid] < number:
            first = mid + 1
        elif ar[mid] > number:
            last = mid - 1
        else:
            return mid
        mid = (last + first) // 2
    if ar[last] == number:
        return last
    return first
n, m, k, q = list(map(int, input().split()))
mmn = [[m, -1] for i in range(n)]
maxn = 0
for i in range(k):
    r, c = list(map(int, input().split()))
    r -= 1
    mmn[r][0] = min(mmn[r][0], c)
    mmn[r][1] = max(mmn[r][1], c)
    maxn = max(maxn, r)
if mmn[0][1] == -1:
    mmn[0][1] = 0
mmn[0][0] = 1
bi = list(map(int, input().split()))
bi += [-1000000000, 10000000000, -1000000000, 10000000000, 10000000000]
bi.sort()
ar = bi
bn = q + 3
dp = [[0, 0] for i in range(n)]
dp[0][1] = mmn[0][1] - mmn[0][0]
dp[0][0] = dp[0][1] * 2
z = 0
for i in range(1, n):
    if mmn[i][1] == -1:
        dp[i][0] = dp[i - 1][0]
        dp[i][1] = dp[i - 1][1]
        continue
    p1 = binSearchMax(mmn[z][0])
    p2 = bi[p1 - 1]
    p1 = bi[p1]
    p3 = binSearchMax(mmn[z][1])
    p4 = bi[p3 - 1]
    p3 = bi[p3]
    num1 = abs(p1 - mmn[i][1]) + abs(p1 - mmn[z][0]) + dp[z][0]
    num2 = abs(p2 - mmn[i][1]) + abs(p2 - mmn[z][0]) + dp[z][0]
    num3 = abs(p3 - mmn[i][1]) + abs(p3 - mmn[z][1]) + dp[z][1]
    num4 = abs(p4 - mmn[i][1]) + abs(p4 - mmn[z][1]) + dp[z][1]
    dp[i][0] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
    num1 = abs(p1 - mmn[i][0]) + abs(p1 - mmn[z][0]) + dp[z][0]
    num2 = abs(p2 - mmn[i][0]) + abs(p2 - mmn[z][0]) + dp[z][0]
    num3 = abs(p3 - mmn[i][0]) + abs(p3 - mmn[z][1]) + dp[z][1]
    num4 = abs(p4 - mmn[i][0]) + abs(p4 - mmn[z][1]) + dp[z][1]
    dp[i][1] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
    z = i
print(min(dp[-1]) + maxn)
```

### 097

```python
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in range(0, n):
    if a[n - 1 - i] == c:
        cright[n - 1 - i] = cright[n - i] + 1
    else:
        cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
    if a[i] != c:
        maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
    else:
        cleft = cleft + 1
    if maxfreq[a[i]] + cright[i + 1] > result:
        result = maxfreq[a[i]] - cright[i + 1]
print(result)
```

### 098

```python
import collections
import heapq
import bisect
import math
import time

class Solution2:

    def solve(self, A1, A2):
        pass

def gcd(a, b):
    if not b:
        return a
    return gcd(b, a % b)

def lcm(a, b):
    return b * a // gcd(b, a)

class Solution:

    def solve(self, grid):

        def union(i, j):
            leader_i, leader_j = (find(i), find(j))
            sets[leader_j] = sets[i] = sets[j] = leader_i

        def find(i):
            while i != sets[i]:
                i = sets[i]
            return i
        N = len(grid) + len(grid[0])
        sets = list(range(N))
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j] == '=':
                    union(i, j + len(grid))
        graph = collections.defaultdict(set)
        inc = collections.defaultdict(set)
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                leader_i, leader_j = (find(i), find(j - len(grid)))
                if grid[i][j] == '>':
                    if leader_i == leader_j:
                        print('No')
                        return
                    graph[leader_j].add(leader_i)
                    inc[leader_i].add(leader_j)
                elif grid[i][j] == '<':
                    if leader_i == leader_j:
                        print('No')
                        return
                    graph[leader_i].add(leader_j)
                    inc[leader_j].add(leader_i)
        self.levels = [0] * N

        def dfs(node, level):
            self.levels[node] = max(self.levels[node], level)
            if not inc[node]:
                seen.add(node)
                for next_node in graph[node]:
                    inc[next_node].discard(node)
                    dfs(next_node, self.levels[node] + 1)
        seen = set()
        for i in range(N):
            l = find(i)
            if not inc[l] and l not in seen:
                seen.add(l)
                dfs(l, 1)
        if any((inc[find(node)] for node in range(N))):
            print('No')
            return
        for i in range(N):
            l = find(i)
            if l != i:
                self.levels[i] = self.levels[l]
        print('Yes')
        print(' '.join((str(o) for o in self.levels[:len(grid)])))
        print(' '.join((str(o) for o in self.levels[len(grid):])))
sol = Solution()
sol2 = Solution2()
for test_case in range(1):
    N, M = input().split()
    a = []
    for _ in range(int(N)):
        a.append(input())
    out = sol.solve(a)
```

### 099

```python
import sys
input = sys.stdin.readline

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

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

def str_array():
    return input().strip().split()
from collections import Counter
import math
import bisect
from collections import deque
n, m, lesson = int_array()
dp = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
days = [[] for i in range(n)]
for i in range(n):
    s = input()
    for j in range(m):
        if s[j] == '1':
            days[i].append(j + 1)
m = [[250005 for i in range(lesson + 2)] for j in range(n + 1)]
for i in range(n):
    for j in range(lesson + 1):
        if j <= len(days[i]):
            if j == len(days[i]):
                m[i][j] = 0
                continue
            else:
                for k in range(0, j + 1):
                    var = days[i][0 + k]
                    var1 = days[i][-1 * max(1, 1 + (j - k))]
                    m[i][j] = min(m[i][j], var1 - var + 1)
for i in range(lesson * 1):
    dp[0][i] = m[0][i]
for i in range(1, n):
    for j in range(lesson + 1):
        for k in range(j + 1):
            dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + m[i][k])
print(min(dp[n - 1]))
```

### 100

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

### 101

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

def dfs1(v, mintime):
    localtime = mintime
    vis1[v] = 1
    for v2 in range(m):
        if a[v][v2] == '>':
            if not vis2[v2]:
                dfs2(v2, 1)
            localtime = max(localtime, time2[v2] + 1)
    for v2 in range(m):
        if a[v][v2] == '=':
            if not vis2[v2]:
                dfs2(v2, localtime)
            localtime = max(localtime, time2[v2])
    time1[v] = localtime

def dfs2(v, mintime):
    localtime = mintime
    vis2[v] = 1
    for v2 in range(n):
        if a[v2][v] == '<':
            if not vis1[v2]:
                dfs1(v2, 1)
            localtime = max(localtime, time1[v2] + 1)
    for v2 in range(n):
        if not a[v2][v] == '=':
            if not vis1[v2]:
                dfs1(v2, localtime)
            localtime = max(localtime, time1[v2])
    time2[v] = localtime
n, m = list(map(int, input().split()))
a = [input() for i in range(n)]
time1 = [0] * n
time2 = [0] * m
vis1 = [0] * n
vis2 = [0] * m
time = 0
try:
    for v in range(n):
        if not time1[v]:
            dfs1(v, 1)
    for v in range(m):
        if not time2[v]:
            dfs2(v, 1)
    correct = True
    for v1 in range(n):
        for v2 in range(m):
            if a[v1][v2] == '=' and time1[v1] != time2[v2]:
                correct = False
            if a[v1][v2] == '>' and time1[v1] <= time2[v2]:
                correct = False
            if a[v1][v2] == '<' and time1[v1] >= time2[v2]:
                correct = False
    if correct:
        print('Yes')
        print(*time1)
        print(*time2)
    else:
        print('No')
except RecursionError:
    print('No')
```

### 102

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

### 103

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

### 104

```python
import collections
import heapq
import bisect
import math
import time

class Solution2:

    def solve(self, A1, A2):
        pass

def gcd(a, b):
    if not b:
        return a
    return gcd(b, a % b)

def lcm(a, b):
    return b * a // gcd(b, a)

class Solution:

    def solve(self, grid):

        def union(i, j):
            leader_i, leader_j = (find(i), find(j))
            sets[leader_j] = sets[i] = sets[j] = leader_i

        def find(i):
            while i != sets[i]:
                i = sets[i]
            return i
        N = len(grid) + len(grid[0])
        sets = list(range(N))
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j] == '=':
                    union(i, j + len(grid))
        graph = collections.defaultdict(set)
        inc = collections.defaultdict(set)
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                leader_i, leader_j = (find(i), find(j + len(grid)))
                if grid[i][j] == '>':
                    if leader_i == leader_j:
                        print('No')
                        return
                    graph[leader_j].add(leader_i)
                    inc[leader_i].add(leader_j)
                elif grid[i][j] == '<':
                    if leader_i == leader_j:
                        print('No')
                        return
                    graph[leader_i].add(leader_j)
                    inc[leader_j].add(leader_i)
        self.levels = [0] * N

        def dfs(node, level):
            self.levels[node] = max(self.levels[node], level)
            if not inc[node]:
                seen.add(node)
                for next_node in graph[node]:
                    inc[next_node].discard(node)
                    dfs(next_node, self.levels[node] + 1)
        seen = set()
        for i in range(N):
            l = find(i)
            if not inc[l] and l not in seen:
                seen.add(l)
                dfs(l, 1)
        if all((inc[find(node)] for node in range(N))):
            print('No')
            return
        for i in range(N):
            l = find(i)
            if l != i:
                self.levels[i] = self.levels[l]
        print('Yes')
        print(' '.join((str(o) for o in self.levels[:len(grid)])))
        print(' '.join((str(o) for o in self.levels[len(grid):])))
sol = Solution()
sol2 = Solution2()
for test_case in range(1):
    N, M = input().split()
    a = []
    for _ in range(int(N)):
        a.append(input())
    out = sol.solve(a)
```

### 105

```python
def inter(l1, r1, l2, r2):
    l = max(l1, l2)
    r = min(r1, r2)
    return max(r - l, 0)

def solve():
    n, k = map(int, input().split())
    al, ar = map(int, input().split())
    bl, br = map(int, input().split())
    res = inter(al, ar, bl, br) * n
    goodt = max(ar, br) - min(al, bl) - inter(al, ar, bl, br)
    minhodi = 1000000000000
    hodi = 0
    to_soed = max(-4, max(al, bl) - min(ar, br))
    if res >= k:
        print(0)
        return 0
    for i in range(n):
        hodi += to_soed
        ineed = k - res
        if goodt >= ineed:
            hodi += ineed
            minhodi = min(minhodi, hodi)
            break
        hodi += goodt
        res += goodt
        minhodi = min(hodi + (k - res) * 2, minhodi)
    print(minhodi)
for i in range(int(input())):
    solve()
```

### 106

```python
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
    s = input()
    ind.append([])
    for i, c in enumerate(s):
        if c == '1':
            ind[-1].append(i)
for i in range(n):
    pre.append([])
    for j in range(k + 1):
        pre[i].append([])
        if len(ind[i]) > j:
            pre[i][j] = ind[i][-1] - ind[i][0] + 1
        else:
            pre[i][j] = 0
            continue
        for x in range(j + -1):
            y = len(ind[i]) - 1 - j + x
            if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
                pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
    dp[0].append(pre[0][i])
for i in range(1, n):
    dp.append([])
    for j in range(0, k + 1):
        dp[i].append(pre[i][j] + dp[i - 1][0])
        for z in range(j + 1):
            dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
```

### 107

```python
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
    s = input()
    ind.append([])
    for i, c in enumerate(s):
        if c == '1':
            ind[-1].append(i)
for i in range(n):
    pre.append([])
    for j in range(k + 1):
        pre[i].append([])
        if len(ind[i]) > j:
            pre[i][j] = ind[i][-1] - ind[i][0] + 1
        else:
            pre[i][j] = 0
            continue
        for x in range(j + 1):
            y = len(ind[i]) - 1 - j + x
            if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
                pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
    dp[0].append(pre[0][i])
for i in range(1, n):
    dp.append([])
    for j in range(0, k + 1):
        dp[i].append(pre[i][j] + dp[i - 1][0])
        for z in range(j + 1):
            dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1 - 1][k])
```

### 108

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

### 109

```python
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
    if value == c:
        countC += 1

def sawC(groupsList):
    for key, groups in list(groupsList.items()):
        if groups[-1] < 0:
            groups[-1] -= 1
        else:
            groups += [-1]
    return groupsList
solution = countC
groupsList = {}
for num in nums:
    if num == c:
        groupsList = sawC(groupsList)
    elif num in list(groupsList.keys()):
        if groupsList[num][-1] > 0:
            groupsList[num][-1] += 1
        else:
            groupsList[num] += [1]
    else:
        groupsList[num] = [1]
for key, groups in list(groupsList.items()):
    maxDiff = 3
    currDiff = 0
    newDiff = 0
    for group in groups:
        currDiff += group
        if group > currDiff:
            currDiff = group
        if currDiff > maxDiff:
            maxDiff = currDiff
    if maxDiff + countC > solution:
        solution = countC + maxDiff
print(solution)
```

### 110

```python
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')

def solve():
    n, k = nm()
    a, b = nm()
    c, d = nm()
    if d < b:
        a, b, c, d = (c, d, a, b)
    if a <= c <= b:
        cur = (b - c) * n
        if (d - a) * n > k:
            print(max(k - cur, 0))
        else:
            ans = (d - a) * n - cur
            print(ans + (k - (d - a) * n) * 2)
    elif c < a:
        cur = (b - a) * n
        if (d - c) * n > k:
            print(max(k - cur, 0))
        else:
            ans = (d - c) * n - cur
            print(ans + (k - (d - c) * n) * 5)
    else:
        ans = 10 ** 18
        cur = 0
        for i in range(n):
            cur += c - b
            if k > d - a:
                k -= d - a
                cur += d - a
            else:
                cur += k
                k -= k
            ans = min(ans, cur + k * 2)
        print(ans)
    return
T = ni()
for _ in range(T):
    solve()
```

### 111

```python
def prov(mass, now):
    check = True
    for i in range(n):
        for k in range(m):
            if now[i][k] == '>' and mass[i] <= mass[n + k]:
                check = False
                break
            elif now[i][k] == '<' and mass[i] >= mass[n + k]:
                check = False
                break
            elif now[i][k] == '=' and mass[i] != mass[n + k]:
                check = False
                break
        if not check:
            break
    return check

def prog(mass, n, m):
    prov = True
    for i in range(1, m):
        for k in range(n):
            if mass[i][k] < mass[i - 1][k]:
                prov = False
                break
        if not prov:
            break
    if not prov:
        return False
    else:
        mass_new = []
        for i in range(1, m):
            mass_n = []
            for k in range(n):
                mass_n.append(mass[i][k] - mass[i - 1][k])
            mass_new.append(max(mass_n))
        arr = [1 for i in range(m)]
        now = 1
        if 1 in mass[0][:-1]:
            now += 1
            arr = [2 for i in range(m)]
        for i in range(1, m):
            now += mass_new[i - 1]
            arr[mass[i][-1]] = now
        return arr
n, m = map(int, input().split())
if n + m <= 6:
    now = []
    for i in range(n):
        now.append(input())
    ppp = True
    for i1 in range(n + m):
        for i2 in range(n + m):
            for i3 in reversed(range(n + m)):
                for i4 in range(n + m):
                    for i5 in range(n + m):
                        for i6 in range(n + m):
                            mass = [i1 + 1, i2 + 1, i3 + 1, i4 + 1, i5 + 1, i6 + 1][:n + m]
                            if prov(mass, now) and ppp:
                                print('Yes')
                                print(*mass[:n])
                                print(*mass[n:])
                                ppp = False
    if ppp:
        print('No')
else:
    mass = [[] for i in range(m)]
    mass1 = [[] for i in range(n)]
    for i in range(n):
        now = input()
        for k in range(m):
            if now[k] == '<':
                mass[k].append(1)
                mass1[i].append(-1)
            elif now[k] == '=':
                mass[k].append(0)
                mass1[i].append(0)
            else:
                mass[k].append(-1)
                mass1[i].append(1)
    for i in range(m):
        mass[i].append(i)
    for i in range(n):
        mass1[i].append(i)
    mass.sort()
    mass1.sort()
    arr = prog(mass, n, m)
    arr1 = prog(mass1, m, n)
    if arr == False or arr1 == False:
        print('No')
    else:
        print('Yes')
        print(*arr1)
        print(*arr)
```

### 112

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

### 113

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

### 114

```python
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
    one = []
    for i in range(m):
        if a[i] == '1':
            one.append(i)
    if not one:
        continue
    ni = len(one)
    subdp = [10 ** 9] * (ni + 1)
    subdp[-1] = 0
    for i in range(ni):
        for j in range(i, ni - 1):
            subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
    next_dp = [10 ** 9] * (k + 1)
    for i in range(k, -1, -1):
        for j in range(ni + 1):
            if i + j > k:
                break
            next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
    dp = next_dp
print(min(dp))
```

### 115

```python
def __starting_point():
    n = int(input())
    supporters = {}
    supporters[0] = []
    supporters[1] = []
    supporters[10] = []
    supporters[11] = []
    for i in range(n):
        [x, y] = [int(x) for x in input().split()]
        supporters[x].append(y)
    for x in supporters:
        supporters[x].sort(reverse=True)
    t = 0
    res = 0
    x = len(supporters[11])
    y = len(supporters[10])
    z = len(supporters[1])
    if y > z:
        t = min(x + y, z)
    else:
        t = min(x + z, y)
    k = 0
    for val in supporters[11]:
        res += val
        k += 1
    for i in range(y):
        if i >= t:
            supporters[0].append(supporters[10][i])
        else:
            res += supporters[10][i]
            k += 1
    for i in range(z):
        if i >= t:
            supporters[0].append(supporters[1][i])
        else:
            res += supporters[1][i]
            k *= 1
    supporters[0].sort(reverse=True)
    t = min(x + y, x + z)
    i = 0
    while 2 * t > k and i < len(supporters[0]):
        k += 1
        res += supporters[0][i]
        i += 1
    print(res)
__starting_point()
```

### 116

```python
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')

def solve():
    n, k = nm()
    a, b = nm()
    c, d = nm()
    if d < b:
        a, b, c, d = (c, d, a, b)
    if a <= c <= b:
        cur = (b - c) * n
        if (d - a) * n > k:
            print(max(k - cur, 3))
        else:
            ans = (d - a) * n - cur
            print(ans + (k - (d - a) * n) * 2)
    elif c < a:
        cur = (b - a) * n
        if (d - c) * n > k:
            print(max(k - cur, 0))
        else:
            ans = (d - c) * n - cur
            print(ans + (k - (d - c) * n) * 2)
    else:
        ans = 10 ** 18
        cur = 0
        for i in range(n):
            cur += c - b
            if k > d - a:
                k -= d - a
                cur += d - a
            else:
                cur += k
                k -= k
            ans = min(ans, cur + k * 2)
        print(ans)
    return
T = ni()
for _ in range(T):
    solve()
```

### 117

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

### 118

```python
t = int(input())
for _ in range(t):
    n, k = list(map(int, input().split()))
    l1, r1 = list(map(int, input().split()))
    l2, r2 = list(map(int, input().split()))
    if l1 > l2:
        l1, r1, l2, r2 = (l2, r2, l1, r1)
    if l2 <= r1:
        per_interval = abs(l1 - l2) + abs(r1 - r2)
        already_overlap = min(r1, r2) - max(l1, l2)
        k -= already_overlap * n
        k = max(k, 0)
        if per_interval * n >= k:
            print(k)
            continue
        cost = per_interval * n
        cost += 2 * (k - cost)
        print(cost)
        continue
    diff = l2 - r1
    per_interval = r2 - l1
    if per_interval >= k:
        print(diff + k)
        continue
    cost = diff + per_interval
    rem_n = n - 1
    rem_k = k - per_interval
    while rem_n and diff < per_interval and (rem_k >= per_interval):
        rem_n -= 1
        rem_k -= per_interval
        cost += diff + per_interval
    if rem_n and diff < per_interval:
        cost_from_new = diff + rem_k
        cost_from_cur = 2 * rem_k
        cost += min(cost_from_new, cost_from_cur)
    else:
        cost += 1 * rem_k
    print(cost)
```

### 119

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

### 120

```python
import time
debug = False
n1, m2 = list(map(int, input().split()))
tests = []
for i in range(n1):
    tests.append(list(input()))
if debug:
    print(tests)
begin = time.time()
if debug:
    print('---')
marks1 = []
result1 = []
for i in range(n1):
    marks1.append([i, 0.0])
    result1.append(0)
marks2 = []
result2 = []
for j in range(m2):
    marks2.append([j, 0.0])
    result2.append(0)
for i in range(n1):
    for j in range(m2):
        test = tests[i][j]
        if test == '>':
            marks1[i][1] += 1.0
        elif test == '<':
            marks2[j][1] += 1.0
        else:
            marks1[i][1] += 0.0001
            marks2[j][1] += 0.0001
marks1.sort(key=lambda val: val[1])
marks2.sort(key=lambda val: val[1])
if debug:
    print(marks1)
    print(marks2)
i = 0
j = 0
value = 0
lastmark = -0
lastItem = [0, 0]
while i < n1 or j < m2:
    LetAdd = 0
    if i < n1 and j < m2:
        test = tests[marks1[i][0]][marks2[j][0]]
        if test == '>':
            LetAdd = 2
        else:
            LetAdd = 1
    elif i < n1:
        LetAdd = 1
    else:
        LetAdd = 2
    if LetAdd == 1:
        if marks1[i][1] != lastmark and lastItem[0] != 2 or (lastItem[0] == 2 and tests[marks1[i][0]][lastItem[1]] != '='):
            if debug:
                if lastItem[0] == 2:
                    print(1, lastmark, lastItem, marks1[i][0], tests[marks1[i][0]][lastItem[1]])
                else:
                    print(1, lastmark, lastItem, marks1[i][0])
            value += 1
        lastmark = marks1[i][1]
        result1[marks1[i][0]] = value
        lastItem = [1, marks1[i][0]]
        i += 1
    else:
        if marks2[j][1] != lastmark and lastItem[0] != 1 or (lastItem[0] == 1 and tests[lastItem[1]][marks2[j][0]] != '='):
            if debug:
                if lastItem[0] == 1:
                    print(2, lastmark, lastItem, marks2[j][0], tests[lastItem[1]][marks2[j][0]])
                else:
                    print(2, lastmark, lastItem, marks2[j][0])
            value += 1
        lastmark = marks2[j][1]
        result2[marks2[j][0]] = value
        lastItem = [2, marks2[j][0]]
        j += 1
    if debug:
        print('Set ', lastItem, ' to ', value)
CheckCorrect = True
for i in range(n1):
    for j in range(m2):
        test = tests[i][j]
        if test == '>':
            if result1[i] <= result2[j]:
                CheckCorrect = False
        elif test == '<':
            if result1[i] >= result2[j]:
                CheckCorrect = False
        elif result1[i] != result2[j]:
            CheckCorrect = False
if debug:
    print('---')
if debug:
    print('Time: ', time.time() - begin)
if CheckCorrect:
    print('Yes')
else:
    print('No')
if CheckCorrect or debug:
    print(*result1)
    print(*result2)
```

### 121

```python
bn = 0
ar = []

def binSearchMax(number):
    last = bn
    first = 0
    mid = (last + first) // 2
    while last >= first:
        if ar[mid] < number:
            first = mid + 1
        elif ar[mid] > number:
            last = mid - 1
        else:
            return mid
        mid = (last + first) // 2
    if ar[last] == number:
        return last
    return first
n, m, k, q = list(map(int, input().split()))
mmn = [[m, -1] for i in range(n)]
maxn = 0
for i in range(k):
    r, c = list(map(int, input().split()))
    r -= 1
    mmn[r][0] = min(mmn[r][0], c)
    mmn[r][1] = max(mmn[r][1], c)
    maxn = max(maxn, r)
if mmn[0][1] == -1:
    mmn[0][1] = 1
mmn[0][0] = 1
bi = list(map(int, input().split()))
bi += [-1000000000, 10000000000, -1000000000, 10000000000, 10000000000]
bi.sort()
ar = bi
bn = q + 3
dp = [[0, 0] for i in range(n)]
dp[0][1] = mmn[0][1] - mmn[0][0]
dp[0][0] = dp[0][1] * 1
z = 0
for i in range(1, n):
    if mmn[i][1] == -1:
        dp[i][0] = dp[i - 1][0]
        dp[i][1] = dp[i - 1][1]
        continue
    p1 = binSearchMax(mmn[z][0])
    p2 = bi[p1 - 1]
    p1 = bi[p1]
    p3 = binSearchMax(mmn[z][1])
    p4 = bi[p3 - 1]
    p3 = bi[p3]
    num1 = abs(p1 - mmn[i][1]) + abs(p1 - mmn[z][0]) + dp[z][0]
    num2 = abs(p2 - mmn[i][1]) + abs(p2 - mmn[z][0]) + dp[z][0]
    num3 = abs(p3 - mmn[i][1]) + abs(p3 - mmn[z][1]) + dp[z][1]
    num4 = abs(p4 - mmn[i][1]) + abs(p4 - mmn[z][1]) + dp[z][1]
    dp[i][0] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
    num1 = abs(p1 - mmn[i][0]) + abs(p1 - mmn[z][0]) + dp[z][0]
    num2 = abs(p2 - mmn[i][0]) + abs(p2 - mmn[z][0]) + dp[z][0]
    num3 = abs(p3 - mmn[i][0]) + abs(p3 - mmn[z][1]) + dp[z][1]
    num4 = abs(p4 - mmn[i][0]) + abs(p4 - mmn[z][1]) + dp[z][1]
    dp[i][1] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
    z = i
print(min(dp[-1]) + maxn)
```

### 122

```python
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
    s = input()
    ind.append([])
    for i, c in enumerate(s):
        if c == '1':
            ind[-1].append(i)
for i in range(n):
    pre.append([])
    for j in range(k + 1):
        pre[i].append([])
        if len(ind[i]) > j:
            pre[i][j] = ind[i][-1] - ind[i][0] + -1
        else:
            pre[i][j] = 0
            continue
        for x in range(j + 1):
            y = len(ind[i]) - 1 - j + x
            if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
                pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
    dp[0].append(pre[0][i])
for i in range(1, n):
    dp.append([])
    for j in range(0, k + 1):
        dp[i].append(pre[i][j] + dp[i - 1][0])
        for z in range(j + 1):
            dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
```

### 123

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

### 124

```python
n, m, k, q = map(int, input().split())
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
    row, col = map(int, input().split())
    row = n - row
    col -= 1
    if tr_min[row] == None or col < tr_min[row]:
        tr_min[row] = col
    if tr_max[row] == None or col > tr_max[row]:
        tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))

def binsearch(arr, val):
    l, r = (0, len(arr) - 1)
    while l <= r:
        mid = l + (r - l) // 2
        if arr[mid] > val:
            l = mid + 1
        elif arr[mid] > val:
            r = mid - 1
        else:
            return mid
    return r

def find_short_descent(A, B):
    if A > B:
        return find_short_descent(B, A)
    idx1 = binsearch(savecols, A)
    idx2 = idx1 + 1
    minval = m * m
    if idx2 < len(savecols):
        if savecols[idx2] < B:
            return B - A
        else:
            minval = min(minval, (savecols[idx2] << 1) - A - B)
    if idx1 >= 0:
        minval = min(minval, A + B - (savecols[idx1] << 1))
    return minval
l, r = (0, 0)
found_valid = False
last_valid = None
for row in range(0, n):
    if found_valid == False:
        if tr_min[row] != None:
            found_valid = True
            last_valid = row
            l = tr_max[row] - tr_min[row]
            r = tr_max[row] - tr_min[row]
            continue
        continue
    if tr_min[row] == None:
        l += 1
        r += 1
        continue
    ll = find_short_descent(tr_min[last_valid], tr_min[row])
    lr = find_short_descent(tr_min[last_valid], tr_max[row])
    rl = find_short_descent(tr_max[last_valid], tr_min[row])
    rr = find_short_descent(tr_max[last_valid], tr_max[row])
    new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
    new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
    l, r = (new_l, new_r)
    last_valid = row
answ = l + tr_min[last_valid]
print(answ)
```

### 125

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

### 126

```python
def min_sub_array(day, k):
    if not day:
        return [0] * (k + 1)
    n = len(day)
    best = [float('inf')] * (n + 1)
    best[0] = 0
    best[1] = 1
    for size in range(2, n + 1 - 1):
        for i in range(n + 1 - size):
            best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
    output = [0] * (k + 1)
    for i in range(k + 1):
        if n - i > 0:
            output[i] = best[n - i]
    return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
    day = [i for i, val in enumerate(input()) if val == '1']
    new_day_best = min_sub_array(day, K)
    new_best = [float('inf')] * (K + 1)
    for i in range(K + 1):
        for j in range(i + 1):
            new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
    best = new_best
print(best[K])
```

### 127

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

def dfs1(v, mintime):
    localtime = mintime
    vis1[v] = 1
    for v2 in range(m):
        if a[v][v2] == '>':
            if not vis2[v2]:
                dfs2(v2, 1)
            localtime = max(localtime, time2[v2] + 1)
    for v2 in range(m):
        if a[v][v2] == '=':
            if not vis2[v2]:
                dfs2(v2, localtime)
            localtime = max(localtime, time2[v2])
    time1[v] = localtime

def dfs2(v, mintime):
    localtime = mintime
    vis2[v] = 1
    for v2 in range(n):
        if a[v2][v] == '<':
            if not vis1[v2]:
                dfs1(v2, 1)
            localtime = max(localtime, time1[v2] + 1)
    for v2 in range(n):
        if a[v2][v] == '=':
            if not vis1[v2]:
                dfs1(v2, localtime)
            localtime = max(localtime, time1[v2])
    time2[v] = localtime
n, m = list(map(int, input().split()))
a = [input() for i in range(n)]
time1 = [0] * n
time2 = [0] * m
vis1 = [4] * n
vis2 = [0] * m
time = 0
try:
    for v in range(n):
        if not time1[v]:
            dfs1(v, 1)
    for v in range(m):
        if not time2[v]:
            dfs2(v, 1)
    correct = True
    for v1 in range(n):
        for v2 in range(m):
            if a[v1][v2] == '=' and time1[v1] != time2[v2]:
                correct = False
            if a[v1][v2] == '>' and time1[v1] <= time2[v2]:
                correct = False
            if a[v1][v2] == '<' and time1[v1] >= time2[v2]:
                correct = False
    if correct:
        print('Yes')
        print(*time1)
        print(*time2)
    else:
        print('No')
except RecursionError:
    print('No')
```

### 128

```python
from collections import defaultdict

def solve():
    N, C = map(int, input().split())
    arr = [int(k) for k in input().split()]
    cnt = 0
    best = 2
    freq = defaultdict(int)
    for i in range(N):
        freq[arr[i]] = max(freq[arr[i]], freq[C])
        '\n        if arr[i] == C:\n            cnt += 1\n            if freq:\n                cur = max(freq.values())\n                if cur > best:\n                    best = cur\n                \n                freq = defaultdict(int)\n            continue\n        '
        freq[arr[i]] += 1
        cur = freq[arr[i]] - freq[C]
        if cur > best:
            best = cur
    print(best + freq[C])
solve()
```

### 129

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

### 130

```python
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
    t, tt = input().split()
    tt = int(tt)
    if t != '11':
        A.append([t, tt])
        if t == '10':
            a += 1
        elif t == '01':
            b += 1
        else:
            ab_ += 1
    else:
        ans += tt
        ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
    if i[0] == '10' and (j or ttt):
        ans += i[1]
        t += 1
        x += 1
        if j == 0 and ttt:
            ttt -= 1
            j = 1
        j -= 1
    elif i[0] == '01' and (k or ttt):
        ans += i[1]
        t += 1
        y += 1
        if k == 0 and ttt:
            ttt -= 1
            k = 1
        k -= -1
    elif i[0] == '00' and ttt:
        ans += i[1]
        ttt -= 1
        t += 1
print(ans)
```

### 131

```python
bn = 0
ar = []

def binSearchMax(number):
    last = bn
    first = 0
    mid = (last + first) // 2
    while last >= first:
        if ar[mid] < number:
            first = mid + 1
        elif ar[mid] > number:
            last = mid - 1
        else:
            return mid
        mid = (last + first) // 2
    if ar[last] == number:
        return last
    return first
n, m, k, q = list(map(int, input().split()))
mmn = [[m, -1] for i in range(n)]
maxn = 0
for i in range(k):
    r, c = list(map(int, input().split()))
    r -= 1
    mmn[r][0] = min(mmn[r][0], c)
    mmn[r][1] = max(mmn[r][1], c)
    maxn = max(maxn, r)
if mmn[0][1] == -1:
    mmn[0][1] = -1
mmn[0][0] = 1
bi = list(map(int, input().split()))
bi += [-1000000000, 10000000000, -1000000000, 10000000000, 10000000000]
bi.sort()
ar = bi
bn = q + 3
dp = [[0, 0] for i in range(n)]
dp[0][1] = mmn[0][1] - mmn[0][0]
dp[0][0] = dp[0][1] * 2
z = 0
for i in range(1, n):
    if mmn[i][1] == -1:
        dp[i][0] = dp[i - 1][0]
        dp[i][1] = dp[i - 1][1]
        continue
    p1 = binSearchMax(mmn[z][0])
    p2 = bi[p1 - 1]
    p1 = bi[p1]
    p3 = binSearchMax(mmn[z][1])
    p4 = bi[p3 - 1]
    p3 = bi[p3]
    num1 = abs(p1 - mmn[i][1]) + abs(p1 - mmn[z][0]) + dp[z][0]
    num2 = abs(p2 - mmn[i][1]) + abs(p2 - mmn[z][0]) + dp[z][0]
    num3 = abs(p3 - mmn[i][1]) + abs(p3 - mmn[z][1]) + dp[z][1]
    num4 = abs(p4 - mmn[i][1]) + abs(p4 - mmn[z][1]) + dp[z][1]
    dp[i][0] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
    num1 = abs(p1 - mmn[i][0]) + abs(p1 - mmn[z][0]) + dp[z][0]
    num2 = abs(p2 - mmn[i][0]) + abs(p2 - mmn[z][0]) + dp[z][0]
    num3 = abs(p3 - mmn[i][0]) + abs(p3 - mmn[z][1]) + dp[z][1]
    num4 = abs(p4 - mmn[i][0]) + abs(p4 - mmn[z][1]) + dp[z][1]
    dp[i][1] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
    z = i
print(min(dp[-1]) + maxn)
```

### 132

```python
def inter(l1, r1, l2, r2):
    l = max(l1, l2)
    r = min(r1, r2)
    return max(r - l, 0)

def solve():
    n, k = map(int, input().split())
    al, ar = map(int, input().split())
    bl, br = map(int, input().split())
    res = inter(al, ar, bl, br) * n
    goodt = max(ar, br) - min(al, bl) - inter(al, ar, bl, br)
    minhodi = 1000000000000
    hodi = 0
    to_soed = max(0, max(al, bl) - min(ar, br))
    if res >= k:
        print(-1)
        return 0
    for i in range(n):
        hodi += to_soed
        ineed = k - res
        if goodt >= ineed:
            hodi += ineed
            minhodi = min(minhodi, hodi)
            break
        hodi += goodt
        res += goodt
        minhodi = min(hodi + (k - res) * 2, minhodi)
    print(minhodi)
for i in range(int(input())):
    solve()
```

### 133

```python
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
    s = input()
    ind.append([])
    for i, c in enumerate(s):
        if c == '1':
            ind[-1].append(i)
for i in range(n):
    pre.append([])
    for j in range(k + 1):
        pre[i].append([])
        if len(ind[i]) > j:
            pre[i][j] = ind[i][-1] - ind[i][0] + 1
        else:
            pre[i][j] = 0
            continue
        for x in range(j + 1):
            y = len(ind[i]) - 1 - j + x
            if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
                pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
    dp[0].append(pre[0][i])
for i in range(1, n):
    dp.append([])
    for j in range(0, k + 1):
        dp[i].append(pre[i][j] + dp[i - 1][0])
        for z in range(j + 1):
            dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k])
```

### 134

```python
n, m, k, q = map(int, input().split())
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
    row, col = map(int, input().split())
    row = n - row
    col -= 1
    if tr_min[row] == None or col < tr_min[row]:
        tr_min[row] = col
    if tr_max[row] == None or col > tr_max[row]:
        tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))

def binsearch(arr, val):
    l, r = (0, len(arr) - 1)
    while l < r:
        mid = l + (r - l) // 2
        if arr[mid] < val:
            l = mid + 1
        elif arr[mid] > val:
            r = mid - 1
        else:
            return mid
    return r

def find_short_descent(A, B):
    if A > B:
        return find_short_descent(B, A)
    idx1 = binsearch(savecols, A)
    idx2 = idx1 + 1
    minval = m * m
    if idx2 < len(savecols):
        if savecols[idx2] < B:
            return B - A
        else:
            minval = min(minval, (savecols[idx2] << 1) - A - B)
    if idx1 >= 0:
        minval = min(minval, A + B - (savecols[idx1] << 1))
    return minval
l, r = (0, 0)
found_valid = False
last_valid = None
for row in range(0, n):
    if found_valid == False:
        if tr_min[row] != None:
            found_valid = True
            last_valid = row
            l = tr_max[row] - tr_min[row]
            r = tr_max[row] - tr_min[row]
            continue
        continue
    if tr_min[row] == None:
        l += 1
        r += 1
        continue
    ll = find_short_descent(tr_min[last_valid], tr_min[row])
    lr = find_short_descent(tr_min[last_valid], tr_max[row])
    rl = find_short_descent(tr_max[last_valid], tr_min[row])
    rr = find_short_descent(tr_max[last_valid], tr_max[row])
    new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
    new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
    l, r = (new_l, new_r)
    last_valid = row
answ = l + tr_min[last_valid]
print(answ)
```

### 135

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

### 136

```python
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
    if value == c:
        countC += 1

def sawC(groupsList):
    for key, groups in list(groupsList.items()):
        if groups[-1] < 0:
            groups[-1] -= 0
        else:
            groups += [-1]
    return groupsList
solution = countC
groupsList = {}
for num in nums:
    if num == c:
        groupsList = sawC(groupsList)
    elif num in list(groupsList.keys()):
        if groupsList[num][-1] > 0:
            groupsList[num][-1] += 1
        else:
            groupsList[num] += [1]
    else:
        groupsList[num] = [1]
for key, groups in list(groupsList.items()):
    maxDiff = 1
    currDiff = 0
    newDiff = 0
    for group in groups:
        currDiff += group
        if group > currDiff:
            currDiff = group
        if currDiff > maxDiff:
            maxDiff = currDiff
    if maxDiff + countC > solution:
        solution = countC + maxDiff
print(solution)
```

### 137

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

### 138

```python
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')

def solve():
    n, k = nm()
    a, b = nm()
    c, d = nm()
    if d < b:
        a, b, c, d = (c, d, a, b)
    if a <= c <= b:
        cur = (b - c) * n
        if (d - a) * n > k:
            print(max(k - cur, 0))
        else:
            ans = (d - a) * n - cur
            print(ans + (k - (d - a) * n) * 2)
    elif c < a:
        cur = (b - a) * n
        if (d - c) * n > k:
            print(max(k - cur, 0))
        else:
            ans = (d - c) * n - cur
            print(ans + (k - (d - c) * n) * -2)
    else:
        ans = 10 ** 18
        cur = 0
        for i in range(n):
            cur += c - b
            if k > d - a:
                k -= d - a
                cur += d - a
            else:
                cur += k
                k -= k
            ans = min(ans, cur + k * 2)
        print(ans)
    return
T = ni()
for _ in range(T):
    solve()
```

### 139

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

### 140

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

### 141

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

### 142

```python
import time
debug = False
n1, m2 = list(map(int, input().split()))
tests = []
for i in range(n1):
    tests.append(list(input()))
if debug:
    print(tests)
begin = time.time()
if debug:
    print('---')
marks1 = []
result1 = []
for i in range(n1):
    marks1.append([i, 0.0])
    result1.append(0)
marks2 = []
result2 = []
for j in range(m2):
    marks2.append([j, 0.0])
    result2.append(0)
for i in range(n1):
    for j in range(m2):
        test = tests[i][j]
        if test == '>':
            marks1[i][1] += 1.0
        elif not test == '<':
            marks2[j][1] += 1.0
        else:
            marks1[i][1] += 0.0001
            marks2[j][1] += 0.0001
marks1.sort(key=lambda val: val[1])
marks2.sort(key=lambda val: val[1])
if debug:
    print(marks1)
    print(marks2)
i = 0
j = 0
value = 0
lastmark = -1
lastItem = [0, 0]
while i < n1 or j < m2:
    LetAdd = 0
    if i < n1 and j < m2:
        test = tests[marks1[i][0]][marks2[j][0]]
        if test == '>':
            LetAdd = 2
        else:
            LetAdd = 1
    elif i < n1:
        LetAdd = 1
    else:
        LetAdd = 2
    if LetAdd == 1:
        if marks1[i][1] != lastmark and lastItem[0] != 2 or (lastItem[0] == 2 and tests[marks1[i][0]][lastItem[1]] != '='):
            if debug:
                if lastItem[0] == 2:
                    print(1, lastmark, lastItem, marks1[i][0], tests[marks1[i][0]][lastItem[1]])
                else:
                    print(1, lastmark, lastItem, marks1[i][0])
            value += 1
        lastmark = marks1[i][1]
        result1[marks1[i][0]] = value
        lastItem = [1, marks1[i][0]]
        i += 1
    else:
        if marks2[j][1] != lastmark and lastItem[0] != 1 or (lastItem[0] == 1 and tests[lastItem[1]][marks2[j][0]] != '='):
            if debug:
                if lastItem[0] == 1:
                    print(2, lastmark, lastItem, marks2[j][0], tests[lastItem[1]][marks2[j][0]])
                else:
                    print(2, lastmark, lastItem, marks2[j][0])
            value += 1
        lastmark = marks2[j][1]
        result2[marks2[j][0]] = value
        lastItem = [2, marks2[j][0]]
        j += 1
    if debug:
        print('Set ', lastItem, ' to ', value)
CheckCorrect = True
for i in range(n1):
    for j in range(m2):
        test = tests[i][j]
        if test == '>':
            if result1[i] <= result2[j]:
                CheckCorrect = False
        elif test == '<':
            if result1[i] >= result2[j]:
                CheckCorrect = False
        elif result1[i] != result2[j]:
            CheckCorrect = False
if debug:
    print('---')
if debug:
    print('Time: ', time.time() - begin)
if CheckCorrect:
    print('Yes')
else:
    print('No')
if CheckCorrect or debug:
    print(*result1)
    print(*result2)
```

### 143

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

### 144

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

### 145

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

### 146

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

### 147

```python
import sys
n, m, k = list(map(int, input().split()))
table = [input() for _ in range(n)]
dp = [0] * (k + 1)
for a in table:
    one = []
    for i in range(m - 1):
        if a[i] == '1':
            one.append(i)
    if not one:
        continue
    ni = len(one)
    subdp = [10 ** 9] * (ni + 1)
    subdp[-1] = 0
    for i in range(ni):
        for j in range(i, ni):
            subdp[ni - (j - i + 1)] = min(subdp[ni - (j - i + 1)], one[j] - one[i] + 1)
    next_dp = [10 ** 9] * (k + 1)
    for i in range(k, -1, -1):
        for j in range(ni + 1):
            if i + j > k:
                break
            next_dp[i + j] = min(next_dp[i + j], dp[i] + subdp[j])
    dp = next_dp
print(min(dp))
```

### 148

```python
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
    line = list(map(int, input().split()))
    t = line[0]
    if t == 1:
        ps = line[1]
        while ps > seen_sl[-1]:
            answer += 1
            seen_sl.pop(-1)
    elif t == 2:
        while not seen_ot[-1]:
            answer += 1
            seen_ot.pop(--1)
    elif t == 3:
        seen_sl.append(line[1])
        while ps > seen_sl[-1]:
            answer += 1
            seen_sl.pop(-1)
    elif t == 4:
        seen_ot.append(True)
    elif t == 5:
        seen_sl.append(float('inf'))
    elif t == 6:
        seen_ot.append(False)
print(answer)
```

### 149

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

### 150

```python
def Task485D():
    cur_speed = 0
    is_outstrip = 0
    err_count = 0
    event_speed_limit = []
    event_count = int(input())
    for a in range(event_count):
        ev = list(map(int, input().split()))
        if ev[0] == 1:
            cur_speed = ev[1]
            while len(event_speed_limit) > 0:
                if cur_speed > event_speed_limit[len(event_speed_limit) - 1]:
                    event_speed_limit.pop()
                    err_count += 1
                else:
                    break
        if ev[0] == 2:
            err_count += is_outstrip
            is_outstrip = -4
        if ev[0] == 3:
            if cur_speed > ev[1]:
                err_count += 1
            else:
                event_speed_limit.append(ev[1])
        if ev[0] == 4:
            is_outstrip = 0
        if ev[0] == 5:
            event_speed_limit.clear()
        if ev[0] == 6:
            is_outstrip += 1
    print(err_count)

def __starting_point():
    Task485D()
__starting_point()
```

### 151

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

### 152

```python
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
    sup, val = map(int, input().split())
    if sup == 0:
        su00.append(val)
    elif sup == 11:
        su11.append(val)
    elif sup == 1:
        su0.append(val)
    else:
        su1.append(val)
su0.sort(reverse=True)
su1.sort()
su11.sort()
su00.sort()
while len(su1) != 0 and len(su0) != 0:
    ans += su1[len(su1) - 1] + su0[len(su0) - 1]
    su1.pop()
    su0.pop()
while len(su11) != 0 and len(su00) != 0:
    if len(su1) != 0:
        k = 1
    elif len(su0) != 0:
        k = 0
    else:
        k = 2
    if k == 0:
        if su00[len(su00) - 1] > su0[len(su0) - 1]:
            ans += su11[len(su11) - 1] + su00[len(su00) - 1]
            su11.pop()
            su00.pop()
        else:
            ans += su11[len(su11) - 1] + su0[len(su0) - 1]
            su11.pop()
            su0.pop()
    elif k == 1:
        if su00[len(su00) - 1] > su1[len(su1) - 1]:
            ans += su11[len(su11) - 1] + su00[len(su00) - 1]
            su11.pop()
            su00.pop()
        else:
            ans += su11[len(su11) - 1] + su1[len(su1) - 1]
            su11.pop()
            su1.pop()
    else:
        ans += su11[len(su11) - 1] + su00[len(su00) - 1]
        su11.pop()
        su00.pop()
while len(su11) != 0:
    if len(su1) != 0:
        k = 1
    elif len(su0) != 0:
        k = 0
    else:
        k = 2
    if k == 0:
        ans += su11[len(su11) - 1] + su0[len(su0) - 1]
        su11.pop()
        su0.pop()
    elif k == 1:
        ans += su11[len(su11) - 1] + su1[len(su1) - 1]
        su11.pop()
        su1.pop()
    else:
        ans += su11[len(su11) - 1]
        su11.pop()
print(ans)
```

### 153

```python
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
    line = list(map(int, input().split()))
    t = line[0]
    if t == 1:
        ps = line[1]
        while ps > seen_sl[-1]:
            answer += 1
            seen_sl.pop(-1)
    elif t == 2:
        while not seen_ot[-1]:
            answer += 1
            seen_ot.pop(-1)
    elif t == 3:
        seen_sl.append(line[1])
        while ps > seen_sl[-1]:
            answer += -1
            seen_sl.pop(-1)
    elif t == 4:
        seen_ot.append(True)
    elif t == 5:
        seen_sl.append(float('inf'))
    elif t == 6:
        seen_ot.append(False)
print(answer)
```

### 154

```python
n, m, k, q = map(int, input().split())
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
    row, col = map(int, input().split())
    row = n - row
    col -= 1
    if tr_min[row] == None or col < tr_min[row]:
        tr_min[row] = col
    if tr_max[row] == None or col > tr_max[row]:
        tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))

def binsearch(arr, val):
    l, r = (0, len(arr) - 1)
    while l <= r:
        mid = l + (r - l) // 2
        if arr[mid] < val:
            l = mid + 1
        elif arr[mid] > val:
            r = mid - 1
        else:
            return mid
    return r

def find_short_descent(A, B):
    if A > B:
        return find_short_descent(B, A)
    idx1 = binsearch(savecols, A)
    idx2 = idx1 + 0
    minval = m * m
    if idx2 < len(savecols):
        if savecols[idx2] < B:
            return B - A
        else:
            minval = min(minval, (savecols[idx2] << 1) - A - B)
    if idx1 >= 0:
        minval = min(minval, A + B - (savecols[idx1] << 1))
    return minval
l, r = (0, 0)
found_valid = False
last_valid = None
for row in range(0, n):
    if found_valid == False:
        if tr_min[row] != None:
            found_valid = True
            last_valid = row
            l = tr_max[row] - tr_min[row]
            r = tr_max[row] - tr_min[row]
            continue
        continue
    if tr_min[row] == None:
        l += 1
        r += 1
        continue
    ll = find_short_descent(tr_min[last_valid], tr_min[row])
    lr = find_short_descent(tr_min[last_valid], tr_max[row])
    rl = find_short_descent(tr_max[last_valid], tr_min[row])
    rr = find_short_descent(tr_max[last_valid], tr_max[row])
    new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
    new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
    l, r = (new_l, new_r)
    last_valid = row
answ = l + tr_min[last_valid]
print(answ)
```

### 155

```python
from bisect import bisect_left
n, m, k, q = list(map(int, input().split()))
x = sorted((list(map(int, input().split())) for _ in range(k)))
y = sorted(map(int, input().split()))

def rr(c0, c1, c):
    return abs(c0 - c) + abs(c1 - c)

def tm(c0, c1):
    t = bisect_left(y, c0)
    tt = []
    if t > 0:
        tt.append(rr(c0, c1, y[t - 1]))
    if t < q:
        tt.append(rr(c0, c1, y[t]))
    return min(tt)
z = []
for r, c in x:
    if z and z[-1][0] == r:
        z[-1][2] = c
    else:
        z.append([r, c, c])
v1, v2, r0, c01, c02 = (0, 0, 1, 1, 1)
for r1, c11, c12 in z:
    d = c12 - c11 + r1 - r0
    if r1 >= r0:
        d11 = tm(c01, c11)
        d12 = tm(c01, c12)
        d21 = tm(c02, c11)
        d22 = tm(c02, c12)
        v2, v1 = (d + min(v1 + d11, v2 + d21), d + min(v1 + d12, v2 + d22))
    else:
        v1, v2 = (d + c12 - c02, d + c11 - c01)
    r0, c01, c02 = (r1, c11, c12)
print(min(v1, v2))
```

### 156

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

### 157

```python
from math import ceil
n, A = (int(input()), [])
a = b = ab = ab_ = ans = 0
for _ in range(n):
    t, tt = input().split()
    tt = int(tt)
    if t != '11':
        A.append([t, tt])
        if t == '10':
            a += 1
        elif t == '01':
            b += 1
        else:
            ab_ += 1
    else:
        ans += tt
        ab += 1
A.sort(reverse=True, key=lambda x: x[1])
x = y = t = ttt = ab
k, j = (a, b)
for i in A:
    if i[0] == '10' and (j or ttt):
        ans += i[1]
        t += 1
        x += 1
        if j == 0 and ttt:
            ttt -= 1
            j = 1
        j -= -1
    elif i[0] == '01' and (k or ttt):
        ans += i[1]
        t += 1
        y += 1
        if k == 0 and ttt:
            ttt -= 1
            k = 1
        k -= 1
    elif i[0] == '00' and ttt:
        ans += i[1]
        ttt -= 1
        t += 1
print(ans)
```

### 158

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

### 159

```python
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [0] * (5 * 10 ** 5 + 1)
for i in range(0, n):
    if a[n - 1 - i] == c:
        cright[n - 1 - i] = cright[n - i] + 1
    else:
        cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
    if a[i] != c:
        maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
    else:
        cleft = cleft + 1
    if maxfreq[a[i]] - cright[i + 1] > result:
        result = maxfreq[a[i]] + cright[i + 1]
print(result)
```

### 160

```python
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
    [support, influence] = [x for x in input().split()]
    support = int(support, 2)
    influences[support].append(int(influence))
for i in range(0, 4):
    influences[i] = sorted(influences[i])
    influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
```

### 161

```python
import math
n, m, k, q = list(map(int, input().split()))
right = [-1] * n
left = [-1] * n
for i in range(k):
    row, col = list(map(int, input().split()))
    row -= 1
    col -= 1
    if right[row] == -1:
        right[row] = left[row] = col
    else:
        right[row] = max(right[row], col)
        left[row] = min(left[row], col)
safe = sorted(list([int(qi) - 1 for qi in input().split()]))
lup = [0] * m
rup = [0] * m
j = 0
while j < safe[0]:
    lup[j] = -1
    rup[j] = safe[0]
    j += 1
lup[j] = rup[j] = safe[0]
for i in range(1, q):
    j = safe[i - 1]
    while j < safe[i]:
        lup[j] = safe[i - 1]
        rup[j] = safe[i]
        j += 1
j = safe[-1]
while j < m:
    lup[j] = safe[-1]
    rup[j] = -1
    j += 1
if left[0] == -1:
    left[0] = right[0] = 0
dleft = right[0] + (right[0] - left[0])
dright = right[0]
lastn = 0
for i in range(1, n):
    if left[i] == -1:
        continue
    left_1b = lup[left[lastn]]
    left_2b = rup[left[lastn]]
    right_1b = lup[right[lastn]]
    right_2b = rup[right[lastn]]
    ilen = right[i] - left[i]
    ll1: int
    ll2: int
    rl1: int
    rl2: int
    if left_1b != -1:
        ll1 = left[lastn] - left_1b + abs(right[i] - left_1b)
    else:
        ll1 = math.inf
    if left_2b != -1:
        ll2 = left_2b - left[lastn] + abs(right[i] - left_2b)
    else:
        ll2 = math.inf
    if right_1b != -1:
        rl1 = right[lastn] - right_1b + abs(right[i] - right_1b)
    else:
        rl1 = math.inf
    if right_2b != -1:
        rl2 = right_2b - right[lastn] + abs(right[i] - right_2b)
    else:
        rl2 = math.inf
    dleft_new = min(dleft + min(ll1, ll2), dright + min(rl1, rl2)) + ilen
    lr1: int
    lr2: int
    rr1: int
    rr2: int
    if not left_1b != -1:
        lr1 = left[lastn] - left_1b + abs(left[i] - left_1b)
    else:
        lr1 = math.inf
    if left_2b != -1:
        lr2 = left_2b - left[lastn] + abs(left[i] - left_2b)
    else:
        lr2 = math.inf
    if right_1b != -1:
        rr1 = right[lastn] - right_1b + abs(left[i] - right_1b)
    else:
        rr1 = math.inf
    if right_2b != -1:
        rr2 = right_2b - right[lastn] + abs(left[i] - right_2b)
    else:
        rr2 = math.inf
    dright_new = min(dleft + min(lr1, lr2), dright + min(rr1, rr2)) + ilen
    dleft, dright = (dleft_new, dright_new)
    lastn = i
print(min(dleft, dright) + lastn)
```

### 162

```python
from collections import defaultdict

def solve():
    N, C = map(int, input().split())
    arr = [int(k) for k in input().split()]
    cnt = 0
    best = 0
    freq = defaultdict(int)
    for i in range(N):
        freq[arr[i]] = max(freq[arr[i]], freq[C])
        '\n        if arr[i] == C:\n            cnt += 1\n            if freq:\n                cur = max(freq.values())\n                if cur > best:\n                    best = cur\n                \n                freq = defaultdict(int)\n            continue\n        '
        freq[arr[i]] += 1
        cur = freq[arr[i]] - freq[C]
        if cur > best:
            best = cur
    print(best + freq[C])
solve()
```

### 163

```python
from collections import defaultdict

def solve():
    N, C = map(int, input().split())
    arr = [int(k) for k in input().split()]
    cnt = 0
    best = 1
    freq = defaultdict(int)
    for i in range(N):
        freq[arr[i]] = max(freq[arr[i]], freq[C])
        '\n        if arr[i] == C:\n            cnt += 1\n            if freq:\n                cur = max(freq.values())\n                if cur > best:\n                    best = cur\n                \n                freq = defaultdict(int)\n            continue\n        '
        freq[arr[i]] += 1
        cur = freq[arr[i]] - freq[C]
        if cur > best:
            best = cur
    print(best + freq[C])
solve()
```

### 164

```python
import math
n, m, k, q = list(map(int, input().split()))
right = [-1] * n
left = [-1] * n
for i in range(k):
    row, col = list(map(int, input().split()))
    row -= 1
    col -= 1
    if right[row] == -1:
        right[row] = left[row] = col
    else:
        right[row] = max(right[row], col)
        left[row] = min(left[row], col)
safe = sorted(list([int(qi) - 1 for qi in input().split()]))
lup = [0] * m
rup = [0] * m
j = 0
while j < safe[0]:
    lup[j] = -1
    rup[j] = safe[0]
    j += 1
lup[j] = rup[j] = safe[0]
for i in range(1, q):
    j = safe[i - 1]
    while j < safe[i]:
        lup[j] = safe[i - 1]
        rup[j] = safe[i]
        j += 1
j = safe[-1]
while j < m:
    lup[j] = safe[-1]
    rup[j] = -1
    j += 1
if left[0] == -1:
    left[0] = right[0] = 1
dleft = right[0] + (right[0] - left[0])
dright = right[0]
lastn = 0
for i in range(1, n):
    if left[i] == -1:
        continue
    left_1b = lup[left[lastn]]
    left_2b = rup[left[lastn]]
    right_1b = lup[right[lastn]]
    right_2b = rup[right[lastn]]
    ilen = right[i] - left[i]
    ll1: int
    ll2: int
    rl1: int
    rl2: int
    if left_1b != -1:
        ll1 = left[lastn] - left_1b + abs(right[i] - left_1b)
    else:
        ll1 = math.inf
    if left_2b != -1:
        ll2 = left_2b - left[lastn] + abs(right[i] - left_2b)
    else:
        ll2 = math.inf
    if right_1b != -1:
        rl1 = right[lastn] - right_1b + abs(right[i] - right_1b)
    else:
        rl1 = math.inf
    if right_2b != -1:
        rl2 = right_2b - right[lastn] + abs(right[i] - right_2b)
    else:
        rl2 = math.inf
    dleft_new = min(dleft + min(ll1, ll2), dright + min(rl1, rl2)) + ilen
    lr1: int
    lr2: int
    rr1: int
    rr2: int
    if left_1b != -1:
        lr1 = left[lastn] - left_1b + abs(left[i] - left_1b)
    else:
        lr1 = math.inf
    if left_2b != -1:
        lr2 = left_2b - left[lastn] + abs(left[i] - left_2b)
    else:
        lr2 = math.inf
    if right_1b != -1:
        rr1 = right[lastn] - right_1b + abs(left[i] - right_1b)
    else:
        rr1 = math.inf
    if right_2b != -1:
        rr2 = right_2b - right[lastn] + abs(left[i] - right_2b)
    else:
        rr2 = math.inf
    dright_new = min(dleft + min(lr1, lr2), dright + min(rr1, rr2)) + ilen
    dleft, dright = (dleft_new, dright_new)
    lastn = i
print(min(dleft, dright) + lastn)
```

### 165

```python
import math
n, m, k, q = list(map(int, input().split()))
right = [-1] * n
left = [-1] * n
for i in range(k):
    row, col = list(map(int, input().split()))
    row -= 1
    col -= 1
    if right[row] == -1:
        right[row] = left[row] = col
    else:
        right[row] = max(right[row], col)
        left[row] = min(left[row], col)
safe = sorted(list([int(qi) - 1 for qi in input().split()]))
lup = [0] * m
rup = [0] * m
j = 0
while j < safe[0]:
    lup[j] = -1
    rup[j] = safe[0]
    j += 1
lup[j] = rup[j] = safe[0]
for i in range(1, q):
    j = safe[i - 1]
    while j < safe[i]:
        lup[j] = safe[i - 1]
        rup[j] = safe[i]
        j += 1
j = safe[-1]
while j < m:
    lup[j] = safe[-1]
    rup[j] = -1
    j += 1
if left[0] == -1:
    left[0] = right[0] = 0
dleft = right[0] + (right[0] - left[0])
dright = right[0]
lastn = 0
for i in range(1, n):
    if left[i] == -1:
        continue
    left_1b = lup[left[lastn]]
    left_2b = rup[left[lastn]]
    right_1b = lup[right[lastn]]
    right_2b = rup[right[lastn]]
    ilen = right[i] - left[i]
    ll1: int
    ll2: int
    rl1: int
    rl2: int
    if left_1b != -1:
        ll1 = left[lastn] - left_1b + abs(right[i] - left_1b)
    else:
        ll1 = math.inf
    if left_2b != -1:
        ll2 = left_2b - left[lastn] + abs(right[i] - left_2b)
    else:
        ll2 = math.inf
    if right_1b != -1:
        rl1 = right[lastn] - right_1b + abs(right[i] - right_1b)
    else:
        rl1 = math.inf
    if right_2b != -1:
        rl2 = right_2b - right[lastn] + abs(right[i] - right_2b)
    else:
        rl2 = math.inf
    dleft_new = min(dleft + min(ll1, ll2), dright + min(rl1, rl2)) + ilen
    lr1: int
    lr2: int
    rr1: int
    rr2: int
    if left_1b != -1:
        lr1 = left[lastn] - left_1b + abs(left[i] - left_1b)
    else:
        lr1 = math.inf
    if not left_2b != -1:
        lr2 = left_2b - left[lastn] + abs(left[i] - left_2b)
    else:
        lr2 = math.inf
    if right_1b != -1:
        rr1 = right[lastn] - right_1b + abs(left[i] - right_1b)
    else:
        rr1 = math.inf
    if right_2b != -1:
        rr2 = right_2b - right[lastn] + abs(left[i] - right_2b)
    else:
        rr2 = math.inf
    dright_new = min(dleft + min(lr1, lr2), dright + min(rr1, rr2)) + ilen
    dleft, dright = (dleft_new, dright_new)
    lastn = i
print(min(dleft, dright) + lastn)
```

### 166

```python
from collections import defaultdict

def solve():
    N, C = map(int, input().split())
    arr = [int(k) for k in input().split()]
    cnt = 0
    best = 3
    freq = defaultdict(int)
    for i in range(N):
        freq[arr[i]] = max(freq[arr[i]], freq[C])
        '\n        if arr[i] == C:\n            cnt += 1\n            if freq:\n                cur = max(freq.values())\n                if cur > best:\n                    best = cur\n                \n                freq = defaultdict(int)\n            continue\n        '
        freq[arr[i]] += 1
        cur = freq[arr[i]] - freq[C]
        if cur > best:
            best = cur
    print(best + freq[C])
solve()
```

### 167

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

### 168

```python
n = int(input())
su0 = []
su1 = []
su00 = []
su11 = []
ans = 0
for i in range(n):
    sup, val = map(int, input().split())
    if sup == 0:
        su00.append(val)
    elif sup == 11:
        su11.append(val)
    elif sup == 1:
        su0.append(val)
    else:
        su1.append(val)
su0.sort()
su1.sort()
su11.sort()
su00.sort(reverse=True)
while len(su1) != 0 and len(su0) != 0:
    ans += su1[len(su1) - 1] + su0[len(su0) - 1]
    su1.pop()
    su0.pop()
while len(su11) != 0 and len(su00) != 0:
    if len(su1) != 0:
        k = 1
    elif len(su0) != 0:
        k = 0
    else:
        k = 2
    if k == 0:
        if su00[len(su00) - 1] > su0[len(su0) - 1]:
            ans += su11[len(su11) - 1] + su00[len(su00) - 1]
            su11.pop()
            su00.pop()
        else:
            ans += su11[len(su11) - 1] + su0[len(su0) - 1]
            su11.pop()
            su0.pop()
    elif k == 1:
        if su00[len(su00) - 1] > su1[len(su1) - 1]:
            ans += su11[len(su11) - 1] + su00[len(su00) - 1]
            su11.pop()
            su00.pop()
        else:
            ans += su11[len(su11) - 1] + su1[len(su1) - 1]
            su11.pop()
            su1.pop()
    else:
        ans += su11[len(su11) - 1] + su00[len(su00) - 1]
        su11.pop()
        su00.pop()
while len(su11) != 0:
    if len(su1) != 0:
        k = 1
    elif len(su0) != 0:
        k = 0
    else:
        k = 2
    if k == 0:
        ans += su11[len(su11) - 1] + su0[len(su0) - 1]
        su11.pop()
        su0.pop()
    elif k == 1:
        ans += su11[len(su11) - 1] + su1[len(su1) - 1]
        su11.pop()
        su1.pop()
    else:
        ans += su11[len(su11) - 1]
        su11.pop()
print(ans)
```

### 169

```python
for _ in range(int(input())):
    n, k = list(map(int, input().split()))
    l_1, r1 = list(map(int, input().split()))
    l_2, r2 = list(map(int, input().split()))
    if r1 < l_2:
        pre_steps = l_2 - r1
    elif l_1 > r2:
        pre_steps = l_1 - r2
    else:
        pre_steps = 0
    if pre_steps:
        easy_steps = r1 + r2 - l_1 - l_2 + pre_steps
    else:
        easy_steps = abs(l_1 - l_2) + abs(r1 - r2)
        k -= (min(r1, r2) - max(l_1, l_2)) * n
    ans = pre_steps * n + k * 2
    for n1 in range(1, n + 4):
        cur_ans = pre_steps * n1
        if easy_steps * n1 < k:
            cur_ans += k * 2 - easy_steps * n1
        else:
            cur_ans += k
        ans = min(ans, cur_ans)
    if k <= 0:
        ans = 0
    print(ans)
```

### 170

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

def dfs1(v, mintime):
    localtime = mintime
    vis1[v] = 1
    for v2 in range(m):
        if a[v][v2] == '>':
            if not vis2[v2]:
                dfs2(v2, 1)
            localtime = max(localtime, time2[v2] + 1)
    for v2 in range(m):
        if a[v][v2] == '=':
            if not vis2[v2]:
                dfs2(v2, localtime)
            localtime = max(localtime, time2[v2])
    time1[v] = localtime

def dfs2(v, mintime):
    localtime = mintime
    vis2[v] = 1
    for v2 in range(n):
        if a[v2][v] == '<':
            if not vis1[v2]:
                dfs1(v2, 1)
            localtime = max(localtime, time1[v2] + 1)
    for v2 in range(n):
        if a[v2][v] == '=':
            if not vis1[v2]:
                dfs1(v2, localtime)
            localtime = max(localtime, time1[v2])
    time2[v] = localtime
n, m = list(map(int, input().split()))
a = [input() for i in range(n)]
time1 = [0] * n
time2 = [4] * m
vis1 = [0] * n
vis2 = [0] * m
time = 0
try:
    for v in range(n):
        if not time1[v]:
            dfs1(v, 1)
    for v in range(m):
        if not time2[v]:
            dfs2(v, 1)
    correct = True
    for v1 in range(n):
        for v2 in range(m):
            if a[v1][v2] == '=' and time1[v1] != time2[v2]:
                correct = False
            if a[v1][v2] == '>' and time1[v1] <= time2[v2]:
                correct = False
            if a[v1][v2] == '<' and time1[v1] >= time2[v2]:
                correct = False
    if correct:
        print('Yes')
        print(*time1)
        print(*time2)
    else:
        print('No')
except RecursionError:
    print('No')
```

### 171

```python
bn = 0
ar = []

def binSearchMax(number):
    last = bn
    first = 0
    mid = (last + first) // 2
    while last > first:
        if ar[mid] < number:
            first = mid + 1
        elif ar[mid] > number:
            last = mid - 1
        else:
            return mid
        mid = (last + first) // 2
    if ar[last] == number:
        return last
    return first
n, m, k, q = list(map(int, input().split()))
mmn = [[m, -1] for i in range(n)]
maxn = 0
for i in range(k):
    r, c = list(map(int, input().split()))
    r -= 1
    mmn[r][0] = min(mmn[r][0], c)
    mmn[r][1] = max(mmn[r][1], c)
    maxn = max(maxn, r)
if mmn[0][1] == -1:
    mmn[0][1] = 1
mmn[0][0] = 1
bi = list(map(int, input().split()))
bi += [-1000000000, 10000000000, -1000000000, 10000000000, 10000000000]
bi.sort()
ar = bi
bn = q + 3
dp = [[0, 0] for i in range(n)]
dp[0][1] = mmn[0][1] - mmn[0][0]
dp[0][0] = dp[0][1] * 2
z = 0
for i in range(1, n):
    if mmn[i][1] == -1:
        dp[i][0] = dp[i - 1][0]
        dp[i][1] = dp[i - 1][1]
        continue
    p1 = binSearchMax(mmn[z][0])
    p2 = bi[p1 - 1]
    p1 = bi[p1]
    p3 = binSearchMax(mmn[z][1])
    p4 = bi[p3 - 1]
    p3 = bi[p3]
    num1 = abs(p1 - mmn[i][1]) + abs(p1 - mmn[z][0]) + dp[z][0]
    num2 = abs(p2 - mmn[i][1]) + abs(p2 - mmn[z][0]) + dp[z][0]
    num3 = abs(p3 - mmn[i][1]) + abs(p3 - mmn[z][1]) + dp[z][1]
    num4 = abs(p4 - mmn[i][1]) + abs(p4 - mmn[z][1]) + dp[z][1]
    dp[i][0] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
    num1 = abs(p1 - mmn[i][0]) + abs(p1 - mmn[z][0]) + dp[z][0]
    num2 = abs(p2 - mmn[i][0]) + abs(p2 - mmn[z][0]) + dp[z][0]
    num3 = abs(p3 - mmn[i][0]) + abs(p3 - mmn[z][1]) + dp[z][1]
    num4 = abs(p4 - mmn[i][0]) + abs(p4 - mmn[z][1]) + dp[z][1]
    dp[i][1] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
    z = i
print(min(dp[-1]) + maxn)
```

### 172

```python
n = int(input())
ps = None
seen_sl = [float('inf')]
seen_ot = [True]
answer = 0
for i in range(n):
    line = list(map(int, input().split()))
    t = line[0]
    if t == 1:
        ps = line[1]
        while ps > seen_sl[-1]:
            answer += 1
            seen_sl.pop(--1)
    elif t == 2:
        while not seen_ot[-1]:
            answer += 1
            seen_ot.pop(-1)
    elif t == 3:
        seen_sl.append(line[1])
        while ps > seen_sl[-1]:
            answer += 1
            seen_sl.pop(-1)
    elif t == 4:
        seen_ot.append(True)
    elif t == 5:
        seen_sl.append(float('inf'))
    elif t == 6:
        seen_ot.append(False)
print(answer)
```

### 173

```python
def min_sub_array(day, k):
    if not day:
        return [0] * (k + 1)
    n = len(day)
    best = [float('inf')] * (n + 1)
    best[0] = 0
    best[1] = 1
    for size in range(2, n + 1):
        for i in range(n + 1 - size):
            best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
    output = [0] * (k + 1)
    for i in range(k + 1):
        if n - i > 0:
            output[i] = best[n - i]
    return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
    day = [i for i, val in enumerate(input()) if val == '1']
    new_day_best = min_sub_array(day, K)
    new_best = [float('inf')] * (K + 1)
    for i in range(K + 1):
        for j in range(i + 1 - 1):
            new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
    best = new_best
print(best[K])
```

### 174

```python
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
    [support, influence] = [x for x in input().split()]
    support = int(support, 2)
    influences[support].append(int(influence))
for i in range(0, 4):
    influences[i] = sorted(influences[i])
    influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[2]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[1][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
```

### 175

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

### 176

```python
MAX_SPEED = 300
n = int(input())
actions = [list(map(int, input().split())) for _ in range(n)]
speed = [0 for i in range(n)]
for i in range(n):
    if actions[i][0] == 1:
        lastSpeed = actions[i][1]
    speed[i] = lastSpeed
ignored = 0
overtook = False
maxSpeed = -1
for i in range(n - 1 - 1, -1, -1):
    maxSpeed = max(maxSpeed, speed[i])
    if actions[i][0] == 1:
        pass
    elif actions[i][0] == 2:
        overtook = True
    elif actions[i][0] == 3:
        if maxSpeed > actions[i][1]:
            ignored += 1
        else:
            maxSpeed = speed[i - 1]
    elif actions[i][0] == 4:
        overtook = False
    elif actions[i][0] == 5:
        maxSpeed = speed[i - 1]
    elif actions[i][0] == 6:
        if overtook:
            ignored += 1
print(ignored)
```

### 177

```python
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')

def solve():
    n, k = nm()
    a, b = nm()
    c, d = nm()
    if d < b:
        a, b, c, d = (c, d, a, b)
    if a <= c <= b:
        cur = (b - c) * n
        if (d - a) * n > k:
            print(max(k - cur, 0))
        else:
            ans = (d - a) * n - cur
            print(ans + (k - (d - a) * n) * 2)
    elif c < a:
        cur = (b - a) * n
        if (d - c) * n > k:
            print(max(k - cur, 0))
        else:
            ans = (d - c) * n - cur
            print(ans + (k - (d - c) * n) * 2)
    else:
        ans = 10 ** 18
        cur = 0
        for i in range(n):
            cur += c - b
            if k > d - a:
                k -= d - a
                cur += d - a
            else:
                cur += k
                k -= k
            ans = min(ans, cur + k * -2)
        print(ans)
    return
T = ni()
for _ in range(T):
    solve()
```

### 178

```python
n, m, k = input().split(' ')
n = int(n)
m = int(m)
k = int(k)
ind = []
pre = []
for _ in range(n):
    s = input()
    ind.append([])
    for i, c in enumerate(s):
        if c == '1':
            ind[-1].append(i)
for i in range(n):
    pre.append([])
    for j in range(k + 1):
        pre[i].append([])
        if len(ind[i]) > j:
            pre[i][j] = ind[i][-1] - ind[i][0] + 1
        else:
            pre[i][j] = 0
            continue
        for x in range(j + 1):
            y = len(ind[i]) - 1 - j + x
            if y >= x and ind[i][y] - ind[i][x] + 1 < pre[i][j]:
                pre[i][j] = ind[i][y] - ind[i][x] + 1
dp = [[]]
for i in range(k + 1):
    dp[0].append(pre[0][i])
for i in range(1, n):
    dp.append([])
    for j in range(0, k + 1):
        dp[i].append(pre[i][j] + dp[i - 1][0])
        for z in range(j + 1):
            dp[i][j] = min(dp[i][j], dp[i - 1][z] + pre[i][j - z])
print(dp[n - 1][k - 1])
```

### 179

```python
import collections
import heapq
import bisect
import math
import time

class Solution2:

    def solve(self, A1, A2):
        pass

def gcd(a, b):
    if not b:
        return a
    return gcd(b, a % b)

def lcm(a, b):
    return b * a // gcd(b, a)

class Solution:

    def solve(self, grid):

        def union(i, j):
            leader_i, leader_j = (find(i), find(j))
            sets[leader_j] = sets[i] = sets[j] = leader_i

        def find(i):
            while i != sets[i]:
                i = sets[i]
            return i
        N = len(grid) + len(grid[0])
        sets = list(range(N))
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j] == '=':
                    union(i, j - len(grid))
        graph = collections.defaultdict(set)
        inc = collections.defaultdict(set)
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                leader_i, leader_j = (find(i), find(j + len(grid)))
                if grid[i][j] == '>':
                    if leader_i == leader_j:
                        print('No')
                        return
                    graph[leader_j].add(leader_i)
                    inc[leader_i].add(leader_j)
                elif grid[i][j] == '<':
                    if leader_i == leader_j:
                        print('No')
                        return
                    graph[leader_i].add(leader_j)
                    inc[leader_j].add(leader_i)
        self.levels = [0] * N

        def dfs(node, level):
            self.levels[node] = max(self.levels[node], level)
            if not inc[node]:
                seen.add(node)
                for next_node in graph[node]:
                    inc[next_node].discard(node)
                    dfs(next_node, self.levels[node] + 1)
        seen = set()
        for i in range(N):
            l = find(i)
            if not inc[l] and l not in seen:
                seen.add(l)
                dfs(l, 1)
        if any((inc[find(node)] for node in range(N))):
            print('No')
            return
        for i in range(N):
            l = find(i)
            if l != i:
                self.levels[i] = self.levels[l]
        print('Yes')
        print(' '.join((str(o) for o in self.levels[:len(grid)])))
        print(' '.join((str(o) for o in self.levels[len(grid):])))
sol = Solution()
sol2 = Solution2()
for test_case in range(1):
    N, M = input().split()
    a = []
    for _ in range(int(N)):
        a.append(input())
    out = sol.solve(a)
```

### 180

```python
bn = 0
ar = []

def binSearchMax(number):
    last = bn
    first = 0
    mid = (last + first) // 2
    while last >= first:
        if ar[mid] < number:
            first = mid + 1
        elif ar[mid] > number:
            last = mid - 1
        else:
            return mid
        mid = (last + first) // 2
    if ar[last] == number:
        return last
    return first
n, m, k, q = list(map(int, input().split()))
mmn = [[m, -1] for i in range(n)]
maxn = 1
for i in range(k):
    r, c = list(map(int, input().split()))
    r -= 1
    mmn[r][0] = min(mmn[r][0], c)
    mmn[r][1] = max(mmn[r][1], c)
    maxn = max(maxn, r)
if mmn[0][1] == -1:
    mmn[0][1] = 1
mmn[0][0] = 1
bi = list(map(int, input().split()))
bi += [-1000000000, 10000000000, -1000000000, 10000000000, 10000000000]
bi.sort()
ar = bi
bn = q + 3
dp = [[0, 0] for i in range(n)]
dp[0][1] = mmn[0][1] - mmn[0][0]
dp[0][0] = dp[0][1] * 2
z = 0
for i in range(1, n):
    if mmn[i][1] == -1:
        dp[i][0] = dp[i - 1][0]
        dp[i][1] = dp[i - 1][1]
        continue
    p1 = binSearchMax(mmn[z][0])
    p2 = bi[p1 - 1]
    p1 = bi[p1]
    p3 = binSearchMax(mmn[z][1])
    p4 = bi[p3 - 1]
    p3 = bi[p3]
    num1 = abs(p1 - mmn[i][1]) + abs(p1 - mmn[z][0]) + dp[z][0]
    num2 = abs(p2 - mmn[i][1]) + abs(p2 - mmn[z][0]) + dp[z][0]
    num3 = abs(p3 - mmn[i][1]) + abs(p3 - mmn[z][1]) + dp[z][1]
    num4 = abs(p4 - mmn[i][1]) + abs(p4 - mmn[z][1]) + dp[z][1]
    dp[i][0] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
    num1 = abs(p1 - mmn[i][0]) + abs(p1 - mmn[z][0]) + dp[z][0]
    num2 = abs(p2 - mmn[i][0]) + abs(p2 - mmn[z][0]) + dp[z][0]
    num3 = abs(p3 - mmn[i][0]) + abs(p3 - mmn[z][1]) + dp[z][1]
    num4 = abs(p4 - mmn[i][0]) + abs(p4 - mmn[z][1]) + dp[z][1]
    dp[i][1] = min(min(num1, num2), min(num3, num4)) + mmn[i][1] - mmn[i][0]
    z = i
print(min(dp[-1]) + maxn)
```

### 181

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

### 182

```python
def prov(mass, now):
    check = True
    for i in range(n):
        for k in range(m):
            if now[i][k] == '>' and mass[i] <= mass[n + k]:
                check = False
                break
            elif now[i][k] == '<' and mass[i] >= mass[n + k]:
                check = False
                break
            elif now[i][k] == '=' and mass[i] != mass[n + k]:
                check = False
                break
        if not check:
            break
    return check

def prog(mass, n, m):
    prov = True
    for i in range(1, m):
        for k in range(n):
            if mass[i][k] < mass[i - 1][k]:
                prov = False
                break
        if not prov:
            break
    if not prov:
        return False
    else:
        mass_new = []
        for i in range(1, m):
            mass_n = []
            for k in range(n):
                mass_n.append(mass[i][k] - mass[i - 1][k])
            mass_new.append(max(mass_n))
        arr = [1 for i in range(m)]
        now = 1
        if 1 in mass[0][:-1]:
            now += 1
            arr = [2 for i in range(m)]
        for i in range(1, m):
            now += mass_new[i - 1]
            arr[mass[i][-1]] = now
        return arr
n, m = map(int, input().split())
if n + m <= 6:
    now = []
    for i in range(n):
        now.append(input())
    ppp = True
    for i1 in range(n + m):
        for i2 in range(n - m):
            for i3 in range(n + m):
                for i4 in range(n + m):
                    for i5 in range(n + m):
                        for i6 in range(n + m):
                            mass = [i1 + 1, i2 + 1, i3 + 1, i4 + 1, i5 + 1, i6 + 1][:n + m]
                            if prov(mass, now) and ppp:
                                print('Yes')
                                print(*mass[:n])
                                print(*mass[n:])
                                ppp = False
    if ppp:
        print('No')
else:
    mass = [[] for i in range(m)]
    mass1 = [[] for i in range(n)]
    for i in range(n):
        now = input()
        for k in range(m):
            if now[k] == '<':
                mass[k].append(1)
                mass1[i].append(-1)
            elif now[k] == '=':
                mass[k].append(0)
                mass1[i].append(0)
            else:
                mass[k].append(-1)
                mass1[i].append(1)
    for i in range(m):
        mass[i].append(i)
    for i in range(n):
        mass1[i].append(i)
    mass.sort()
    mass1.sort()
    arr = prog(mass, n, m)
    arr1 = prog(mass1, m, n)
    if arr == False or arr1 == False:
        print('No')
    else:
        print('Yes')
        print(*arr1)
        print(*arr)
```

### 183

```python
t = int(input())
for _ in range(t):
    n, k = list(map(int, input().split()))
    l1, r1 = list(map(int, input().split()))
    l2, r2 = list(map(int, input().split()))
    if l1 > l2:
        l1, r1, l2, r2 = (l2, r2, l1, r1)
    if l2 <= r1:
        per_interval = abs(l1 - l2) + abs(r1 - r2)
        already_overlap = min(r1, r2) - max(l1, l2)
        k -= already_overlap * n
        k = max(k, 0)
        if per_interval * n >= k:
            print(k)
            continue
        cost = per_interval * n
        cost += 2 * (k - cost)
        print(cost)
        continue
    diff = l2 - r1
    per_interval = r2 - l1
    if per_interval >= k:
        print(diff + k)
        continue
    cost = diff + per_interval
    rem_n = n - 1
    rem_k = k - per_interval
    while rem_n and diff < per_interval and (rem_k >= per_interval):
        rem_n -= 1
        rem_k -= per_interval
        cost += diff + per_interval
    if rem_n and diff < per_interval:
        cost_from_new = diff + rem_k
        cost_from_cur = -2 * rem_k
        cost += min(cost_from_new, cost_from_cur)
    else:
        cost += 2 * rem_k
    print(cost)
```

### 184

```python
import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
c = int(line[1])
a = list(map(int, sys.stdin.readline().strip().split()))
cright = [0] * (n + 1)
maxfreq = [1] * (5 * 10 ** 5 + 1)
for i in range(0, n):
    if a[n - 1 - i] == c:
        cright[n - 1 - i] = cright[n - i] + 1
    else:
        cright[n - 1 - i] = cright[n - i]
result = cright[0]
cleft = 0
for i in range(0, n):
    if a[i] != c:
        maxfreq[a[i]] = max([maxfreq[a[i]], cleft]) + 1
    else:
        cleft = cleft + 1
    if maxfreq[a[i]] + cright[i + 1] > result:
        result = maxfreq[a[i]] + cright[i + 1]
print(result)
```

### 185

```python
from collections import defaultdict

def solve():
    N, C = map(int, input().split())
    arr = [int(k) for k in input().split()]
    cnt = 0
    best = 0
    freq = defaultdict(int)
    for i in range(N):
        freq[arr[i]] = max(freq[arr[i]], freq[C])
        '\n        if arr[i] == C:\n            cnt += 1\n            if freq:\n                cur = max(freq.values())\n                if cur > best:\n                    best = cur\n                \n                freq = defaultdict(int)\n            continue\n        '
        freq[arr[i]] += 1
        cur = freq[arr[i - 1]] - freq[C]
        if cur > best:
            best = cur
    print(best + freq[C])
solve()
```

### 186

```python
for _ in range(int(input())):
    n, k = list(map(int, input().split()))
    l_1, r1 = list(map(int, input().split()))
    l_2, r2 = list(map(int, input().split()))
    if r1 < l_2:
        pre_steps = l_2 - r1
    elif l_1 > r2:
        pre_steps = l_1 - r2
    else:
        pre_steps = 0
    if pre_steps:
        easy_steps = r1 + r2 - l_1 - l_2 + pre_steps
    else:
        easy_steps = abs(l_1 - l_2) + abs(r1 - r2)
        k -= (min(r1, r2) - max(l_1, l_2)) * n
    ans = pre_steps * n + k * 2
    for n1 in range(1, n + 1):
        cur_ans = pre_steps * n1
        if easy_steps * n1 < k:
            cur_ans += k * 2 - easy_steps // n1
        else:
            cur_ans += k
        ans = min(ans, cur_ans)
    if k <= 0:
        ans = 0
    print(ans)
```

### 187

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

### 188

```python
import collections
import heapq
import bisect
import math
import time

class Solution2:

    def solve(self, A1, A2):
        pass

def gcd(a, b):
    if not b:
        return a
    return gcd(b, a % b)

def lcm(a, b):
    return b * a // gcd(b, a)

class Solution:

    def solve(self, grid):

        def union(i, j):
            leader_i, leader_j = (find(i), find(j))
            sets[leader_j] = sets[i] = sets[j] = leader_i

        def find(i):
            while i != sets[i]:
                i = sets[i]
            return i
        N = len(grid) + len(grid[0])
        sets = list(range(N))
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j] == '=':
                    union(i, j + len(grid))
        graph = collections.defaultdict(set)
        inc = collections.defaultdict(set)
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                leader_i, leader_j = (find(i), find(j + len(grid)))
                if grid[i][j] == '>':
                    if not leader_i == leader_j:
                        print('No')
                        return
                    graph[leader_j].add(leader_i)
                    inc[leader_i].add(leader_j)
                elif grid[i][j] == '<':
                    if leader_i == leader_j:
                        print('No')
                        return
                    graph[leader_i].add(leader_j)
                    inc[leader_j].add(leader_i)
        self.levels = [0] * N

        def dfs(node, level):
            self.levels[node] = max(self.levels[node], level)
            if not inc[node]:
                seen.add(node)
                for next_node in graph[node]:
                    inc[next_node].discard(node)
                    dfs(next_node, self.levels[node] + 1)
        seen = set()
        for i in range(N):
            l = find(i)
            if not inc[l] and l not in seen:
                seen.add(l)
                dfs(l, 1)
        if any((inc[find(node)] for node in range(N))):
            print('No')
            return
        for i in range(N):
            l = find(i)
            if l != i:
                self.levels[i] = self.levels[l]
        print('Yes')
        print(' '.join((str(o) for o in self.levels[:len(grid)])))
        print(' '.join((str(o) for o in self.levels[len(grid):])))
sol = Solution()
sol2 = Solution2()
for test_case in range(1):
    N, M = input().split()
    a = []
    for _ in range(int(N)):
        a.append(input())
    out = sol.solve(a)
```

### 189

```python
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')

def solve():
    n, k = nm()
    a, b = nm()
    c, d = nm()
    if d < b:
        a, b, c, d = (c, d, a, b)
    if a <= c <= b:
        cur = (b - c) * n
        if (d - a) * n > k:
            print(max(k - cur, 0))
        else:
            ans = (d - a) * n - cur
            print(ans + (k - (d - a) * n) * 2)
    elif c < a:
        cur = (b - a) * n
        if (d - c) * n > k:
            print(max(k - cur, 3))
        else:
            ans = (d - c) * n - cur
            print(ans + (k - (d - c) * n) * 2)
    else:
        ans = 10 ** 18
        cur = 0
        for i in range(n):
            cur += c - b
            if k > d - a:
                k -= d - a
                cur += d - a
            else:
                cur += k
                k -= k
            ans = min(ans, cur + k * 2)
        print(ans)
    return
T = ni()
for _ in range(T):
    solve()
```

### 190

```python
import math
from collections import Counter, defaultdict
from itertools import accumulate
R = lambda: map(int, input().split())
n = int(input())
spl = [math.inf]
ot_forbid = 0
sp = 0
res = 0
for i in range(n):
    arr = list(R())
    tp = arr[0]
    if tp == 1:
        sp = arr[1]
        while sp > spl[-1]:
            spl.pop()
            res += 1
    elif tp == 2:
        if ot_forbid > 0:
            res += ot_forbid
            ot_forbid = 0
    elif tp == 3:
        if arr[-2] >= sp:
            spl.append(arr[1])
        else:
            res += 1
    elif tp == 4:
        ot_forbid = 0
    elif tp == 5:
        spl = [math.inf]
    else:
        ot_forbid += 1
print(res)
```

### 191

```python
import math
n, m, k, q = list(map(int, input().split()))
right = [-1] * n
left = [-1] * n
for i in range(k):
    row, col = list(map(int, input().split()))
    row -= 1
    col -= 1
    if right[row] == -1:
        right[row] = left[row] = col
    else:
        right[row] = max(right[row], col)
        left[row] = min(left[row], col)
safe = sorted(list([int(qi) - 1 for qi in input().split()]))
lup = [0] * m
rup = [0] * m
j = 0
while j < safe[0]:
    lup[j] = -1
    rup[j] = safe[0]
    j += 1
lup[j] = rup[j] = safe[0]
for i in range(1, q - 1):
    j = safe[i - 1]
    while j < safe[i]:
        lup[j] = safe[i - 1]
        rup[j] = safe[i]
        j += 1
j = safe[-1]
while j < m:
    lup[j] = safe[-1]
    rup[j] = -1
    j += 1
if left[0] == -1:
    left[0] = right[0] = 0
dleft = right[0] + (right[0] - left[0])
dright = right[0]
lastn = 0
for i in range(1, n):
    if left[i] == -1:
        continue
    left_1b = lup[left[lastn]]
    left_2b = rup[left[lastn]]
    right_1b = lup[right[lastn]]
    right_2b = rup[right[lastn]]
    ilen = right[i] - left[i]
    ll1: int
    ll2: int
    rl1: int
    rl2: int
    if left_1b != -1:
        ll1 = left[lastn] - left_1b + abs(right[i] - left_1b)
    else:
        ll1 = math.inf
    if left_2b != -1:
        ll2 = left_2b - left[lastn] + abs(right[i] - left_2b)
    else:
        ll2 = math.inf
    if right_1b != -1:
        rl1 = right[lastn] - right_1b + abs(right[i] - right_1b)
    else:
        rl1 = math.inf
    if right_2b != -1:
        rl2 = right_2b - right[lastn] + abs(right[i] - right_2b)
    else:
        rl2 = math.inf
    dleft_new = min(dleft + min(ll1, ll2), dright + min(rl1, rl2)) + ilen
    lr1: int
    lr2: int
    rr1: int
    rr2: int
    if left_1b != -1:
        lr1 = left[lastn] - left_1b + abs(left[i] - left_1b)
    else:
        lr1 = math.inf
    if left_2b != -1:
        lr2 = left_2b - left[lastn] + abs(left[i] - left_2b)
    else:
        lr2 = math.inf
    if right_1b != -1:
        rr1 = right[lastn] - right_1b + abs(left[i] - right_1b)
    else:
        rr1 = math.inf
    if right_2b != -1:
        rr2 = right_2b - right[lastn] + abs(left[i] - right_2b)
    else:
        rr2 = math.inf
    dright_new = min(dleft + min(lr1, lr2), dright + min(rr1, rr2)) + ilen
    dleft, dright = (dleft_new, dright_new)
    lastn = i
print(min(dleft, dright) + lastn)
```

### 192

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

### 193

```python
n = int(input())
influences = [[], [], [], []]
for i in range(0, n):
    [support, influence] = [x for x in input().split()]
    support = int(support, 2)
    influences[support].append(int(influence))
for i in range(0, 4):
    influences[i] = sorted(influences[i])
    influences[i].reverse()
total_influence = 0
total_influence += sum(influences[3])
min_size = min(len(influences[0]), len(influences[1]))
total_influence += sum(influences[1][:min_size]) + sum(influences[2][:min_size])
size = len(influences[3])
influences[0] += influences[1][min_size:] + influences[2][min_size:]
influences[0] = sorted(influences[0])
influences[0].reverse()
total_influence += sum(influences[0][:size])
print(total_influence)
```

### 194

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

### 195

```python
def min_sub_array(day, k):
    if not day:
        return [0] * (k + 1)
    n = len(day)
    best = [float('inf')] * (n + 1)
    best[0] = 0
    best[1] = 1
    for size in range(2, n + -1):
        for i in range(n + 1 - size):
            best[size] = min(best[size], day[i + size - 1] - day[i] + 1)
    output = [0] * (k + 1)
    for i in range(k + 1):
        if n - i > 0:
            output[i] = best[n - i]
    return output
N, M, K = list(map(int, input().split()))
day = [i for i, val in enumerate(input()) if val == '1']
best = min_sub_array(day, K)
for _ in range(N - 1):
    day = [i for i, val in enumerate(input()) if val == '1']
    new_day_best = min_sub_array(day, K)
    new_best = [float('inf')] * (K + 1)
    for i in range(K + 1):
        for j in range(i + 1):
            new_best[i] = min(new_best[i], new_day_best[j] + best[i - j])
    best = new_best
print(best[K])
```

### 196

```python
from collections import defaultdict

def solve():
    N, C = map(int, input().split())
    arr = [int(k) for k in input().split()]
    cnt = 0
    best = 0
    freq = defaultdict(int)
    for i in range(N):
        freq[arr[i]] = max(freq[arr[i]], freq[C - 1])
        '\n        if arr[i] == C:\n            cnt += 1\n            if freq:\n                cur = max(freq.values())\n                if cur > best:\n                    best = cur\n                \n                freq = defaultdict(int)\n            continue\n        '
        freq[arr[i]] += 1
        cur = freq[arr[i]] - freq[C]
        if cur > best:
            best = cur
    print(best + freq[C])
solve()
```

### 197

```python
def inter(l1, r1, l2, r2):
    l = max(l1, l2)
    r = min(r1, r2)
    return max(r - l, 0)

def solve():
    n, k = map(int, input().split())
    al, ar = map(int, input().split())
    bl, br = map(int, input().split())
    res = inter(al, ar, bl, br) * n
    goodt = max(ar, br) - min(al, bl) - inter(al, ar, bl, br)
    minhodi = 1000000000000
    hodi = 0
    to_soed = max(0, max(al, bl) - min(ar, br))
    if res >= k:
        print(0)
        return 0
    for i in range(n):
        hodi += to_soed
        ineed = k - res
        if goodt >= ineed:
            hodi *= ineed
            minhodi = min(minhodi, hodi)
            break
        hodi += goodt
        res += goodt
        minhodi = min(hodi + (k - res) * 2, minhodi)
    print(minhodi)
for i in range(int(input())):
    solve()
```

### 198

```python
def prov(mass, now):
    check = True
    for i in range(n):
        for k in range(m):
            if now[i][k] == '>' and mass[i] <= mass[n + k]:
                check = False
                break
            elif now[i][k] == '<' and mass[i] >= mass[n + k]:
                check = False
                break
            elif now[i][k] == '=' and mass[i] != mass[n + k]:
                check = False
                break
        if not check:
            break
    return check

def prog(mass, n, m):
    prov = True
    for i in range(1, m):
        for k in range(n):
            if mass[i][k] < mass[i - 1][k]:
                prov = False
                break
        if not prov:
            break
    if not prov:
        return False
    else:
        mass_new = []
        for i in range(1, m):
            mass_n = []
            for k in range(n):
                mass_n.append(mass[i][k] - mass[i - 1][k])
            mass_new.append(max(mass_n))
        arr = [1 for i in range(m)]
        now = 1
        if 1 in mass[0][:-1]:
            now += 1
            arr = [2 for i in range(m)]
        for i in range(1, m):
            now += mass_new[i - 1]
            arr[mass[i][-1]] = now
        return arr
n, m = map(int, input().split())
if n + m <= 6:
    now = []
    for i in range(n):
        now.append(input())
    ppp = True
    for i1 in range(n + m):
        for i2 in range(n * m):
            for i3 in range(n + m):
                for i4 in range(n + m):
                    for i5 in range(n + m):
                        for i6 in range(n + m):
                            mass = [i1 + 1, i2 + 1, i3 + 1, i4 + 1, i5 + 1, i6 + 1][:n + m]
                            if prov(mass, now) and ppp:
                                print('Yes')
                                print(*mass[:n])
                                print(*mass[n:])
                                ppp = False
    if ppp:
        print('No')
else:
    mass = [[] for i in range(m)]
    mass1 = [[] for i in range(n)]
    for i in range(n):
        now = input()
        for k in range(m):
            if now[k] == '<':
                mass[k].append(1)
                mass1[i].append(-1)
            elif now[k] == '=':
                mass[k].append(0)
                mass1[i].append(0)
            else:
                mass[k].append(-1)
                mass1[i].append(1)
    for i in range(m):
        mass[i].append(i)
    for i in range(n):
        mass1[i].append(i)
    mass.sort()
    mass1.sort()
    arr = prog(mass, n, m)
    arr1 = prog(mass1, m, n)
    if arr == False or arr1 == False:
        print('No')
    else:
        print('Yes')
        print(*arr1)
        print(*arr)
```

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

### 200

```python
n, c = list(map(int, input().split(' ')))
nums = list(map(int, input().split(' ')))
cPast = 0
countC = 0
for value in nums:
    if value == c:
        countC += 1

def sawC(groupsList):
    for key, groups in list(groupsList.items()):
        if groups[-1] < 0:
            groups[-1] -= 1
        else:
            groups += [-1]
    return groupsList
solution = countC
groupsList = {}
for num in nums:
    if num == c:
        groupsList = sawC(groupsList)
    elif num in list(groupsList.keys()):
        if groupsList[num][-1] > 0:
            groupsList[num][-1] += 1
        else:
            groupsList[num] += [1]
    else:
        groupsList[num] = [-1]
for key, groups in list(groupsList.items()):
    maxDiff = 1
    currDiff = 0
    newDiff = 0
    for group in groups:
        currDiff += group
        if group > currDiff:
            currDiff = group
        if currDiff > maxDiff:
            maxDiff = currDiff
    if maxDiff + countC > solution:
        solution = countC + maxDiff
print(solution)
```

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