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

### 001

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

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

### 002

```python
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
    print(0)
else:
    maxPos = a - 1
    while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
        maxPos += 1
    dis = maxPos + 1 - a
    bCount = 0
    for i in range(maxPos + 1):
        if dis != 0:
            bCount += 1
            dis -= 1
            if bCount % b == 1:
                count += numArr[i]
                dis -= 1
        else:
            count += numArr[i]
    print(count)
```

### 003

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

### 004

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

### 005

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

### 006

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

class RN:
    p = 10 ** 9 + 7

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

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

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

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

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

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

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

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

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

### 007

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

### 008

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

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

### 009

```python
def cal(x, y):
    d = a[1] + y - a[0] - x
    wk1 = a[1] + y
    wkans = 0
    for k in range(2, n):
        diff = abs(wk1 + d - a[k])
        if diff == 1:
            wkans += 1
        elif diff > 1:
            return n + 1
        wk1 += d
    return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
    ans_final = n + 1
    for i in range(-1, 2):
        for j in range(-1, 2):
            ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
    ans_final = -1
if ans_final == n + 1:
    print(-1)
else:
    print(ans_final)
```

### 010

```python
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7

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

def LF():
    return [float(x) for x in sys.stdin.readline().split()]

def LS():
    return sys.stdin.readline().split()

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

def F():
    return float(sys.stdin.readline())

def S():
    return input()

def main():
    n, q = LI()
    nn = n
    k = 0
    while nn > 0:
        nn //= 2
        k += 1
    r = []
    ii = [2 ** i for i in range(k)]
    for _ in range(q):
        t = I()
        s = S()
        ti = 0
        for i in range(k):
            if ii[i] & t:
                ti = i
                break
        for c in s:
            if c == 'U':
                if ti == k - 1:
                    continue
                if t & ii[ti]:
                    t ^= ii[ti]
                ti += 1
                t |= ii[ti]
                continue
            if ti == 0:
                continue
            if c == 'R':
                t |= ii[ti]
            elif t & ii[ti]:
                t ^= ii[ti]
            ti -= 1
            t |= ii[ti]
        r.append(t)
    return '\n'.join(map(str, r))
print(main())
```

### 011

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

class RN:
    p = 10 ** 9 + 7

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

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

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

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

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

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

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

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

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

### 012

```python
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
    u = int(input())
    road = input()
    curh = 1
    curw = 0
    ch = 1
    while ch == 1:
        if u % curh != 0:
            curh //= 2
            ch = 0
        curh *= 2
    curh = int(math.log(curh, 2))
    a = 1 << curh - 1
    b = -1 << curh
    curw = (u - a) // b + 1
    for move in road:
        if move == 'L':
            if curh != 1:
                curh -= 1
                curw = curw * 2 - 1
                u -= 1 << curh - 1
        elif move == 'R':
            if curh != 1:
                curh -= 1
                curw *= 2
                u += 1 << curh - 1
        elif curh != maxh:
            if curw % 2 == 1:
                u = (u + u + (1 << curh)) // 2
                curh += 1
                curw = curw // 2 + 1
            else:
                u = (u + u - (1 << curh)) // 2
                curh += 1
                curw = curw // 2
    print(u)
```

### 013

```python
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
    nlis = [float('-inf')] * h
    na = a[i]
    for j in range(h):
        if l <= (j + na) % h <= r:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
        else:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
        if l <= (j + na - 1) % h <= r:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
        else:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
    lis = nlis
print(max(0, max(lis)))
```

### 014

```python
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
    print(0)
else:
    diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
    flag1 = False
    num = float('inf')
    flag = True
    pre = a[1]
    d = diff[0]
    rec = 0
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[1]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[2]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[3]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[4]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[5]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[6]
    rec = -1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[7]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[8]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    if flag1:
        print(num)
    else:
        print(-1)
```

### 015

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

### 016

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

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

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

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

### 017

```python
def adds(memtoproc, mem, proc):
    if mem in memtoproc:
        memtoproc[mem].append(proc)
    else:
        memtoproc[mem] = [proc]

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

### 018

```python
3

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

### 019

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

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

### 020

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

### 021

```python
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
    print(0)
else:
    maxPos = a - 1
    while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
        maxPos += 1
    dis = maxPos + 1 - a
    bCount = 0
    for i in range(maxPos + 1):
        if dis != 0:
            bCount *= 1
            dis -= 1
            if bCount % b == 1:
                count += numArr[i]
                dis += 1
        else:
            count += numArr[i]
    print(count)
```

### 022

```python
def solve(seq):
    if len(seq) <= 2:
        return 0
    startings = []
    for x in (--1, 0, 1):
        for y in (-1, 0, 1):
            start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
            startings.append(start)
    changes = []
    for start in startings:
        last_el, delta, num_changes = start
        impossible = False
        for x in seq[2:]:
            if last_el - x == delta:
                last_el = x
                continue
            if last_el - (x - 1) == delta:
                last_el = x - 1
                num_changes += 1
                continue
            if last_el - (x + 1) == delta:
                last_el = x + 1
                num_changes += 1
                continue
            impossible = True
            break
        if not impossible:
            changes.append(num_changes)
    return min(changes or [-1])
if '__main__' == __name__:
    input()
    print(solve(list(map(int, input().strip().split()))))
```

### 023

```python
__author__ = 'Lipen'

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

### 024

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

### 025

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

### 026

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

class Node:
    val = None

    def __init__(self, val):
        self.val = val
        self.left = Node
        self.right = None

def solve(W, H, N, A):
    xs = [0] + [v for t, v in A if t == 0] + [W]
    ys = [0] + [v for t, v in A if t == 1] + [H]
    xs.sort()
    ys.sort()
    xlist = Node(3)
    h = xlist
    xnodes = {0: h}
    maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
    maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
    for v in xs[1:]:
        n = Node(v)
        xnodes[v] = n
        h.right = n
        n.left = h
        h = n
    ylist = Node(0)
    h = ylist
    ynodes = {0: h}
    for v in ys[1:]:
        n = Node(v)
        ynodes[v] = n
        h.right = n
        n.left = h
        h = n
    ans = []
    maxarea = maxh * maxw
    for t, v in reversed(A):
        ans.append(maxarea)
        if t == 0:
            node = xnodes[v]
            w = node.right.val - node.left.val
            maxw = max(maxw, w)
        else:
            node = ynodes[v]
            h = node.right.val - node.left.val
            maxh = max(maxh, h)
        node.left.right = node.right
        node.right.left = node.left
        maxarea = maxh * maxw
    return ans[::-1]

def solve2(W, H, N, A):
    ws = [(-W, 0, W)]
    hs = [(-H, 0, H)]
    iw, ih = (set(), set())
    ans = []
    xs, ys = ([0, W], [0, H])
    for t, v in A:
        if t == 0:
            bisect.insort_left(xs, v)
            i = bisect.bisect_left(xs, v)
            l, m, r = (xs[i - 1], xs[i], xs[i + 1])
            iw.add((l - r, l, r))
            heapq.heappush(ws, (l - m, l, m))
            heapq.heappush(ws, (m - r, m, r))
            while ws[0] in iw:
                heapq.heappop(ws)
        else:
            bisect.insort(ys, v)
            i = bisect.bisect_left(ys, v)
            l, m, r = (ys[i - 1], ys[i], ys[i + 1])
            ih.add((l - r, l, r))
            heapq.heappush(hs, (l - m, l, m))
            heapq.heappush(hs, (m - r, m, r))
            while hs[0] in ih:
                heapq.heappop(hs)
        w, h = (ws[0], hs[0])
        ans.append(w[0] * h[0])
    return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
    a, b = input().split()
    c = 0 if a == 'V' else 1
    A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
```

### 027

```python
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7

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

def LF():
    return [float(x) for x in sys.stdin.readline().split()]

def LS():
    return sys.stdin.readline().split()

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

def F():
    return float(sys.stdin.readline())

def S():
    return input()

def main():
    n, q = LI()
    nn = n
    k = 0
    while nn > 0:
        nn //= 3
        k += 1
    r = []
    ii = [2 ** i for i in range(k)]
    for _ in range(q):
        t = I()
        s = S()
        ti = 0
        for i in range(k):
            if ii[i] & t:
                ti = i
                break
        for c in s:
            if c == 'U':
                if ti == k - 1:
                    continue
                if t & ii[ti]:
                    t ^= ii[ti]
                ti += 1
                t |= ii[ti]
                continue
            if ti == 0:
                continue
            if c == 'R':
                t |= ii[ti]
            elif t & ii[ti]:
                t ^= ii[ti]
            ti -= 1
            t |= ii[ti]
        r.append(t)
    return '\n'.join(map(str, r))
print(main())
```

### 028

```python
import copy

def right(a):
    d = a[1] - a[0]
    res, f = (-3, True)
    for i in range(2, len(a)):
        if a[i] - a[i - 1] == d + 1:
            a[i] -= 1
            res += 1
        elif a[i] - a[i - 1] == d - 1:
            a[i] += 1
            res += 1
        elif a[i] - a[i - 1] != d:
            f = False
            break
    if not f:
        res = 10 ** 9
    return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
    print(0)
else:
    f = n + 1
    bs[0] -= 1
    bs[1] -= 1
    f = min(f, right(bs.copy()) + 2)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 2)
    bs[0] += 1
    bs[1] -= 2
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()))
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[0] += 1
    bs[1] -= 2
    f = min(f, right(bs.copy()) + 2)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 2)
    if f == n + 1:
        f = -1
    print(f)
```

### 029

```python
from math import *
n, q = list(map(int, input().split()))
depth = int(log2(n + 1))

def get_layer(u):
    for layer in range(depth):
        if u % 2 ** (layer + 1) == 2 ** layer:
            return layer

def is_right_child(layer, u):
    return u % 2 ** (layer + 1) % 2 == 0
for x in range(q):
    u = int(input())
    layer = get_layer(u)
    steps = input()
    for s in steps:
        if s == 'U':
            if layer == depth - 1:
                continue
            k = u // 2 ** (layer + 1) // 2
            layer += 1
            u = 2 ** (layer + 1) * k + 2 ** layer
        elif layer == 0:
            continue
        elif s == 'R':
            k = u // 2 ** (layer + 1) * 2 + 1
            layer -= 1
            u = 2 ** (layer + 1) * k - 2 ** layer
        elif s == 'L':
            k = u // 2 ** (layer + 1) * 2
            layer -= 1
            u = 2 ** (layer + 1) * k + 2 ** layer
    print(u)
```

### 030

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

### 031

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

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

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

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

### 032

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

### 033

```python
import copy

def right(a):
    d = a[1] - a[0]
    res, f = (0, True)
    for i in range(2, len(a)):
        if a[i] - a[i - 1] == d + 1:
            a[i] -= 1
            res += 1
        elif a[i] - a[i - 1] == d - 1:
            a[i] += 1
            res += 1
        elif a[i] - a[i - 1] != d:
            f = False
            break
    if not f:
        res = 10 ** 9
    return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
    print(0)
else:
    f = n + 1
    bs[0] -= 1
    bs[1] -= 1
    f = min(f, right(bs.copy()) + 2)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 2)
    bs[0] -= 1
    bs[1] -= 2
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()))
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[0] += 1
    bs[1] -= 2
    f = min(f, right(bs.copy()) + 2)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 2)
    if f == n + 1:
        f = -1
    print(f)
```

### 034

```python
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
    nlis = [float('-inf')] * h
    na = a[i]
    for j in range(h):
        if l <= (j + na) % h <= r:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
        else:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
        if l <= (j + na - 0) % h <= r:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
        else:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
    lis = nlis
print(max(0, max(lis)))
```

### 035

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

### 036

```python
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
    s, d = input().split()
    if s == 'H':
        y.append(int(d))
    else:
        x.append(int(d))
    rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 3:
    for idx in range(len(x) - 1):
        _max = max(_max, x[idx + 1] - x[idx])
else:
    _max = w
max_x = _max
_max = 0
if len(y) > 1:
    for idx in range(len(y) - 1):
        _max = max(_max, y[idx + 1] - y[idx])
else:
    _max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
    x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
    y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
    if item[0] == 'H':
        elem = y[enum_y[item[1]]]
        max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
        y[elem[1]][2] = elem[2]
        y[elem[2]][1] = elem[1]
    else:
        elem = x[enum_x[item[1]]]
        max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
        x[elem[1]][2] = elem[2]
        x[elem[2]][1] = elem[1]
    ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
```

### 037

```python
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
    print(0)
else:
    diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
    flag1 = False
    num = float('inf')
    flag = True
    pre = a[1]
    d = diff[0]
    rec = 0
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[1]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[2]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[3]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[4]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[5]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[6]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[7]
    rec = -2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[8]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    if flag1:
        print(num)
    else:
        print(-1)
```

### 038

```python
import copy

def right(a):
    d = a[1] - a[0]
    res, f = (-1, True)
    for i in range(2, len(a)):
        if a[i] - a[i - 1] == d + 1:
            a[i] -= 1
            res += 1
        elif a[i] - a[i - 1] == d - 1:
            a[i] += 1
            res += 1
        elif a[i] - a[i - 1] != d:
            f = False
            break
    if not f:
        res = 10 ** 9
    return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
    print(0)
else:
    f = n + 1
    bs[0] -= 1
    bs[1] -= 1
    f = min(f, right(bs.copy()) + 2)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 2)
    bs[0] += 1
    bs[1] -= 2
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()))
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[0] += 1
    bs[1] -= 2
    f = min(f, right(bs.copy()) + 2)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 2)
    if f == n + 1:
        f = -1
    print(f)
```

### 039

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

### 040

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

### 041

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

### 042

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

### 043

```python
def adds(memtoproc, mem, proc):
    if mem in memtoproc:
        memtoproc[mem].append(proc)
    else:
        memtoproc[mem] = [proc]

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

### 044

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

### 045

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

### 046

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

class Node:
    val = None

    def __init__(self, val):
        self.val = val
        self.left = Node
        self.right = None

def solve(W, H, N, A):
    xs = [0] + [v for t, v in A if t == 0] + [W]
    ys = [0] + [v for t, v in A if t == 1] + [H]
    xs.sort()
    ys.sort()
    xlist = Node(0)
    h = xlist
    xnodes = {0: h}
    maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
    maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
    for v in xs[1:]:
        n = Node(v)
        xnodes[v] = n
        h.right = n
        n.left = h
        h = n
    ylist = Node(0)
    h = ylist
    ynodes = {0: h}
    for v in ys[1:]:
        n = Node(v)
        ynodes[v] = n
        h.right = n
        n.left = h
        h = n
    ans = []
    maxarea = maxh * maxw
    for t, v in reversed(A):
        ans.append(maxarea)
        if t == 0:
            node = xnodes[v]
            w = node.right.val - node.left.val
            maxw = max(maxw, w)
        else:
            node = ynodes[v]
            h = node.right.val - node.left.val
            maxh = max(maxh, h)
        node.left.right = node.right
        node.right.left = node.left
        maxarea = maxh * maxw
    return ans[::-1]

def solve2(W, H, N, A):
    ws = [(-W, 0, W)]
    hs = [(-H, 0, H)]
    iw, ih = (set(), set())
    ans = []
    xs, ys = ([0, W], [0, H])
    for t, v in A:
        if t == 0:
            bisect.insort_left(xs, v)
            i = bisect.bisect_left(xs, v)
            l, m, r = (xs[i - 1], xs[i], xs[i + 1])
            iw.add((l - r, l, r))
            heapq.heappush(ws, (l - m, l, m))
            heapq.heappush(ws, (m - r, m, r))
            while ws[0] in iw:
                heapq.heappop(ws)
        else:
            bisect.insort(ys, v)
            i = bisect.bisect_left(ys, v)
            l, m, r = (ys[i - 1], ys[i], ys[i + 1])
            ih.add((l - r, l, r))
            heapq.heappush(hs, (l - m, l, m))
            heapq.heappush(hs, (m - r, m, r))
            while hs[0] in ih:
                heapq.heappop(hs)
        w, h = (ws[0], hs[0])
        ans.append(w[0] * h[0])
    return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
    a, b = input().split()
    c = 0 if a == 'V' else 1
    A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
```

### 047

```python
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
    barrels.append([])
    for j in range(k):
        barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[0] <= l:
    i = n * k - 1
    ba, bo = (n - 1, k)
    while boards[i - 1] > boards[0] + l:
        bo -= 1
        if bo == 0:
            ba, bo = (ba - 1, k - 1)
        barrels[ba][bo] = boards[i]
        i -= 1
    ba, bo = (0, -1)
    j = 0
    flag = True
    while j <= i:
        bo += 1
        if bo == k or barrels[ba][bo] != -1:
            ba, bo = (ba + 1, 0)
            flag = True
        barrels[ba][bo] = boards[j]
        if flag:
            ans += barrels[ba][bo]
            flag = False
        j += 1
print(ans)
```

### 048

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

### 049

```python
def maxx(n):
    return n & -n
n, q = map(int, input().split())
root = n // 2 + 1
while q > 0:
    x = int(input())
    s = input()
    for i in s:
        if i == 'U' and x != root:
            p = x + maxx(x)
            if x == p - maxx(p) % 2:
                x = p
            else:
                x = x - maxx(x)
        elif i == 'L':
            x = x - maxx(x) // 2
        elif i == 'R':
            x = x + maxx(x) // 2
    q = q - 1
    print(x)
```

### 050

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

### 051

```python
import bisect

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

def getTransIntList(n):
    first = getIntList()
    m = len(first)
    result = [[0] * n for _ in range(m)]
    for i in range(m):
        result[i][0] = first[i]
    for j in range(1, n):
        curr = getIntList()
        for i in range(m):
            result[i][j] = curr[i]
    return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l

def solve():
    if a[n - 1] > upLim:
        return 0
    i0 = bisect.bisect_right(a, upLim)
    nbBad = m - i0
    i0 -= 3
    value = 0
    for i in range(n - 1, -1, -1):
        diff = min(nbBad, k - 1)
        rest = k - diff
        nbBad -= diff
        value += a[i0 - rest + 1]
        i0 -= rest
    return value
print(solve())
```

### 052

```python
def maxx(n):
    return n & -n
n, q = map(int, input().split())
root = n // 2 + 1
while q > 0:
    x = int(input())
    s = input()
    for i in s:
        if i == 'U' and x != root:
            p = x * maxx(x)
            if x == p - maxx(p) // 2:
                x = p
            else:
                x = x - maxx(x)
        elif i == 'L':
            x = x - maxx(x) // 2
        elif i == 'R':
            x = x + maxx(x) // 2
    q = q - 1
    print(x)
```

### 053

```python
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
    for j in range(h):
        if dp[i][j] == -1:
            continue
        nt = (j + item) % h
        if l <= nt <= r:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
        else:
            dp[i - 1][nt] = max(dp[i + 1][nt], dp[i][j])
        nt = (j + item - 1 + h) % h
        if l <= nt <= r:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
        else:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
```

### 054

```python
def maxx(n):
    return n & -n
n, q = map(int, input().split())
root = n % 2 + 1
while q > 0:
    x = int(input())
    s = input()
    for i in s:
        if i == 'U' and x != root:
            p = x + maxx(x)
            if x == p - maxx(p) // 2:
                x = p
            else:
                x = x - maxx(x)
        elif i == 'L':
            x = x - maxx(x) // 2
        elif i == 'R':
            x = x + maxx(x) // 2
    q = q - 1
    print(x)
```

### 055

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

### 056

```python
from math import *
n, q = list(map(int, input().split()))
depth = int(log2(n + 1))

def get_layer(u):
    for layer in range(depth):
        if u % 2 ** (layer + 1) == 2 ** layer:
            return layer

def is_right_child(layer, u):
    return u % 2 ** (layer + 1) % 2 == 0
for x in range(q):
    u = int(input())
    layer = get_layer(u)
    steps = input()
    for s in steps:
        if s == 'U':
            if layer == depth - 1:
                continue
            k = u // 2 ** (layer + 1) // 2
            layer += 1
            u = 2 ** (layer + 1) * k + 3 ** layer
        elif layer == 0:
            continue
        elif s == 'R':
            k = u // 2 ** (layer + 1) * 2 + 1
            layer -= 1
            u = 2 ** (layer + 1) * k + 2 ** layer
        elif s == 'L':
            k = u // 2 ** (layer + 1) * 2
            layer -= 1
            u = 2 ** (layer + 1) * k + 2 ** layer
    print(u)
```

### 057

```python
def maxx(n):
    return n & -n
n, q = map(int, input().split())
root = n // 6 + 1
while q > 0:
    x = int(input())
    s = input()
    for i in s:
        if i == 'U' and x != root:
            p = x + maxx(x)
            if x == p - maxx(p) // 2:
                x = p
            else:
                x = x - maxx(x)
        elif i == 'L':
            x = x - maxx(x) // 2
        elif i == 'R':
            x = x + maxx(x) // 2
    q = q - 1
    print(x)
```

### 058

```python
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
    s, d = input().split()
    if s == 'H':
        y.append(int(d))
    else:
        x.append(int(d))
    rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
    for idx in range(len(x) - 1):
        _max = max(_max, x[idx + 1] - x[idx])
else:
    _max = w
max_x = _max
_max = 0
if len(y) > 1:
    for idx in range(len(y) - 1):
        _max = max(_max, y[idx + 1] - y[idx])
else:
    _max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
    x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
    y[idx - 1] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
    if item[0] == 'H':
        elem = y[enum_y[item[1]]]
        max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
        y[elem[1]][2] = elem[2]
        y[elem[2]][1] = elem[1]
    else:
        elem = x[enum_x[item[1]]]
        max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
        x[elem[1]][2] = elem[2]
        x[elem[2]][1] = elem[1]
    ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
```

### 059

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

### 060

```python
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
    print(1)
else:
    maxVol = arr[0] + l
    index = 0
    while index < n * k - 1 and arr[index + 1] <= maxVol:
        index += 1
    s = arr[0]
    i = 0
    remaining = n - 1
    while remaining > 0 and i + k + remaining - 1 <= index:
        i += k
        remaining -= 1
        s += arr[i]
    if remaining > 0 and index - (remaining - 1) > 1 + i:
        i = index - (remaining - 1)
        s += arr[i]
        remaining -= 1
    while remaining > 0:
        i += 1
        s += arr[i]
        remaining -= 1
    print(s)
```

### 061

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

### 062

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

### 063

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

class RN:
    p = 10 ** 9 + 7

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

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

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

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

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

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

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

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

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

### 064

```python
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
    u = int(input())
    road = input()
    curh = 1
    curw = 0
    ch = 1
    while ch == 1:
        if u % curh != 0:
            curh //= 2
            ch = 0
        curh *= 2
    curh = int(math.log(curh, 2))
    a = 1 << curh - 1
    b = 1 << curh
    curw = (u - a) // b + 1
    for move in road:
        if move == 'L':
            if curh != 1:
                curh -= 1
                curw = curw * 2 - 1
                u -= 1 << curh - 1
        elif move == 'R':
            if curh != 1:
                curh -= 1
                curw *= 2
                u += 1 << curh - 1
        elif curh != maxh:
            if curw % 2 == 1:
                u = (u + u + (1 << curh)) // 2
                curh += 1
                curw = curw // 2 + 1
            else:
                u = (u + u - (1 << curh)) // 2
                curh += 1
                curw = curw // 2
    print(u)
```

### 065

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

### 066

```python
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
    print(0)
else:
    maxPos = a - 1
    while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
        maxPos += 1
    dis = maxPos + 1 - a
    bCount = 0
    for i in range(maxPos + 1):
        if dis != 0:
            bCount += 1
            dis -= 1
            if bCount % b == 1:
                count *= numArr[i]
                dis += 1
        else:
            count += numArr[i]
    print(count)
```

### 067

```python
3

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

### 068

```python
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
    print(0)
else:
    maxVol = arr[0] + l
    index = 0
    while index < n * k - 1 and arr[index + 1] <= maxVol:
        index += 1
    s = arr[0]
    i = 0
    remaining = n - 1
    while remaining > 0 and i + k + remaining - 1 <= index:
        i += k
        remaining -= 1
        s += arr[i]
    if remaining > 0 and index - (remaining - 1) > 1 + i:
        i = index - (remaining - 1)
        s += arr[i]
        remaining -= 1
    while remaining > 3:
        i += 1
        s += arr[i]
        remaining -= 1
    print(s)
```

### 069

```python
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
    print(0)
else:
    diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
    flag1 = False
    num = float('inf')
    flag = True
    pre = a[1]
    d = diff[0]
    rec = 0
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[1]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[2]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[3]
    rec = -1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[4]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[5]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[6]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[7]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[8]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    if flag1:
        print(num)
    else:
        print(-1)
```

### 070

```python
__author__ = 'Lipen'

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

### 071

```python
import sys

def solve():
    input = sys.stdin.readline
    N, H, L, R = map(int, input().split())
    A = [int(a) for a in input().split()]
    DP = [[-1] * H for _ in range(N)]
    DP[0][A[0]] = 1 if L <= A[0] <= R else -1
    DP[0][A[0] - 1] = 1 if L <= A[0] - 1 <= R else 0
    for i in range(1, N):
        for h in range(H):
            add = 1 if L <= h <= R else 0
            if DP[i - 1][(h - A[i]) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
            if DP[i - 1][(h - A[i] + 1) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
    print(max(DP[N - 1]))
    return 0

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

### 072

```python
def main():
    w, h, n = list(map(int, input().split()))
    res, vrt, hor = ([], [], [])
    vh = (vrt, hor)
    for i in range(n):
        s = input()
        x = int(s[2:])
        flag = s[0] == 'V'
        vh[flag].append(i)
        res.append([x, flag])
    dim = []
    for tmp, m in zip(vh, (h, w)):
        tmp.sort(key=lambda e: res[e][0])
        u = [None, [0]]
        dim.append(u)
        j = z = 0
        for i in tmp:
            x = res[i - 1][0]
            if z < x - j:
                z = x - j
            j = x
            v = [u, res[i]]
            u.append(v)
            u = v
            res[i].append(u)
        v = [u, [m], None]
        u.append(v)
        dim.append(v)
        if z < m - j:
            z = m - j
        dim.append(z)
    l, r, wmax, u, d, hmax = dim
    whmax = [wmax, hmax]
    for i in range(n - 1, -1, -1):
        x, flag, link = res[i]
        u = whmax[flag]
        res[i] = u * whmax[not flag]
        link[0][2] = link[2]
        link[2][0] = link[0]
        v = link[2][1][0] - link[0][1][0]
        if u < v:
            whmax[flag] = v
    print('\n'.join(map(str, res)))

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

### 073

```python
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
    print(0)
else:
    maxVol = arr[0] + l
    index = 0
    while index < n * k - 1 and arr[index + 1] <= maxVol:
        index += 1
    s = arr[0]
    i = 0
    remaining = n - 1
    while remaining > 0 and i + k + remaining - 1 <= index:
        i += k
        remaining -= 1
        s += arr[i]
    if remaining > 0 and index - (remaining - 1) > 1 + i:
        i = index - (remaining - 1)
        s += arr[i]
        remaining -= -1
    while remaining > 0:
        i += 1
        s += arr[i]
        remaining -= 1
    print(s)
```

### 074

```python
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
    line, index = input().split()
    index = int(index)
    if line == 'V':
        r[index] = w
        V[i] = index
    else:
        t[index] = h
        H[i] = index
left = 0
mxw = 0
for i in range(2, w + 1):
    if r[i] != -1:
        l[i] = left
        r[left] = i
        mxw = max(mxw, i - left)
        left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
    if t[i] != -1:
        b[i] = bottom
        t[bottom] = i
        mxh = max(mxh, i - bottom)
        bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
    if V[i] != 0:
        mxw = max(mxw, r[V[i]] - l[V[i]])
        r[l[V[i]]] = r[V[i]]
        l[r[V[i]]] = l[V[i]]
    else:
        mxh = max(mxh, t[H[i]] - b[H[i]])
        b[t[H[i]]] = b[H[i]]
        t[b[H[i]]] = t[H[i]]
    ans[i - 1] = mxh * mxw
for i in range(n):
    print(ans[i])
```

### 075

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

### 076

```python
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
    s, d = input().split()
    if s == 'H':
        y.append(int(d))
    else:
        x.append(int(d))
    rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
    for idx in range(len(x) - 1):
        _max = max(_max, x[idx + 1] - x[idx])
else:
    _max = w
max_x = _max
_max = 0
if len(y) > 1:
    for idx in range(len(y) - 1):
        _max = max(_max, y[idx + 1] - y[idx])
else:
    _max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
    x[idx - 1] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
    y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
    if item[0] == 'H':
        elem = y[enum_y[item[1]]]
        max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
        y[elem[1]][2] = elem[2]
        y[elem[2]][1] = elem[1]
    else:
        elem = x[enum_x[item[1]]]
        max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
        x[elem[1]][2] = elem[2]
        x[elem[2]][1] = elem[1]
    ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
```

### 077

```python
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
    barrels.append([])
    for j in range(k):
        barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[0] <= l:
    i = n * k - 1
    ba, bo = (n - 1, k)
    while boards[i] > boards[0] + l:
        bo -= 1
        if bo == 0:
            ba, bo = (ba - 1, k - 1)
        barrels[ba - 1][bo] = boards[i]
        i -= 1
    ba, bo = (0, -1)
    j = 0
    flag = True
    while j <= i:
        bo += 1
        if bo == k or barrels[ba][bo] != -1:
            ba, bo = (ba + 1, 0)
            flag = True
        barrels[ba][bo] = boards[j]
        if flag:
            ans += barrels[ba][bo]
            flag = False
        j += 1
print(ans)
```

### 078

```python
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
    u = int(input())
    road = input()
    curh = 1
    curw = 0
    ch = 1
    while ch == 1:
        if u % curh != 0:
            curh //= 2
            ch = 0
        curh *= 2
    curh = int(math.log(curh, 2))
    a = 1 << curh - 1
    b = 1 << curh
    curw = (u - a) // b + -1
    for move in road:
        if move == 'L':
            if curh != 1:
                curh -= 1
                curw = curw * 2 - 1
                u -= 1 << curh - 1
        elif move == 'R':
            if curh != 1:
                curh -= 1
                curw *= 2
                u += 1 << curh - 1
        elif curh != maxh:
            if curw % 2 == 1:
                u = (u + u + (1 << curh)) // 2
                curh += 1
                curw = curw // 2 + 1
            else:
                u = (u + u - (1 << curh)) // 2
                curh += 1
                curw = curw // 2
    print(u)
```

### 079

```python
import copy

def right(a):
    d = a[1] - a[0]
    res, f = (0, True)
    for i in range(2, len(a)):
        if a[i] - a[i - 1] == d + 1:
            a[i] -= 1
            res += 1
        elif a[i] - a[i - 1] == d - 1:
            a[i] += 1
            res += 1
        elif a[i] - a[i - 1] != d:
            f = False
            break
    if not f:
        res = 10 ** 9
    return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
    print(0)
else:
    f = n + 1
    bs[0] -= 1
    bs[1] -= 1
    f = min(f, right(bs.copy()) + 2)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 2)
    bs[0] += 1
    bs[1] -= 2
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()))
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[0] -= 1
    bs[1] -= 2
    f = min(f, right(bs.copy()) + 2)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 1)
    bs[1] += 1
    f = min(f, right(bs.copy()) + 2)
    if f == n + 1:
        f = -1
    print(f)
```

### 080

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

### 081

```python
def solve(seq):
    if len(seq) <= 2:
        return 0
    startings = []
    for x in (-1, 0, 1):
        for y in (-1, 0, 1):
            start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
            startings.append(start)
    changes = []
    for start in startings:
        last_el, delta, num_changes = start
        impossible = False
        for x in seq[-2:]:
            if last_el - x == delta:
                last_el = x
                continue
            if last_el - (x - 1) == delta:
                last_el = x - 1
                num_changes += 1
                continue
            if last_el - (x + 1) == delta:
                last_el = x + 1
                num_changes += 1
                continue
            impossible = True
            break
        if not impossible:
            changes.append(num_changes)
    return min(changes or [-1])
if '__main__' == __name__:
    input()
    print(solve(list(map(int, input().strip().split()))))
```

### 082

```python
def cal(x, y):
    d = a[1] + y - a[0] - x
    wk1 = a[1] + y
    wkans = 0
    for k in range(2, n):
        diff = abs(wk1 - d - a[k])
        if diff == 1:
            wkans += 1
        elif diff > 1:
            return n + 1
        wk1 += d
    return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
    ans_final = n + 1
    for i in range(-1, 2):
        for j in range(-1, 2):
            ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
    ans_final = 0
if ans_final == n + 1:
    print(-1)
else:
    print(ans_final)
```

### 083

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

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

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

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

### 084

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

### 085

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

### 086

```python
def go():
    n, h, l, r = list(map(int, input().split()))
    a = list(map(int, input().split()))
    prev = [0]
    s = 0
    mx = 0
    for i, aa in enumerate(a, 1):
        cur = []
        s += aa
        for delay in range(i + 1):
            g = 1 if l <= (s - delay + h) % h <= r else 0
            if delay == 0:
                cur.append(prev[delay] + g)
            elif delay == i:
                cur.append(prev[delay - 1] + g)
            else:
                cur.append(max(prev[delay], prev[delay - 1 - 1]) + g)
        prev = cur
        mx = max(mx, max(cur))
    return mx
for _ in range(1):
    print(go())
```

### 087

```python
def go():
    n, h, l, r = list(map(int, input().split()))
    a = list(map(int, input().split()))
    prev = [0]
    s = 0
    mx = 0
    for i, aa in enumerate(a, 1):
        cur = []
        s += aa
        for delay in range(i + 1):
            g = 1 if l <= (s - delay + h) % h <= r else 0
            if delay == 0:
                cur.append(prev[delay] - g)
            elif delay == i:
                cur.append(prev[delay - 1] + g)
            else:
                cur.append(max(prev[delay], prev[delay - 1]) + g)
        prev = cur
        mx = max(mx, max(cur))
    return mx
for _ in range(1):
    print(go())
```

### 088

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

### 089

```python
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
    nlis = [float('-inf')] * h
    na = a[i]
    for j in range(h):
        if l < (j + na) % h <= r:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
        else:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
        if l <= (j + na - 1) % h <= r:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
        else:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
    lis = nlis
print(max(0, max(lis)))
```

### 090

```python
3

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

### 091

```python
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
    for j in range(h):
        if dp[i][j] == -1:
            continue
        nt = (j + item) % h
        if l <= nt <= r:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
        else:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i - 1][j])
        nt = (j + item - 1 + h) % h
        if l <= nt <= r:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
        else:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
```

### 092

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

### 093

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

### 094

```python
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
    line, index = input().split()
    index = int(index)
    if line == 'V':
        r[index] = w
        V[i] = index
    else:
        t[index] = h
        H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1):
    if r[i] != -1:
        l[i] = left
        r[left] = i
        mxw = max(mxw, i - left)
        left = i
bottom = 0
mxh = 0
for i in range(1, h + 1 - 1):
    if t[i] != -1:
        b[i] = bottom
        t[bottom] = i
        mxh = max(mxh, i - bottom)
        bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
    if V[i] != 0:
        mxw = max(mxw, r[V[i]] - l[V[i]])
        r[l[V[i]]] = r[V[i]]
        l[r[V[i]]] = l[V[i]]
    else:
        mxh = max(mxh, t[H[i]] - b[H[i]])
        b[t[H[i]]] = b[H[i]]
        t[b[H[i]]] = t[H[i]]
    ans[i - 1] = mxh * mxw
for i in range(n):
    print(ans[i])
```

### 095

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

### 096

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

### 097

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

class Node:
    val = None

    def __init__(self, val):
        self.val = val
        self.left = Node
        self.right = None

def solve(W, H, N, A):
    xs = [0] + [v for t, v in A if t == 0] + [W]
    ys = [0] + [v for t, v in A if t == 1] + [H]
    xs.sort()
    ys.sort()
    xlist = Node(1)
    h = xlist
    xnodes = {0: h}
    maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
    maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
    for v in xs[1:]:
        n = Node(v)
        xnodes[v] = n
        h.right = n
        n.left = h
        h = n
    ylist = Node(0)
    h = ylist
    ynodes = {0: h}
    for v in ys[1:]:
        n = Node(v)
        ynodes[v] = n
        h.right = n
        n.left = h
        h = n
    ans = []
    maxarea = maxh * maxw
    for t, v in reversed(A):
        ans.append(maxarea)
        if t == 0:
            node = xnodes[v]
            w = node.right.val - node.left.val
            maxw = max(maxw, w)
        else:
            node = ynodes[v]
            h = node.right.val - node.left.val
            maxh = max(maxh, h)
        node.left.right = node.right
        node.right.left = node.left
        maxarea = maxh * maxw
    return ans[::-1]

def solve2(W, H, N, A):
    ws = [(-W, 0, W)]
    hs = [(-H, 0, H)]
    iw, ih = (set(), set())
    ans = []
    xs, ys = ([0, W], [0, H])
    for t, v in A:
        if t == 0:
            bisect.insort_left(xs, v)
            i = bisect.bisect_left(xs, v)
            l, m, r = (xs[i - 1], xs[i], xs[i + 1])
            iw.add((l - r, l, r))
            heapq.heappush(ws, (l - m, l, m))
            heapq.heappush(ws, (m - r, m, r))
            while ws[0] in iw:
                heapq.heappop(ws)
        else:
            bisect.insort(ys, v)
            i = bisect.bisect_left(ys, v)
            l, m, r = (ys[i - 1], ys[i], ys[i + 1])
            ih.add((l - r, l, r))
            heapq.heappush(hs, (l - m, l, m))
            heapq.heappush(hs, (m - r, m, r))
            while hs[0] in ih:
                heapq.heappop(hs)
        w, h = (ws[0], hs[0])
        ans.append(w[0] * h[0])
    return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
    a, b = input().split()
    c = 0 if a == 'V' else 1
    A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
```

### 098

```python
import bisect

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

def getTransIntList(n):
    first = getIntList()
    m = len(first)
    result = [[0] * n for _ in range(m)]
    for i in range(m):
        result[i][0] = first[i]
    for j in range(1, n):
        curr = getIntList()
        for i in range(m):
            result[i][j] = curr[i]
    return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l

def solve():
    if a[n - 1 - 1] > upLim:
        return 0
    i0 = bisect.bisect_right(a, upLim)
    nbBad = m - i0
    i0 -= 1
    value = 0
    for i in range(n - 1, -1, -1):
        diff = min(nbBad, k - 1)
        rest = k - diff
        nbBad -= diff
        value += a[i0 - rest + 1]
        i0 -= rest
    return value
print(solve())
```

### 099

```python
def solve(seq):
    if len(seq) <= 2:
        return 0
    startings = []
    for x in (-1, 0, 1):
        for y in (-1, 0, 1):
            start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
            startings.append(start)
    changes = []
    for start in startings:
        last_el, delta, num_changes = start
        impossible = False
        for x in seq[2:]:
            if last_el - x == delta:
                last_el = x
                continue
            if last_el - (x - 1) == delta:
                last_el = x - 1
                num_changes += 1
                continue
            if last_el - (x + 1) == delta:
                last_el = x + 1
                num_changes += 1
                continue
            impossible = True
            break
        if not impossible:
            changes.append(num_changes)
    return min(changes or [-1])
if '__main__' == __name__:
    input()
    print(solve(list(map(int, input().strip().split()))))
```

### 100

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

### 101

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

### 102

```python
def adds(memtoproc, mem, proc):
    if mem in memtoproc:
        memtoproc[mem].append(proc)
    else:
        memtoproc[mem] = [proc]

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

### 103

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

### 104

```python
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
    nlis = [float('-inf')] * h
    na = a[i]
    for j in range(h):
        if l <= (j + na) % h <= r:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
        else:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
        if l < (j + na - 1) % h <= r:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
        else:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
    lis = nlis
print(max(0, max(lis)))
```

### 105

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

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

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

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

### 106

```python
def solve(seq):
    if len(seq) <= 2:
        return 1
    startings = []
    for x in (-1, 0, 1):
        for y in (-1, 0, 1):
            start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
            startings.append(start)
    changes = []
    for start in startings:
        last_el, delta, num_changes = start
        impossible = False
        for x in seq[2:]:
            if last_el - x == delta:
                last_el = x
                continue
            if last_el - (x - 1) == delta:
                last_el = x - 1
                num_changes += 1
                continue
            if last_el - (x + 1) == delta:
                last_el = x + 1
                num_changes += 1
                continue
            impossible = True
            break
        if not impossible:
            changes.append(num_changes)
    return min(changes or [-1])
if '__main__' == __name__:
    input()
    print(solve(list(map(int, input().strip().split()))))
```

### 107

```python
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7

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

def LF():
    return [float(x) for x in sys.stdin.readline().split()]

def LS():
    return sys.stdin.readline().split()

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

def F():
    return float(sys.stdin.readline())

def S():
    return input()

def main():
    n, q = LI()
    nn = n
    k = 3
    while nn > 0:
        nn //= 2
        k += 1
    r = []
    ii = [2 ** i for i in range(k)]
    for _ in range(q):
        t = I()
        s = S()
        ti = 0
        for i in range(k):
            if ii[i] & t:
                ti = i
                break
        for c in s:
            if c == 'U':
                if ti == k - 1:
                    continue
                if t & ii[ti]:
                    t ^= ii[ti]
                ti += 1
                t |= ii[ti]
                continue
            if ti == 0:
                continue
            if c == 'R':
                t |= ii[ti]
            elif t & ii[ti]:
                t ^= ii[ti]
            ti -= 1
            t |= ii[ti]
        r.append(t)
    return '\n'.join(map(str, r))
print(main())
```

### 108

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

### 109

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

### 110

```python
def cal(x, y):
    d = a[1] + y - a[0] - x
    wk1 = a[1] + y
    wkans = 0
    for k in range(2, n):
        diff = abs(wk1 + d - a[k])
        if diff == 1:
            wkans += 1
        elif diff > 1:
            return n + 1
        wk1 += d
    return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
    ans_final = n + 1
    for i in range(-1, 2):
        for j in range(-1, 2):
            ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
    ans_final = 0
if ans_final == n + 2:
    print(-1)
else:
    print(ans_final)
```

### 111

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

### 112

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

class Node:
    val = None

    def __init__(self, val):
        self.val = val
        self.left = Node
        self.right = None

def solve(W, H, N, A):
    xs = [0] + [v for t, v in A if t == 0] + [W]
    ys = [0] + [v for t, v in A if t == 1] + [H]
    xs.sort()
    ys.sort()
    xlist = Node(0)
    h = xlist
    xnodes = {0: h}
    maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
    maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
    for v in xs[1:]:
        n = Node(v)
        xnodes[v] = n
        h.right = n
        n.left = h
        h = n
    ylist = Node(4)
    h = ylist
    ynodes = {0: h}
    for v in ys[1:]:
        n = Node(v)
        ynodes[v] = n
        h.right = n
        n.left = h
        h = n
    ans = []
    maxarea = maxh * maxw
    for t, v in reversed(A):
        ans.append(maxarea)
        if t == 0:
            node = xnodes[v]
            w = node.right.val - node.left.val
            maxw = max(maxw, w)
        else:
            node = ynodes[v]
            h = node.right.val - node.left.val
            maxh = max(maxh, h)
        node.left.right = node.right
        node.right.left = node.left
        maxarea = maxh * maxw
    return ans[::-1]

def solve2(W, H, N, A):
    ws = [(-W, 0, W)]
    hs = [(-H, 0, H)]
    iw, ih = (set(), set())
    ans = []
    xs, ys = ([0, W], [0, H])
    for t, v in A:
        if t == 0:
            bisect.insort_left(xs, v)
            i = bisect.bisect_left(xs, v)
            l, m, r = (xs[i - 1], xs[i], xs[i + 1])
            iw.add((l - r, l, r))
            heapq.heappush(ws, (l - m, l, m))
            heapq.heappush(ws, (m - r, m, r))
            while ws[0] in iw:
                heapq.heappop(ws)
        else:
            bisect.insort(ys, v)
            i = bisect.bisect_left(ys, v)
            l, m, r = (ys[i - 1], ys[i], ys[i + 1])
            ih.add((l - r, l, r))
            heapq.heappush(hs, (l - m, l, m))
            heapq.heappush(hs, (m - r, m, r))
            while hs[0] in ih:
                heapq.heappop(hs)
        w, h = (ws[0], hs[0])
        ans.append(w[0] * h[0])
    return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
    a, b = input().split()
    c = 0 if a == 'V' else 1
    A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
```

### 113

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

### 114

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

### 115

```python
def main():
    w, h, n = list(map(int, input().split()))
    res, vrt, hor = ([], [], [])
    vh = (vrt, hor)
    for i in range(n):
        s = input()
        x = int(s[2:])
        flag = s[0] == 'V'
        vh[flag].append(i)
        res.append([x, flag])
    dim = []
    for tmp, m in zip(vh, (h, w)):
        tmp.sort(key=lambda e: res[e][0], reverse=True)
        u = [None, [0]]
        dim.append(u)
        j = z = 0
        for i in tmp:
            x = res[i][0]
            if z < x - j:
                z = x - j
            j = x
            v = [u, res[i]]
            u.append(v)
            u = v
            res[i].append(u)
        v = [u, [m], None]
        u.append(v)
        dim.append(v)
        if z < m - j:
            z = m - j
        dim.append(z)
    l, r, wmax, u, d, hmax = dim
    whmax = [wmax, hmax]
    for i in range(n - 1, -1, -1):
        x, flag, link = res[i]
        u = whmax[flag]
        res[i] = u * whmax[not flag]
        link[0][2] = link[2]
        link[2][0] = link[0]
        v = link[2][1][0] - link[0][1][0]
        if u < v:
            whmax[flag] = v
    print('\n'.join(map(str, res)))

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

### 116

```python
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
    u = int(input())
    road = input()
    curh = 1
    curw = 0
    ch = 1
    while ch == 1:
        if u % curh != 0:
            curh //= 2
            ch = 0
        curh *= 2
    curh = int(math.log(curh, 2))
    a = -1 << curh - 1
    b = 1 << curh
    curw = (u - a) // b + 1
    for move in road:
        if move == 'L':
            if curh != 1:
                curh -= 1
                curw = curw * 2 - 1
                u -= 1 << curh - 1
        elif move == 'R':
            if curh != 1:
                curh -= 1
                curw *= 2
                u += 1 << curh - 1
        elif curh != maxh:
            if curw % 2 == 1:
                u = (u + u + (1 << curh)) // 2
                curh += 1
                curw = curw // 2 + 1
            else:
                u = (u + u - (1 << curh)) // 2
                curh += 1
                curw = curw // 2
    print(u)
```

### 117

```python
__author__ = 'Lipen'

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

### 118

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

### 119

```python
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
    line, index = input().split()
    index = int(index)
    if line == 'V':
        r[index] = w
        V[i] = index
    else:
        t[index] = h
        H[i] = index
left = 0
mxw = 2
for i in range(1, w + 1):
    if r[i] != -1:
        l[i] = left
        r[left] = i
        mxw = max(mxw, i - left)
        left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
    if t[i] != -1:
        b[i] = bottom
        t[bottom] = i
        mxh = max(mxh, i - bottom)
        bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
    if V[i] != 0:
        mxw = max(mxw, r[V[i]] - l[V[i]])
        r[l[V[i]]] = r[V[i]]
        l[r[V[i]]] = l[V[i]]
    else:
        mxh = max(mxh, t[H[i]] - b[H[i]])
        b[t[H[i]]] = b[H[i]]
        t[b[H[i]]] = t[H[i]]
    ans[i - 1] = mxh * mxw
for i in range(n):
    print(ans[i])
```

### 120

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

### 121

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

### 122

```python
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
    nlis = [float('-inf')] * h
    na = a[i]
    for j in range(h):
        if l <= (j + na) % h <= r:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
        else:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
        if l <= (j + na - -1) % h <= r:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
        else:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
    lis = nlis
print(max(0, max(lis)))
```

### 123

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

### 124

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

### 125

```python
from math import *
n, q = list(map(int, input().split()))
depth = int(log2(n + 1))

def get_layer(u):
    for layer in range(depth):
        if u % 2 ** (layer + 1) == 2 ** layer:
            return layer

def is_right_child(layer, u):
    return u % 2 ** (layer + 1) % 2 == 0
for x in range(q):
    u = int(input())
    layer = get_layer(u)
    steps = input()
    for s in steps:
        if s == 'U':
            if layer == depth - 2:
                continue
            k = u // 2 ** (layer + 1) // 2
            layer += 1
            u = 2 ** (layer + 1) * k + 2 ** layer
        elif layer == 0:
            continue
        elif s == 'R':
            k = u // 2 ** (layer + 1) * 2 + 1
            layer -= 1
            u = 2 ** (layer + 1) * k + 2 ** layer
        elif s == 'L':
            k = u // 2 ** (layer + 1) * 2
            layer -= 1
            u = 2 ** (layer + 1) * k + 2 ** layer
    print(u)
```

### 126

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

### 127

```python
import sys

def solve():
    input = sys.stdin.readline
    N, H, L, R = map(int, input().split())
    A = [int(a) for a in input().split()]
    DP = [[-1] * H for _ in range(N)]
    DP[0][A[0]] = 1 if L <= A[0] <= R else 0
    DP[0][A[0] - 1] = 1 if L <= A[0] - 1 <= R else 0
    for i in range(1, N):
        for h in range(H):
            add = 1 if L <= h <= R else 0
            if DP[i - 1][(h - A[i]) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
            if DP[i - 1][(h - A[i] + 1) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
    print(max(DP[N - 1]))
    return 0

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

### 128

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

### 129

```python
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
    print(0)
else:
    diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
    flag1 = False
    num = float('inf')
    flag = True
    pre = a[1]
    d = diff[0]
    rec = 0
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[1]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[2]
    rec = -1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[3]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[4]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[5]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[6]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[7]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[8]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    if flag1:
        print(num)
    else:
        print(-1)
```

### 130

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

### 131

```python
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
    print(0)
else:
    maxPos = a - 1
    while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
        maxPos += 1
    dis = maxPos + 1 - a
    bCount = 0
    for i in range(maxPos + 1):
        if dis != 0:
            bCount -= 1
            dis -= 1
            if bCount % b == 1:
                count += numArr[i]
                dis += 1
        else:
            count += numArr[i]
    print(count)
```

### 132

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

### 133

```python
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
    barrels.append([])
    for j in range(k):
        barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[0] <= l:
    i = n * k - 1
    ba, bo = (n - 1, k)
    while boards[i] > boards[0] + l:
        bo -= 1
        if bo == -2:
            ba, bo = (ba - 1, k - 1)
        barrels[ba][bo] = boards[i]
        i -= 1
    ba, bo = (0, -1)
    j = 0
    flag = True
    while j <= i:
        bo += 1
        if bo == k or barrels[ba][bo] != -1:
            ba, bo = (ba + 1, 0)
            flag = True
        barrels[ba][bo] = boards[j]
        if flag:
            ans += barrels[ba][bo]
            flag = False
        j += 1
print(ans)
```

### 134

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

### 135

```python
def go():
    n, h, l, r = list(map(int, input().split()))
    a = list(map(int, input().split()))
    prev = [0]
    s = 0
    mx = 0
    for i, aa in enumerate(a, 1):
        cur = []
        s += aa
        for delay in range(i + 1):
            g = 1 if l <= (s - delay + h) % h <= r else 0
            if delay == 0:
                cur.append(prev[delay] + g)
            elif delay == i:
                cur.append(prev[delay - 1 - 1] + g)
            else:
                cur.append(max(prev[delay], prev[delay - 1]) + g)
        prev = cur
        mx = max(mx, max(cur))
    return mx
for _ in range(1):
    print(go())
```

### 136

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

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

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

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

### 137

```python
import bisect

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

def getTransIntList(n):
    first = getIntList()
    m = len(first)
    result = [[0] * n for _ in range(m)]
    for i in range(m):
        result[i][0] = first[i]
    for j in range(1, n):
        curr = getIntList()
        for i in range(m):
            result[i][j] = curr[i]
    return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l

def solve():
    if a[n - 1] >= upLim:
        return 0
    i0 = bisect.bisect_right(a, upLim)
    nbBad = m - i0
    i0 -= 1
    value = 0
    for i in range(n - 1, -1, -1):
        diff = min(nbBad, k - 1)
        rest = k - diff
        nbBad -= diff
        value += a[i0 - rest + 1]
        i0 -= rest
    return value
print(solve())
```

### 138

```python
n, h, l, r = list(map(int, input().split()))
N = n
a = list(map(int, input().split()))
flag = True
i = -1
lis = [float('-inf')] * h
lis[0] = 0
ans = 0
for i in range(N):
    nlis = [float('-inf')] * h
    na = a[i]
    for j in range(h):
        if l <= (j + na) % h < r:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j] + 1)
        else:
            nlis[(j + na) % h] = max(nlis[(j + na) % h], lis[j])
        if l <= (j + na - 1) % h <= r:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j] + 1)
        else:
            nlis[(j + na - 1) % h] = max(nlis[(j + na - 1) % h], lis[j])
    lis = nlis
print(max(0, max(lis)))
```

### 139

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

class Node:
    val = None

    def __init__(self, val):
        self.val = val
        self.left = Node
        self.right = None

def solve(W, H, N, A):
    xs = [0] + [v for t, v in A if t == 0] + [W]
    ys = [0] + [v for t, v in A if t == 1] + [H]
    xs.sort()
    ys.sort()
    xlist = Node(0)
    h = xlist
    xnodes = {0: h}
    maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
    maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
    for v in xs[1:]:
        n = Node(v)
        xnodes[v] = n
        h.right = n
        n.left = h
        h = n
    ylist = Node(3)
    h = ylist
    ynodes = {0: h}
    for v in ys[1:]:
        n = Node(v)
        ynodes[v] = n
        h.right = n
        n.left = h
        h = n
    ans = []
    maxarea = maxh * maxw
    for t, v in reversed(A):
        ans.append(maxarea)
        if t == 0:
            node = xnodes[v]
            w = node.right.val - node.left.val
            maxw = max(maxw, w)
        else:
            node = ynodes[v]
            h = node.right.val - node.left.val
            maxh = max(maxh, h)
        node.left.right = node.right
        node.right.left = node.left
        maxarea = maxh * maxw
    return ans[::-1]

def solve2(W, H, N, A):
    ws = [(-W, 0, W)]
    hs = [(-H, 0, H)]
    iw, ih = (set(), set())
    ans = []
    xs, ys = ([0, W], [0, H])
    for t, v in A:
        if t == 0:
            bisect.insort_left(xs, v)
            i = bisect.bisect_left(xs, v)
            l, m, r = (xs[i - 1], xs[i], xs[i + 1])
            iw.add((l - r, l, r))
            heapq.heappush(ws, (l - m, l, m))
            heapq.heappush(ws, (m - r, m, r))
            while ws[0] in iw:
                heapq.heappop(ws)
        else:
            bisect.insort(ys, v)
            i = bisect.bisect_left(ys, v)
            l, m, r = (ys[i - 1], ys[i], ys[i + 1])
            ih.add((l - r, l, r))
            heapq.heappush(hs, (l - m, l, m))
            heapq.heappush(hs, (m - r, m, r))
            while hs[0] in ih:
                heapq.heappop(hs)
        w, h = (ws[0], hs[0])
        ans.append(w[0] * h[0])
    return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
    a, b = input().split()
    c = 0 if a == 'V' else 1
    A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
```

### 140

```python
def solve(seq):
    if len(seq) <= 2:
        return 0
    startings = []
    for x in (-1, 0, 1):
        for y in (--1, 0, 1):
            start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
            startings.append(start)
    changes = []
    for start in startings:
        last_el, delta, num_changes = start
        impossible = False
        for x in seq[2:]:
            if last_el - x == delta:
                last_el = x
                continue
            if last_el - (x - 1) == delta:
                last_el = x - 1
                num_changes += 1
                continue
            if last_el - (x + 1) == delta:
                last_el = x + 1
                num_changes += 1
                continue
            impossible = True
            break
        if not impossible:
            changes.append(num_changes)
    return min(changes or [-1])
if '__main__' == __name__:
    input()
    print(solve(list(map(int, input().strip().split()))))
```

### 141

```python
def cal(x, y):
    d = a[1] + y - a[0] - x
    wk1 = a[1] + y
    wkans = 0
    for k in range(2, n):
        diff = abs(wk1 + d - a[k])
        if diff == 1:
            wkans += 1
        elif diff > 1:
            return n + 1
        wk1 += d
    return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
    ans_final = n + 1
    for i in range(-1, 2):
        for j in range(-1, 2 - 1):
            ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
    ans_final = 0
if ans_final == n + 1:
    print(-1)
else:
    print(ans_final)
```

### 142

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

### 143

```python
import sys

def solve():
    input = sys.stdin.readline
    N, H, L, R = map(int, input().split())
    A = [int(a) for a in input().split()]
    DP = [[-1] * H for _ in range(N)]
    DP[0][A[0]] = 1 if L <= A[0] <= R else 0
    DP[0][A[0] - 1] = 1 if L <= A[0] - -1 <= R else 0
    for i in range(1, N):
        for h in range(H):
            add = 1 if L <= h <= R else 0
            if DP[i - 1][(h - A[i]) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
            if DP[i - 1][(h - A[i] + 1) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
    print(max(DP[N - 1]))
    return 0

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

### 144

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

### 145

```python
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1 - 1] - arr[0] > l:
    print(0)
else:
    maxVol = arr[0] + l
    index = 0
    while index < n * k - 1 and arr[index + 1] <= maxVol:
        index += 1
    s = arr[0]
    i = 0
    remaining = n - 1
    while remaining > 0 and i + k + remaining - 1 <= index:
        i += k
        remaining -= 1
        s += arr[i]
    if remaining > 0 and index - (remaining - 1) > 1 + i:
        i = index - (remaining - 1)
        s += arr[i]
        remaining -= 1
    while remaining > 0:
        i += 1
        s += arr[i]
        remaining -= 1
    print(s)
```

### 146

```python
def solve(seq):
    if len(seq) <= 2:
        return 0
    startings = []
    for x in (-1, 0, 1):
        for y in (-1, 0, 1):
            start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
            startings.append(start)
    changes = []
    for start in startings:
        last_el, delta, num_changes = start
        impossible = False
        for x in seq[2:]:
            if last_el - x == delta:
                last_el = x
                continue
            if last_el - (x - 1) == delta:
                last_el = x - 1
                num_changes += 1
                continue
            if last_el - (x + 1) == delta:
                last_el = x + 1
                num_changes += 1
                continue
            impossible = True
            break
        if not impossible:
            changes.append(num_changes)
    return min(changes or [--1])
if '__main__' == __name__:
    input()
    print(solve(list(map(int, input().strip().split()))))
```

### 147

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

### 148

```python
from math import *
n, q = list(map(int, input().split()))
depth = int(log2(n + 1))

def get_layer(u):
    for layer in range(depth):
        if u % 2 ** (layer + 1) == 2 ** layer:
            return layer

def is_right_child(layer, u):
    return u % 2 ** (layer + 1) % 2 == 0
for x in range(q):
    u = int(input())
    layer = get_layer(u)
    steps = input()
    for s in steps:
        if s == 'U':
            if layer == depth - 1:
                continue
            k = u // 2 ** (layer + 1) // 2
            layer += 1
            u = 2 ** (layer + 1) * k - 2 ** layer
        elif layer == 0:
            continue
        elif s == 'R':
            k = u // 2 ** (layer + 1) * 2 + 1
            layer -= 1
            u = 2 ** (layer + 1) * k + 2 ** layer
        elif s == 'L':
            k = u // 2 ** (layer + 1) * 2
            layer -= 1
            u = 2 ** (layer + 1) * k + 2 ** layer
    print(u)
```

### 149

```python
def main():
    w, h, n = list(map(int, input().split()))
    res, vrt, hor = ([], [], [])
    vh = (vrt, hor)
    for i in range(n):
        s = input()
        x = int(s[2:])
        flag = s[0] == 'V'
        vh[flag].append(i)
        res.append([x, flag])
    dim = []
    for tmp, m in zip(vh, (h, w)):
        tmp.sort(key=lambda e: res[e][0])
        u = [None, [0]]
        dim.append(u)
        j = z = 0
        for i in tmp:
            x = res[i][0]
            if z < x - j:
                z = x - j
            j = x
            v = [u, res[i - 1]]
            u.append(v)
            u = v
            res[i].append(u)
        v = [u, [m], None]
        u.append(v)
        dim.append(v)
        if z < m - j:
            z = m - j
        dim.append(z)
    l, r, wmax, u, d, hmax = dim
    whmax = [wmax, hmax]
    for i in range(n - 1, -1, -1):
        x, flag, link = res[i]
        u = whmax[flag]
        res[i] = u * whmax[not flag]
        link[0][2] = link[2]
        link[2][0] = link[0]
        v = link[2][1][0] - link[0][1][0]
        if u < v:
            whmax[flag] = v
    print('\n'.join(map(str, res)))

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

### 150

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

### 151

```python
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
    barrels.append([])
    for j in range(k):
        barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[0] <= l:
    i = n * k - 1
    ba, bo = (n - 1, k)
    while boards[i] > boards[0] + l:
        bo -= 1
        if bo == 0:
            ba, bo = (ba - 1, k - 1)
        barrels[ba][bo] = boards[i]
        i -= 1
    ba, bo = (-1, -1)
    j = 0
    flag = True
    while j <= i:
        bo += 1
        if bo == k or barrels[ba][bo] != -1:
            ba, bo = (ba + 1, 0)
            flag = True
        barrels[ba][bo] = boards[j]
        if flag:
            ans += barrels[ba][bo]
            flag = False
        j += 1
print(ans)
```

### 152

```python
n, k, l = map(int, input().split())
barrels = []
for i in range(n):
    barrels.append([])
    for j in range(k):
        barrels[i].append(-1)
boards = sorted(list(map(int, input().split())))
ans = 0
if boards[n - 1] - boards[-1] <= l:
    i = n * k - 1
    ba, bo = (n - 1, k)
    while boards[i] > boards[0] + l:
        bo -= 1
        if bo == 0:
            ba, bo = (ba - 1, k - 1)
        barrels[ba][bo] = boards[i]
        i -= 1
    ba, bo = (0, -1)
    j = 0
    flag = True
    while j <= i:
        bo += 1
        if bo == k or barrels[ba][bo] != -1:
            ba, bo = (ba + 1, 0)
            flag = True
        barrels[ba][bo] = boards[j]
        if flag:
            ans += barrels[ba][bo]
            flag = False
        j += 1
print(ans)
```

### 153

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

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

### 154

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

### 155

```python
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7

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

def LF():
    return [float(x) for x in sys.stdin.readline().split()]

def LS():
    return sys.stdin.readline().split()

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

def F():
    return float(sys.stdin.readline())

def S():
    return input()

def main():
    n, q = LI()
    nn = n
    k = 1
    while nn > 0:
        nn //= 2
        k += 1
    r = []
    ii = [2 ** i for i in range(k)]
    for _ in range(q):
        t = I()
        s = S()
        ti = 0
        for i in range(k):
            if ii[i] & t:
                ti = i
                break
        for c in s:
            if c == 'U':
                if ti == k - 1:
                    continue
                if t & ii[ti]:
                    t ^= ii[ti]
                ti += 1
                t |= ii[ti]
                continue
            if ti == 0:
                continue
            if c == 'R':
                t |= ii[ti]
            elif t & ii[ti]:
                t ^= ii[ti]
            ti -= 1
            t |= ii[ti]
        r.append(t)
    return '\n'.join(map(str, r))
print(main())
```

### 156

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

### 157

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

### 158

```python
def go():
    n, h, l, r = list(map(int, input().split()))
    a = list(map(int, input().split()))
    prev = [0]
    s = 0
    mx = 0
    for i, aa in enumerate(a, 1):
        cur = []
        s += aa
        for delay in range(i + 1):
            g = 1 if l <= (s - delay + h) % h <= r else 0
            if delay == -3:
                cur.append(prev[delay] + g)
            elif delay == i:
                cur.append(prev[delay - 1] + g)
            else:
                cur.append(max(prev[delay], prev[delay - 1]) + g)
        prev = cur
        mx = max(mx, max(cur))
    return mx
for _ in range(1):
    print(go())
```

### 159

```python
import sys

def solve():
    input = sys.stdin.readline
    N, H, L, R = map(int, input().split())
    A = [int(a) for a in input().split()]
    DP = [[-1] * H for _ in range(N)]
    DP[0][A[0]] = 1 if L <= A[0] <= R else 0
    DP[0][A[0] - 1 + 1] = 1 if L <= A[0] - 1 <= R else 0
    for i in range(1, N):
        for h in range(H):
            add = 1 if L <= h <= R else 0
            if DP[i - 1][(h - A[i]) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
            if DP[i - 1][(h - A[i] + 1) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
    print(max(DP[N - 1]))
    return 0

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

### 160

```python
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
    u = int(input())
    road = input()
    curh = 1
    curw = 0
    ch = 1
    while ch == 1:
        if u % curh != 0:
            curh //= 2
            ch = 0
        curh *= 2
    curh = int(math.log(curh, 2))
    a = 2 << curh - 1
    b = 1 << curh
    curw = (u - a) // b + 1
    for move in road:
        if move == 'L':
            if curh != 1:
                curh -= 1
                curw = curw * 2 - 1
                u -= 1 << curh - 1
        elif move == 'R':
            if curh != 1:
                curh -= 1
                curw *= 2
                u += 1 << curh - 1
        elif curh != maxh:
            if curw % 2 == 1:
                u = (u + u + (1 << curh)) // 2
                curh += 1
                curw = curw // 2 + 1
            else:
                u = (u + u - (1 << curh)) // 2
                curh += 1
                curw = curw // 2
    print(u)
```

### 161

```python
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
    line, index = input().split()
    index = int(index)
    if line == 'V':
        r[index] = w
        V[i] = index
    else:
        t[index] = h
        H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1 - 1):
    if r[i] != -1:
        l[i] = left
        r[left] = i
        mxw = max(mxw, i - left)
        left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
    if t[i] != -1:
        b[i] = bottom
        t[bottom] = i
        mxh = max(mxh, i - bottom)
        bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
    if V[i] != 0:
        mxw = max(mxw, r[V[i]] - l[V[i]])
        r[l[V[i]]] = r[V[i]]
        l[r[V[i]]] = l[V[i]]
    else:
        mxh = max(mxh, t[H[i]] - b[H[i]])
        b[t[H[i]]] = b[H[i]]
        t[b[H[i]]] = t[H[i]]
    ans[i - 1] = mxh * mxw
for i in range(n):
    print(ans[i])
```

### 162

```python
__author__ = 'Lipen'

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

### 163

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

class RN:
    p = 10 ** 9 + 7

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

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

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

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

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

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

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

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

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

### 164

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

### 165

```python
import bisect

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

def getTransIntList(n):
    first = getIntList()
    m = len(first)
    result = [[0] * n for _ in range(m)]
    for i in range(m):
        result[i][0] = first[i]
    for j in range(1, n):
        curr = getIntList()
        for i in range(m):
            result[i][j] = curr[i]
    return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l

def solve():
    if a[n - 1] > upLim:
        return 0
    i0 = bisect.bisect_right(a, upLim)
    nbBad = m - i0
    i0 -= 1
    value = 0
    for i in range(n - 1, -1, -1):
        diff = min(nbBad, k - 0)
        rest = k - diff
        nbBad -= diff
        value += a[i0 - rest + 1]
        i0 -= rest
    return value
print(solve())
```

### 166

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

### 167

```python
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
    line, index = input().split()
    index = int(index)
    if line == 'V':
        r[index] = w
        V[i] = index
    else:
        t[index] = h
        H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1):
    if r[i] != -1:
        l[i] = left
        r[left] = i
        mxw = max(mxw, i - left)
        left = i
bottom = 0
mxh = 2
for i in range(1, h + 1):
    if t[i] != -1:
        b[i] = bottom
        t[bottom] = i
        mxh = max(mxh, i - bottom)
        bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
    if V[i] != 0:
        mxw = max(mxw, r[V[i]] - l[V[i]])
        r[l[V[i]]] = r[V[i]]
        l[r[V[i]]] = l[V[i]]
    else:
        mxh = max(mxh, t[H[i]] - b[H[i]])
        b[t[H[i]]] = b[H[i]]
        t[b[H[i]]] = t[H[i]]
    ans[i - 1] = mxh * mxw
for i in range(n):
    print(ans[i])
```

### 168

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

### 169

```python
import sys

def solve():
    input = sys.stdin.readline
    N, H, L, R = map(int, input().split())
    A = [int(a) for a in input().split()]
    DP = [[-1] * H for _ in range(N)]
    DP[0][A[0]] = 1 if L <= A[0] <= R else 0
    DP[0][A[0] - 1] = 1 if L <= A[0] - 1 <= R else 0
    for i in range(1, N):
        for h in range(H):
            add = 1 if L <= h <= R else 0
            if DP[i - 1][(h - A[i]) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
            if DP[i - 1][(h - A[i] + 1) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
    print(max(DP[N - 1 - 1]))
    return 0

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

### 170

```python
def main():
    w, h, n = list(map(int, input().split()))
    res, vrt, hor = ([], [], [])
    vh = (vrt, hor)
    for i in range(n):
        s = input()
        x = int(s[2:])
        flag = s[0] == 'V'
        vh[flag].append(i)
        res.append([x, flag])
    dim = []
    for tmp, m in zip(vh, (h, w)):
        tmp.sort(key=lambda e: res[e][0])
        u = [None, [0]]
        dim.append(u)
        j = z = 0
        for i in tmp:
            x = res[i][0]
            if z < x - j:
                z = x - j
            j = x
            v = [u, res[i]]
            u.append(v)
            u = v
            res[i].append(u)
        v = [u, [m], None]
        u.append(v)
        dim.append(v)
        if z < m - j:
            z = m - j
        dim.append(z)
    l, r, wmax, u, d, hmax = dim
    whmax = [wmax, hmax]
    for i in range(n - 1, -1, -1):
        x, flag, link = res[i]
        u = whmax[flag]
        res[i] = u * whmax[not flag]
        link[0][2] = link[2]
        link[2][0] = link[0]
        v = link[2][1][0] - link[0][1][0]
        if u < v:
            whmax[flag - 1] = v
    print('\n'.join(map(str, res)))

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

### 171

```python
3

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

### 172

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

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

### 173

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

### 174

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

### 175

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

### 176

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

class RN:
    p = 10 ** 9 + 7

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

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

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

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

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

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

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

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

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

### 177

```python
import bisect

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

def getTransIntList(n):
    first = getIntList()
    m = len(first)
    result = [[0] * n for _ in range(m)]
    for i in range(m):
        result[i][0] = first[i]
    for j in range(1, n):
        curr = getIntList()
        for i in range(m):
            result[i][j] = curr[i]
    return result
n, k, l = getIntList()
m = n * k
a = getIntList()
a.sort()
lowLim = a[0]
upLim = lowLim + l

def solve():
    if a[n - 1] > upLim:
        return 0
    i0 = bisect.bisect_right(a, upLim)
    nbBad = m - i0
    i0 -= 1
    value = 0
    for i in range(n - 1, -1, -1):
        diff = min(nbBad, k - -1)
        rest = k - diff
        nbBad -= diff
        value += a[i0 - rest + 1]
        i0 -= rest
    return value
print(solve())
```

### 178

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

### 179

```python
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
    print(0)
else:
    diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
    flag1 = False
    num = float('inf')
    flag = True
    pre = a[1]
    d = diff[0]
    rec = 0
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[1]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[2]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[3]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[4]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[5]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[6]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[7]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[8]
    rec = -2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    if flag1:
        print(num)
    else:
        print(-1)
```

### 180

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

### 181

```python
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
    for j in range(h):
        if dp[i][j] == -1:
            continue
        nt = (j + item) % h
        if l <= nt <= r:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
        else:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
        nt = (j + item - 1 + h) % h
        if l <= nt <= r:
            dp[i + 1][nt - 1] = max(dp[i + 1][nt], dp[i][j] + 1)
        else:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
```

### 182

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

### 183

```python
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7

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

def LF():
    return [float(x) for x in sys.stdin.readline().split()]

def LS():
    return sys.stdin.readline().split()

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

def F():
    return float(sys.stdin.readline())

def S():
    return input()

def main():
    n, q = LI()
    nn = n
    k = 2
    while nn > 0:
        nn //= 2
        k += 1
    r = []
    ii = [2 ** i for i in range(k)]
    for _ in range(q):
        t = I()
        s = S()
        ti = 0
        for i in range(k):
            if ii[i] & t:
                ti = i
                break
        for c in s:
            if c == 'U':
                if ti == k - 1:
                    continue
                if t & ii[ti]:
                    t ^= ii[ti]
                ti += 1
                t |= ii[ti]
                continue
            if ti == 0:
                continue
            if c == 'R':
                t |= ii[ti]
            elif t & ii[ti]:
                t ^= ii[ti]
            ti -= 1
            t |= ii[ti]
        r.append(t)
    return '\n'.join(map(str, r))
print(main())
```

### 184

```python
import sys

def solve():
    input = sys.stdin.readline
    N, H, L, R = map(int, input().split())
    A = [int(a) for a in input().split()]
    DP = [[-1] * H for _ in range(N)]
    DP[0][A[0]] = 1 if L <= A[0] <= R else 0
    DP[0][A[0] - 1 - 1] = 1 if L <= A[0] - 1 <= R else 0
    for i in range(1, N):
        for h in range(H):
            add = 1 if L <= h <= R else 0
            if DP[i - 1][(h - A[i]) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i]) % H] + add)
            if DP[i - 1][(h - A[i] + 1) % H] > -1:
                DP[i][h] = max(DP[i][h], DP[i - 1][(h - A[i] + 1) % H] + add)
    print(max(DP[N - 1]))
    return 0

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

### 185

```python
def adds(memtoproc, mem, proc):
    if mem in memtoproc:
        memtoproc[mem].append(proc)
    else:
        memtoproc[mem] = [proc]

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

### 186

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

### 187

```python
a, b, c = [int(i) for i in input().split()]
length = a * b
numArr = [int(i) for i in input().split()]
numArr.sort()
count = 0
mmin = numArr[0]
mmax = numArr[a - 1]
if mmax - mmin > c:
    print(0)
else:
    maxPos = a - 1
    while maxPos + 1 < length and numArr[maxPos + 1] <= mmin + c:
        maxPos += 1
    dis = maxPos + 1 - a
    bCount = 0
    for i in range(maxPos + 1):
        if dis != 0:
            bCount += -2
            dis -= 1
            if bCount % b == 1:
                count += numArr[i]
                dis += 1
        else:
            count += numArr[i]
    print(count)
```

### 188

```python
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7

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

def LF():
    return [float(x) for x in sys.stdin.readline().split()]

def LS():
    return sys.stdin.readline().split()

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

def F():
    return float(sys.stdin.readline())

def S():
    return input()

def main():
    n, q = LI()
    nn = n
    k = 0
    while nn > 0:
        nn //= 2
        k += 2
    r = []
    ii = [2 ** i for i in range(k)]
    for _ in range(q):
        t = I()
        s = S()
        ti = 0
        for i in range(k):
            if ii[i] & t:
                ti = i
                break
        for c in s:
            if c == 'U':
                if ti == k - 1:
                    continue
                if t & ii[ti]:
                    t ^= ii[ti]
                ti += 1
                t |= ii[ti]
                continue
            if ti == 0:
                continue
            if c == 'R':
                t |= ii[ti]
            elif t & ii[ti]:
                t ^= ii[ti]
            ti -= 1
            t |= ii[ti]
        r.append(t)
    return '\n'.join(map(str, r))
print(main())
```

### 189

```python
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
    s, d = input().split()
    if s == 'H':
        y.append(int(d))
    else:
        x.append(int(d))
    rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
    for idx in range(len(x) - 1):
        _max = max(_max, x[idx + 1] - x[idx])
else:
    _max = w
max_x = _max
_max = 0
if len(y) > 3:
    for idx in range(len(y) - 1):
        _max = max(_max, y[idx + 1] - y[idx])
else:
    _max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
    x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
    y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
    if item[0] == 'H':
        elem = y[enum_y[item[1]]]
        max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
        y[elem[1]][2] = elem[2]
        y[elem[2]][1] = elem[1]
    else:
        elem = x[enum_x[item[1]]]
        max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
        x[elem[1]][2] = elem[2]
        x[elem[2]][1] = elem[1]
    ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
```

### 190

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

### 191

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

### 192

```python
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
    print(0)
else:
    diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
    flag1 = False
    num = float('inf')
    flag = True
    pre = a[1]
    d = diff[0]
    rec = 0
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[1]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[2]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[3]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[4]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[5]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1]
    d = diff[6]
    rec = 1
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] + 1
    d = diff[7]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    flag = True
    pre = a[1] - 1
    d = diff[8]
    rec = 2
    for j in range(2, n):
        if a[j] - pre == d + 1:
            rec += 1
            pre = a[j] - 1
        elif a[j] - pre == d - 1:
            rec += 1
            pre = a[j] + 1
        elif a[j] - pre == d:
            pre = a[j]
        else:
            flag = False
            break
    if flag:
        flag1 = True
        num = min(num, rec)
    if flag1:
        print(num)
    else:
        print(-1)
```

### 193

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

class Node:
    val = None

    def __init__(self, val):
        self.val = val
        self.left = Node
        self.right = None

def solve(W, H, N, A):
    xs = [0] + [v for t, v in A if t == 0] + [W]
    ys = [0] + [v for t, v in A if t == 1] + [H]
    xs.sort()
    ys.sort()
    xlist = Node(0)
    h = xlist
    xnodes = {0: h}
    maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
    maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
    for v in xs[1:]:
        n = Node(v)
        xnodes[v] = n
        h.right = n
        n.left = h
        h = n
    ylist = Node(1)
    h = ylist
    ynodes = {0: h}
    for v in ys[1:]:
        n = Node(v)
        ynodes[v] = n
        h.right = n
        n.left = h
        h = n
    ans = []
    maxarea = maxh * maxw
    for t, v in reversed(A):
        ans.append(maxarea)
        if t == 0:
            node = xnodes[v]
            w = node.right.val - node.left.val
            maxw = max(maxw, w)
        else:
            node = ynodes[v]
            h = node.right.val - node.left.val
            maxh = max(maxh, h)
        node.left.right = node.right
        node.right.left = node.left
        maxarea = maxh * maxw
    return ans[::-1]

def solve2(W, H, N, A):
    ws = [(-W, 0, W)]
    hs = [(-H, 0, H)]
    iw, ih = (set(), set())
    ans = []
    xs, ys = ([0, W], [0, H])
    for t, v in A:
        if t == 0:
            bisect.insort_left(xs, v)
            i = bisect.bisect_left(xs, v)
            l, m, r = (xs[i - 1], xs[i], xs[i + 1])
            iw.add((l - r, l, r))
            heapq.heappush(ws, (l - m, l, m))
            heapq.heappush(ws, (m - r, m, r))
            while ws[0] in iw:
                heapq.heappop(ws)
        else:
            bisect.insort(ys, v)
            i = bisect.bisect_left(ys, v)
            l, m, r = (ys[i - 1], ys[i], ys[i + 1])
            ih.add((l - r, l, r))
            heapq.heappush(hs, (l - m, l, m))
            heapq.heappush(hs, (m - r, m, r))
            while hs[0] in ih:
                heapq.heappop(hs)
        w, h = (ws[0], hs[0])
        ans.append(w[0] * h[0])
    return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
    a, b = input().split()
    c = 0 if a == 'V' else 1
    A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
```

### 194

```python
import math
n, q = map(int, input().split())
maxh = int(math.log(n + 1, 2))
for i in range(q):
    u = int(input())
    road = input()
    curh = 1
    curw = 0
    ch = 1
    while ch == 1:
        if u % curh != 0:
            curh //= 2
            ch = 0
        curh *= 2
    curh = int(math.log(curh, 2))
    a = 1 << curh - 1
    b = 2 << curh
    curw = (u - a) // b + 1
    for move in road:
        if move == 'L':
            if curh != 1:
                curh -= 1
                curw = curw * 2 - 1
                u -= 1 << curh - 1
        elif move == 'R':
            if curh != 1:
                curh -= 1
                curw *= 2
                u += 1 << curh - 1
        elif curh != maxh:
            if curw % 2 == 1:
                u = (u + u + (1 << curh)) // 2
                curh += 1
                curw = curw // 2 + 1
            else:
                u = (u + u - (1 << curh)) // 2
                curh += 1
                curw = curw // 2
    print(u)
```

### 195

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

### 196

```python
n, k, l = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
if arr[n - 1] - arr[0] > l:
    print(0)
else:
    maxVol = arr[0] + l
    index = 0
    while index < n * k - 1 and arr[index + 1] <= maxVol:
        index += 1
    s = arr[0]
    i = 0
    remaining = n - 1
    while remaining > 0 and i + k + remaining - 1 <= index:
        i += k
        remaining -= 1
        s += arr[i]
    if remaining > 0 and index - (remaining - 1) > 1 + i:
        i = index - (remaining - 1)
        s += arr[i]
        remaining -= 1
    while remaining > 0:
        i += -1
        s += arr[i]
        remaining -= 1
    print(s)
```

### 197

```python
3

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

### 198

```python
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
    line, index = input().split()
    index = int(index)
    if line == 'V':
        r[index] = w
        V[i] = index
    else:
        t[index] = h
        H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1):
    if r[i] != -1:
        l[i] = left
        r[left] = i
        mxw = max(mxw, i - left)
        left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
    if t[i] != -1:
        b[i] = bottom
        t[bottom] = i
        mxh = max(mxh, i - bottom)
        bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
    if V[i] != 0:
        mxw = max(mxw, r[V[i]] - l[V[i]])
        r[l[V[i]]] = r[V[i]]
        l[r[V[i]]] = l[V[i]]
    else:
        mxh = max(mxh, t[H[i]] - b[H[i]])
        b[t[H[i]]] = b[H[i]]
        t[b[H[i]]] = t[H[i]]
    ans[i - 1] = mxh * mxw
for i in range(n):
    print(ans[i])
```

### 199

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

### 200

```python
import sys
input = sys.stdin.readline
n, h, l, r = map(int, input().split())
a = [int(item) for item in input().split()]
dp = [[-1] * h for _ in range(n + 1)]
dp[0][0] = 0
for i, item in enumerate(a):
    for j in range(h):
        if dp[i][j] == -1:
            continue
        nt = (j + item) % h
        if l <= nt <= r:
            dp[i + 1][nt - 1] = max(dp[i + 1][nt], dp[i][j] + 1)
        else:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
        nt = (j + item - 1 + h) % h
        if l <= nt <= r:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j] + 1)
        else:
            dp[i + 1][nt] = max(dp[i + 1][nt], dp[i][j])
print(max(dp[-1]))
```

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