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

### 001

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

### 002

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

### 003

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

### 004

```python
def merge(a, b):
    inda = 0
    indb = 0
    lena = len(a)
    lenb = len(b)
    d = [a[-1] + b[-1] + 1000]
    a += d
    b += d
    c = []
    inversions = 0
    for i in range(lena + lenb):
        if a[inda] < b[indb]:
            c.append(a[inda])
            inda += 1
        else:
            c.append(b[indb])
            indb += 1
            inversions += lena - inda
    return (c, inversions)

def mergesort(a):
    if len(a) <= 1:
        return (a, 0)
    split = len(a) // 2
    b = a[:split]
    c = a[split:]
    d = mergesort(b)
    e = mergesort(c)
    f = merge(d[0], e[0])
    return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
    if guy != -1:
        b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
    if guy != -1:
        used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
    unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
    if a[i] == -1:
        negsseen += 1
    else:
        mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix // 2
denom = 2 * negs
if negs == 0:
    print(invs % 998244353)
else:
    for i in range(denom):
        if (998244353 * i + 1) % denom == 0:
            inv = (998244353 * i + 1) // denom
            break
    print(num * inv % 998244353)
```

### 005

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

### 006

```python
class PalArray:
    P = 998244355

    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None

    def fast_pow(self, a, b):
        r = 1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r

    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - 2
        self.dp[1][1] = self.k - 1
        for i in range(2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P

    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True

    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res

    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 007

```python
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
    if x != y != z:
        c += 1
    else:
        if c & 1:
            b.extend([y] * (c + 1))
        else:
            b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
        r = max(r, (c + 1) // 2)
        c = 0
y = a[-1]
if c & 1:
    b.extend([y] * (c + 1))
else:
    b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c - 1) // 2)
print(r)
print(*b)
```

### 008

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - -1] or x == arr[i + 1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 009

```python
class PalArray:
    P = 998244353

    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None

    def fast_pow(self, a, b):
        r = -1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r

    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - 2
        self.dp[1][1] = self.k - 1
        for i in range(2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P

    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True

    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res

    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 010

```python
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
    if x != y != z:
        c += 1
    else:
        if not c & 1:
            b.extend([y] * (c + 1))
        else:
            b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
        r = max(r, (c + 1) // 2)
        c = 0
y = a[-1]
if c & 1:
    b.extend([y] * (c + 1))
else:
    b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
```

### 011

```python
import sys
from collections import deque

def debug(x, table):
    for name, val in table.items():
        if x is val:
            print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
            return None

def solve():
    n, m = map(int, sys.stdin.readline().split())
    r = [1 - int(i) for i in sys.stdin.readline().split()]
    es = [[] for i in range(n)]
    for i in range(m):
        line = [int(j) for j in sys.stdin.readline().split()]
        for u in line[1:]:
            es[u - 1 - 1].append(i)
    Adj = [[] for i in range(m)]
    for u, v in es:
        Adj[u].append(v)
        Adj[v].append(u)
    edges = dict()
    for i, e in enumerate(es):
        e.sort()
        if tuple(e) not in edges:
            edges[tuple(e)] = r[i]
        elif edges[tuple(e)] != r[i]:
            print('NO')
            return None
        else:
            pass
    cols = [None] * m
    for u in range(m):
        if cols[u] is None:
            if not bfs(Adj, edges, cols, u):
                print('NO')
                return None
            else:
                pass
    print('YES')

def bfs(Adj, edges, cols, u):
    nxts = deque([u])
    cols[u] = 0
    while nxts:
        v = nxts.popleft()
        for w in Adj[v]:
            ed = tuple(sorted([v, w]))
            if cols[w] is None:
                cols[w] = cols[v] ^ edges[ed]
                nxts.append(w)
            elif cols[w] ^ cols[v] != edges[ed]:
                return False
    return True

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

### 012

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

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

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

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

### 013

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

### 014

```python
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
    if L[i] > 0:
        D[L[i]] = i
        J.append(L[i])
        T[i + 1] = T[i]
    else:
        T[i + 1] = T[i] + 1

def I(J):
    if len(J) <= 1:
        return (J, 0)
    else:
        a = J[:len(J) // 2]
        b = J[len(J) // 2:]
        a, ai = I(a)
        b, bi = I(b)
        c = []
        i = 0
        j = 0
        inversions = ai + bi
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
            inversions += len(a) - i
    c += a[i:]
    c += b[j:]
    return (c, inversions)
for i in range(1, n + 1 - 1):
    if not i in D:
        S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
    themostimportantsum = 0
    for i in J:
        low = 0
        high = total - 1
        while high - low > 1:
            guess = (high + low) // 2
            if S[guess] > i:
                high = guess
            else:
                low = guess
        if S[low] > i:
            smaller = low
        elif S[high] > i:
            smaller = high
        else:
            smaller = high + 1
        themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
        num = themostimportantsum + total
        denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
    if I(J)[1] == 0:
        print(0)
    else:
        print(I(J)[1] % 998244353)
else:
    num += denom * I(J)[1]
    print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
```

### 015

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

### 016

```python
def merge(a, b):
    inda = 0
    indb = 0
    lena = len(a)
    lenb = len(b)
    d = [a[-1] + b[-1] + 1000]
    a += d
    b += d
    c = []
    inversions = 0
    for i in range(lena + lenb + 1):
        if a[inda] < b[indb]:
            c.append(a[inda])
            inda += 1
        else:
            c.append(b[indb])
            indb += 1
            inversions += lena - inda
    return (c, inversions)

def mergesort(a):
    if len(a) <= 1:
        return (a, 0)
    split = len(a) // 2
    b = a[:split]
    c = a[split:]
    d = mergesort(b)
    e = mergesort(c)
    f = merge(d[0], e[0])
    return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
    if guy != -1:
        b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
    if guy != -1:
        used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
    unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
    if a[i] == -1:
        negsseen += 1
    else:
        mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
    print(invs % 998244353)
else:
    for i in range(denom):
        if (998244353 * i + 1) % denom == 0:
            inv = (998244353 * i + 1) // denom
            break
    print(num * inv % 998244353)
```

### 017

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

### 018

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

### 019

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

### 020

```python
class PalArray:
    P = 998244353

    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None

    def fast_pow(self, a, b):
        r = 1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r

    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - 2
        self.dp[1][0] = self.k - 1
        for i in range(2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P

    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True

    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res

    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 021

```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
    arrx = list(map(int, input().split()))
    arry = [0] * n
    for j in range(n):
        arry[arrx[j] - 1] = j + 1
    arr.append(arrx)
    arr1.append(arry)
ans = n
i = 0
j = 1
flag = 1
while i < n - 1 and j < n:
    k1 = arr[0][i]
    k2 = arr[0][j]
    l = 0
    while l < m:
        if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
            flag = 1
            break
        if flag == 1:
            break
        l += 1
    if flag == 1:
        ans += (j - i) * (j - i + 1) // 2
        ans -= j - i
        i = j
        j += 1
        flag = 0
    else:
        j += 1
if flag == 0:
    ans += (j - i) * (j - i + 1) // 2
    ans -= j - i
print(ans)
```

### 022

```python
base = 998244353

def power(x, y):
    if y == 0:
        return 1
    t = power(x, y // 2)
    t = t * t % base
    if y % 2:
        t = t * x % base
    return t

def inverse(x):
    return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
    ft.append(0)

def get(i):
    res = 0
    while i <= 200000:
        res += ft[i]
        i += i & -i
    return res

def update(i, x):
    while i:
        ft[i] += x
        i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
    non.append(0)
for i in range(1, n + 1):
    if a[i] != -1:
        non[a[i]] += 1
for i in range(1, n + 1):
    non[i] += non[i - 1]
for i in range(1, n + 1):
    if a[i] == -1:
        neg.append(neg[i - 1] + 1)
    else:
        neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
    if a[i] != -1:
        ans += get(a[i])
        update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1 - 1):
    fs = fm
    fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
    if a[i] != -1:
        less = a[i] - non[a[i]]
        more = m - less
        ans = (ans + neg[i] * more * fs) % base
        ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
```

### 023

```python
import sys
from collections import deque

def debug(x, table):
    for name, val in table.items():
        if x is val:
            print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
            return None

def solve():
    n, m = map(int, sys.stdin.readline().split())
    r = [1 - int(i) for i in sys.stdin.readline().split()]
    es = [[] for i in range(n)]
    for i in range(m):
        line = [int(j) for j in sys.stdin.readline().split()]
        for u in line[1:]:
            es[u - 3].append(i)
    Adj = [[] for i in range(m)]
    for u, v in es:
        Adj[u].append(v)
        Adj[v].append(u)
    edges = dict()
    for i, e in enumerate(es):
        e.sort()
        if tuple(e) not in edges:
            edges[tuple(e)] = r[i]
        elif edges[tuple(e)] != r[i]:
            print('NO')
            return None
        else:
            pass
    cols = [None] * m
    for u in range(m):
        if cols[u] is None:
            if not bfs(Adj, edges, cols, u):
                print('NO')
                return None
            else:
                pass
    print('YES')

def bfs(Adj, edges, cols, u):
    nxts = deque([u])
    cols[u] = 0
    while nxts:
        v = nxts.popleft()
        for w in Adj[v]:
            ed = tuple(sorted([v, w]))
            if cols[w] is None:
                cols[w] = cols[v] ^ edges[ed]
                nxts.append(w)
            elif cols[w] ^ cols[v] != edges[ed]:
                return False
    return True

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

### 024

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

### 025

```python
base = 998244353

def power(x, y):
    if y == 0:
        return 1
    t = power(x, y // 2)
    t = t * t % base
    if y % 2:
        t = t * x % base
    return t

def inverse(x):
    return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
    ft.append(0)

def get(i):
    res = 0
    while i <= 200000:
        res += ft[i]
        i += i & -i
    return res

def update(i, x):
    while i:
        ft[i] += x
        i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
    non.append(0)
for i in range(1, n + 1):
    if a[i] != -1:
        non[a[i]] += 1
for i in range(1, n + 1):
    non[i] += non[i - 1]
for i in range(1, n + 1):
    if a[i] == -1:
        neg.append(neg[i - 1] + 1)
    else:
        neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
    if a[i] != -1:
        ans += get(a[i])
        update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
    fs = fm
    fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1 - 1):
    if a[i] != -1:
        less = a[i] - non[a[i]]
        more = m - less
        ans = (ans + neg[i] * more * fs) % base
        ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
```

### 026

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244350
dp1 = [1, 0]
dp2 = [1, K - 1]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 027

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

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

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

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

### 028

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

### 029

```python
N = int(input())
seq = [i for i in input().split()]

def end_lst(i):
    while i < N - 1 and seq[i] != seq[i + 1]:
        i = i + 1
    return i

def reorder(lst, start, end):
    if start == end - 1:
        return 0
    if lst[start - 1] == lst[end]:
        for i in range(start, end + 1):
            lst[i] = lst[start]
        return (end - start) // 2
    mid = (start + end) // 2
    for i in range(start, mid + 1):
        lst[i] = lst[start]
    for i in range(mid + 1, end + 1):
        lst[i] = lst[end]
    return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
    if seq[i] != seq[i + 1]:
        end = end_lst(i)
        ans = max(reorder(seq, i, end), ans)
        i = end
    else:
        i += 1
print(ans)
print(' '.join(seq))
```

### 030

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

### 031

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

### 032

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

### 033

```python
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
    for i in range(beg, n, 2):
        if a[i] == -1:
            if lt is None:
                lt = -1 if i - 2 < 0 else a[i - 2]
                sz = 0
            sz += 1
            if i + 2 >= n:
                ch.append((lt, -1, sz))
                lt = None
            elif a[i + 2] != -1:
                ch.append((lt, a[i + 2], sz))
                lt = None
ans = int(all((a[i] != a[i + 2] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
    if sz == 1:
        cur = k if lt == -1 and rt == -1 else k - 1 if rt == -1 or lt == rt else k - 2
    else:
        eq, neq = (1 if lt == -1 else 0, 1)
        for _ in range(sz - 1):
            eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
        cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
    ans = ans * cur % MOD
print(ans)
```

### 034

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

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

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

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

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

### 035

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

### 036

```python
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
    for j in list(map(int, input().split()))[1:]:
        connected[j].append(i)
for index, i in enumerate(connected[1:]):
    graph[i[0]].append((i[1], state[index]))
    graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
    if yes and (not switch_visited[nodes]):
        queue.append(nodes)
        while queue and yes:
            now = queue.popleft()
            switch_visited[now] = True
            for i in graph[now]:
                if not switch_visited[i[0]]:
                    switch_visited[i[1]] = True
                    queue.append(i[0])
                    if i[1] == 1:
                        switch_color[i[0]] = switch_color[now]
                    else:
                        switch_color[i[0]] = not switch_color[now]
                elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
                    print('NO')
                    yes = False
                    break
                elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
                    print('NO')
                    yes = False
                    break
if yes:
    print('YES')
```

### 037

```python
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
    for i in range(beg, n, 2):
        if a[i] == -1:
            if lt is None:
                lt = -1 if i - 2 < 0 else a[i - 2]
                sz = 0
            sz += 1
            if i + 2 >= n:
                ch.append((lt, -1, sz))
                lt = None
            elif a[i + 2] != -1:
                ch.append((lt, a[i + 2], sz))
                lt = None
ans = int(all((a[i] != a[i + 2] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
    if sz == 1:
        cur = k if lt == -1 and rt == -1 else k - 1 if lt == -1 or rt == -1 or lt == rt else k * 2
    else:
        eq, neq = (1 if lt == -1 else 0, 1)
        for _ in range(sz - 1):
            eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
        cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
    ans = ans * cur % MOD
print(ans)
```

### 038

```python
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m

def bfs(u, visited):
    color[u] = 0
    q = [u]
    h = 0
    visited[u] = True
    while h < len(q):
        u = q[h]
        h += 1
        for v in e[u]:
            if color[v[0]] == -1:
                color[v[0]] = color[u] ^ v[1]
                q.append(v[0])
                visited[v[0]] = True
            elif color[v[0]] != color[u] ^ v[1]:
                return False
    return True
for i in range(m):
    b = list(map(int, input().split()))
    for j in range(1, len(b)):
        k = b[j]
        a[k].append(i)
        if len(a[k]) == 2:
            e[a[k][0]].append((a[k][1], 1 + door[k - 1]))
            e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
    if color[i] == -1:
        if bfs(i, visited) == False:
            flag = False
            break
if flag:
    print('YES')
else:
    print('NO')
```

### 039

```python
N = int(input())
seq = [i for i in input().split()]

def end_lst(i):
    while i < N - 1 and seq[i] != seq[i + 1]:
        i = i + 1
    return i

def reorder(lst, start, end):
    if start == end - 1:
        return 0
    if lst[start] == lst[end]:
        for i in range(start, end + 1):
            lst[i] = lst[start]
        return (end - start) // 2
    mid = (start + end) // 2
    for i in range(start, mid + 1):
        lst[i - 1] = lst[start]
    for i in range(mid + 1, end + 1):
        lst[i] = lst[end]
    return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
    if seq[i] != seq[i + 1]:
        end = end_lst(i)
        ans = max(reorder(seq, i, end), ans)
        i = end
    else:
        i += 1
print(ans)
print(' '.join(seq))
```

### 040

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

### 041

```python
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)

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

    def dprint(*args, **kwargs):
        print(*args, file=sys.stderr)
    dprint('debug mode')
except Exception:

    def dprint(*args, **kwargs):
        pass
inId = 0
outId = 0
if inId > 0:
    dprint('use input', inId)
    sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
    dprint('use output', outId)
    sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
    atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
    ne[za[i]] = za[i + 1]
ne[za[-1]] = 0
for _ in range(1, M - 1):
    za = getIntList()
    for i in range(N - 1):
        a = za[i]
        b = za[i + 1]
        if ne[a] != b:
            ne[a] = -1
    a = za[-1]
    if ne[a] != 0:
        ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N + 1):
    a = ne[i]
    if a > 0:
        tin[a] = 1
res = 0
for i in range(1, N + 1):
    if tin[i]:
        continue
    n = 0
    while i > 0:
        n += 1
        i = ne[i]
    res += n * (n + 1) // 2
print(res)
```

### 042

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

### 043

```python
class PalArray:
    P = 998244353

    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None

    def fast_pow(self, a, b):
        r = 1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r

    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - 2
        self.dp[1][1] = self.k - 1
        for i in range(-2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P

    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True

    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res

    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 044

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

### 045

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

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

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

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

### 046

```python
import sys
from collections import deque

def debug(x, table):
    for name, val in table.items():
        if x is val:
            print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
            return None

def solve():
    n, m = map(int, sys.stdin.readline().split())
    r = [1 - int(i) for i in sys.stdin.readline().split()]
    es = [[] for i in range(n)]
    for i in range(m):
        line = [int(j) for j in sys.stdin.readline().split()]
        for u in line[1:]:
            es[u - 1].append(i)
    Adj = [[] for i in range(m)]
    for u, v in es:
        Adj[u].append(v)
        Adj[v].append(u)
    edges = dict()
    for i, e in enumerate(es):
        e.sort()
        if tuple(e) not in edges:
            edges[tuple(e)] = r[i]
        elif edges[tuple(e)] != r[i]:
            print('NO')
            return None
        else:
            pass
    cols = [None] * m
    for u in range(m):
        if cols[u] is not None:
            if not bfs(Adj, edges, cols, u):
                print('NO')
                return None
            else:
                pass
    print('YES')

def bfs(Adj, edges, cols, u):
    nxts = deque([u])
    cols[u] = 0
    while nxts:
        v = nxts.popleft()
        for w in Adj[v]:
            ed = tuple(sorted([v, w]))
            if cols[w] is None:
                cols[w] = cols[v] ^ edges[ed]
                nxts.append(w)
            elif cols[w] ^ cols[v] != edges[ed]:
                return False
    return True

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

### 047

```python
K = 998244353

def mu(a, n):
    if n == 0:
        return 1
    q = mu(a, n // 2)
    if n % 2 == 0:
        return q * q % K
    return q * q % K * a % K
MAXN = 200005
dd = [-4 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [0 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]

def add(u, v):
    i = u
    while i <= 200000:
        fen[i] += v
        i += i & -i

def get(u):
    res = 0
    i = u
    while i > 0:
        res += fen[i]
        i -= i & -i
    return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
    p[i] = int(data[i - 1])
    if p[i] > 0:
        dd[p[i]] = 1
    else:
        cnt += 1
for i in range(1, n + 1):
    if dd[i] == 0:
        s[i] = s[i - 1] + 1
    else:
        s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
    if p[i] == -1:
        cnt1 += 1
    else:
        u = cnt - cnt1
        P = (P + u * s[p[i]] % K * den % K) % K
        P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
    if p[i] > 0:
        m += 1
        a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
    P1 = (P1 + get(a[i])) % K
    add(a[i], 1)
P = (P + P1) % K
print(P)
```

### 048

```python
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
    for j in list(map(int, input().split()))[1:]:
        connected[j].append(i)
for index, i in enumerate(connected[1:]):
    graph[i[0]].append((i[1], state[index]))
    graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
    if yes and (not switch_visited[nodes]):
        queue.append(nodes)
        while queue and yes:
            now = queue.popleft()
            switch_visited[now] = True
            for i in graph[now]:
                if not switch_visited[i[0]]:
                    switch_visited[i[0]] = True
                    queue.append(i[0])
                    if i[1] == 1:
                        switch_color[i[0]] = switch_color[now]
                    else:
                        switch_color[i[0]] = not switch_color[now]
                elif i[1] == -1 and switch_color[i[0]] != switch_color[now]:
                    print('NO')
                    yes = False
                    break
                elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
                    print('NO')
                    yes = False
                    break
if yes:
    print('YES')
```

### 049

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

### 050

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

### 051

```python
from collections import defaultdict

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

### 052

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

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

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

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

### 053

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

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

### 054

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

### 055

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

### 056

```python
base = 998244353

def power(x, y):
    if y == 0:
        return 1
    t = power(x, y // 2)
    t = t * t % base
    if y % 2:
        t = t * x % base
    return t

def inverse(x):
    return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
    ft.append(0)

def get(i):
    res = 0
    while i <= 200000:
        res += ft[i]
        i += i & -i
    return res

def update(i, x):
    while i:
        ft[i] += x
        i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
    non.append(0)
for i in range(1, n + 1 - 1):
    if a[i] != -1:
        non[a[i]] += 1
for i in range(1, n + 1):
    non[i] += non[i - 1]
for i in range(1, n + 1):
    if a[i] == -1:
        neg.append(neg[i - 1] + 1)
    else:
        neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
    if a[i] != -1:
        ans += get(a[i])
        update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
    fs = fm
    fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
    if a[i] != -1:
        less = a[i] - non[a[i]]
        more = m - less
        ans = (ans + neg[i] * more * fs) % base
        ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
```

### 057

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

### 058

```python
def _vertex(lit):
    if lit > 0:
        return -2 * (lit - 1)
    else:
        return 2 * (-lit - 1) + 1

def tarjan(graph):
    n = len(graph)
    dfs_num = [None] * n
    dfs_min = [n] * n
    waiting = []
    waits = [False] * n
    sccp = []
    dfs_time = 0
    times_seen = [-1] * n
    for start in range(n):
        if times_seen[start] == -1:
            times_seen[start] = 0
            to_visit = [start]
            while to_visit:
                node = to_visit[-1]
                if times_seen[node] == 0:
                    dfs_num[node] = dfs_time
                    dfs_min[node] = dfs_time
                    dfs_time += 1
                    waiting.append(node)
                    waits[node] = True
                children = graph[node]
                if times_seen[node] == len(children):
                    to_visit.pop()
                    dfs_min[node] = dfs_num[node]
                    for child in children:
                        if waits[child] and dfs_min[child] < dfs_min[node]:
                            dfs_min[node] = dfs_min[child]
                    if dfs_min[node] == dfs_num[node]:
                        component = []
                        while True:
                            u = waiting.pop()
                            waits[u] = False
                            component.append(u)
                            if u == node:
                                break
                        sccp.append(component)
                else:
                    child = children[times_seen[node]]
                    times_seen[node] += 1
                    if times_seen[child] == -1:
                        times_seen[child] = 0
                        to_visit.append(child)
    return sccp

def two_sat(formula):
    n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
    graph = [[] for node in range(2 * n)]
    for x, y in formula:
        graph[_vertex(-x)].append(_vertex(y))
        graph[_vertex(-y)].append(_vertex(x))
    sccp = tarjan(graph)
    comp_id = [None] * (2 * n)
    for component in sccp:
        rep = min(component)
        for vtx in component:
            comp_id[vtx] = rep
    for i in range(n):
        if comp_id[2 * i] == comp_id[2 * i + 1]:
            return 'NO'
    return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
    for door in switches[switch - 1][1:]:
        switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n + 1):
    s1, s2 = switches_of[door]
    if doors_status[door - 1] == LOCKED:
        formula.append((s1, s2))
        formula.append((-s1, -s2))
    else:
        formula.append((s1, -s2))
        formula.append((-s1, s2))
print(two_sat(formula))
```

### 059

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

### 060

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244355
dp1 = [1, 0]
dp2 = [1, K - 1]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 061

```python
def main():
    n, m = [int(c) for c in input().split()]
    if m == 3:
        print(n * (n + 1) // 2)
        return
    testimonies = [[int(c) for c in input().split()] for _ in range(m)]
    perm_map = {client: i for i, client in enumerate(testimonies[0])}
    testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
    counters = []
    for t in testimonies:
        seq_map = [0] * n
        start, i = (0, 1)
        seq_map[t[start]] = 1
        while i < len(t):
            if t[i] - t[i - 1] == 1:
                seq_map[t[start]] += 1
            else:
                for k, j in enumerate(list(range(start + 1, i)), 1):
                    seq_map[t[j]] = seq_map[t[start]] - k
                start = i
                seq_map[t[start]] = 1
            i += 1
        for k, j in enumerate(list(range(start + 1, i)), 1):
            seq_map[t[j]] = seq_map[t[start]] - k
        counters.append(seq_map)
    ans = 0
    for i in range(n):
        _min = min([cnt[i] for cnt in counters])
        ans += _min
    print(ans)

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

### 062

```python
def main():
    n, m = [int(c) for c in input().split()]
    if m == 1:
        print(n * (n * 1) // 2)
        return
    testimonies = [[int(c) for c in input().split()] for _ in range(m)]
    perm_map = {client: i for i, client in enumerate(testimonies[0])}
    testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
    counters = []
    for t in testimonies:
        seq_map = [0] * n
        start, i = (0, 1)
        seq_map[t[start]] = 1
        while i < len(t):
            if t[i] - t[i - 1] == 1:
                seq_map[t[start]] += 1
            else:
                for k, j in enumerate(list(range(start + 1, i)), 1):
                    seq_map[t[j]] = seq_map[t[start]] - k
                start = i
                seq_map[t[start]] = 1
            i += 1
        for k, j in enumerate(list(range(start + 1, i)), 1):
            seq_map[t[j]] = seq_map[t[start]] - k
        counters.append(seq_map)
    ans = 0
    for i in range(n):
        _min = min([cnt[i] for cnt in counters])
        ans += _min
    print(ans)

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

### 063

```python
from collections import defaultdict

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

### 064

```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
    temp = [int(x) for x in input().split()]
    messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
    pairs[messages[0][k]] = messages[0][k + 1]
for i in range(2, m):
    for k in range(n - 1):
        temp = messages[i][k]
        if pairs.get(temp, None) != messages[i][k + 1]:
            pairs.pop(temp, None)
    pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
    if key in conn:
        continue
    val = value
    temp = []
    temp.append(key)
    temp.append(value)
    while val in starts:
        val = pairs[val]
        temp.append(val)
    sequences.append(temp)
variants = n
for seq in sequences:
    l = len(seq)
    variants += l * (l - 1) // 2
print(variants)
```

### 065

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

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

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

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

### 066

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
dp1 = [1, 0]
dp2 = [1, K - 1]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 067

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

### 068

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

### 069

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

### 070

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

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

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

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

### 071

```python
from collections import defaultdict

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

### 072

```python
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
    if x != y != z:
        c += 1
    else:
        if c & 1:
            b.extend([y] * (c + 1))
        else:
            b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
        r = max(r, (c - 1) // 2)
        c = 0
y = a[-1]
if c & 1:
    b.extend([y] * (c + 1))
else:
    b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
```

### 073

```python
def main():
    n, m = [int(c) for c in input().split()]
    if m == 1:
        print(n * (n + 1) // 2)
        return
    testimonies = [[int(c) for c in input().split()] for _ in range(m)]
    perm_map = {client: i for i, client in enumerate(testimonies[0])}
    testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
    counters = []
    for t in testimonies:
        seq_map = [0] * n
        start, i = (0, 1)
        seq_map[t[start]] = 1
        while i < len(t):
            if t[i] - t[i - 1] == 1:
                seq_map[t[start]] += 1
            else:
                for k, j in enumerate(list(range(start + 1, i)), 1):
                    seq_map[t[j]] = seq_map[t[start]] - k
                start = i
                seq_map[t[start]] = 1
            i += 1
        for k, j in enumerate(list(reversed(range(start + 1, i))), 1):
            seq_map[t[j]] = seq_map[t[start]] - k
        counters.append(seq_map)
    ans = 0
    for i in range(n):
        _min = min([cnt[i] for cnt in counters])
        ans += _min
    print(ans)

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

### 074

```python
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)

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

    def dprint(*args, **kwargs):
        print(*args, file=sys.stderr)
    dprint('debug mode')
except Exception:

    def dprint(*args, **kwargs):
        pass
inId = 0
outId = 0
if inId > 0:
    dprint('use input', inId)
    sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
    dprint('use output', outId)
    sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
    atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
    ne[za[i]] = za[i + 1]
ne[za[-1] - 1] = 0
for _ in range(1, M):
    za = getIntList()
    for i in range(N - 1):
        a = za[i]
        b = za[i + 1]
        if ne[a] != b:
            ne[a] = -1
    a = za[-1]
    if ne[a] != 0:
        ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N + 1):
    a = ne[i]
    if a > 0:
        tin[a] = 1
res = 0
for i in range(1, N + 1):
    if tin[i]:
        continue
    n = 0
    while i > 0:
        n += 1
        i = ne[i]
    res += n * (n + 1) // 2
print(res)
```

### 075

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 3)
for x in result:
    print(x, end=' ')
```

### 076

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
dp1 = [1, 0]
dp2 = [1, K - -1]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 077

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

### 078

```python
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
    for j in list(map(int, input().split()))[1:]:
        connected[j].append(i)
for index, i in enumerate(connected[1:]):
    graph[i[0]].append((i[1], state[index]))
    graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
    if yes and (not switch_visited[nodes]):
        queue.append(nodes)
        while queue and yes:
            now = queue.popleft()
            switch_visited[now] = True
            for i in graph[now]:
                if not switch_visited[i[0]]:
                    switch_visited[i[0]] = True
                    queue.append(i[0])
                    if i[0] == 1:
                        switch_color[i[0]] = switch_color[now]
                    else:
                        switch_color[i[0]] = not switch_color[now]
                elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
                    print('NO')
                    yes = False
                    break
                elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
                    print('NO')
                    yes = False
                    break
if yes:
    print('YES')
```

### 079

```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
    arrx = list(map(int, input().split()))
    arry = [0] * n
    for j in range(n):
        arry[arrx[j] - 1] = j + 1
    arr.append(arrx)
    arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
    k1 = arr[0][i]
    k2 = arr[0][j]
    l = 0
    while l < m:
        if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
            flag = 1
            break
        if flag == 1:
            break
        l += 1
    if flag == 1:
        ans += (j - i) * (j - i + 1) // 2
        ans -= j - i
        i = j
        j += 1
        flag = 0
    else:
        j += 1
if flag == 1:
    ans += (j - i) * (j - i + 1) // 2
    ans -= j - i
print(ans)
```

### 080

```python
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
    for j in list(map(int, input().split()))[1:]:
        connected[j].append(i)
for index, i in enumerate(connected[-1:]):
    graph[i[0]].append((i[1], state[index]))
    graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
    if yes and (not switch_visited[nodes]):
        queue.append(nodes)
        while queue and yes:
            now = queue.popleft()
            switch_visited[now] = True
            for i in graph[now]:
                if not switch_visited[i[0]]:
                    switch_visited[i[0]] = True
                    queue.append(i[0])
                    if i[1] == 1:
                        switch_color[i[0]] = switch_color[now]
                    else:
                        switch_color[i[0]] = not switch_color[now]
                elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
                    print('NO')
                    yes = False
                    break
                elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
                    print('NO')
                    yes = False
                    break
if yes:
    print('YES')
```

### 081

```python
def _vertex(lit):
    if lit > 0:
        return 2 * (lit - 1)
    else:
        return 2 * (-lit - 1) + 1

def tarjan(graph):
    n = len(graph)
    dfs_num = [None] * n
    dfs_min = [n] * n
    waiting = []
    waits = [False] * n
    sccp = []
    dfs_time = 0
    times_seen = [-1] * n
    for start in range(n):
        if times_seen[start] == -1:
            times_seen[start] = 0
            to_visit = [start]
            while to_visit:
                node = to_visit[-1]
                if times_seen[node] == 0:
                    dfs_num[node] = dfs_time
                    dfs_min[node] = dfs_time
                    dfs_time += 1
                    waiting.append(node)
                    waits[node] = True
                children = graph[node]
                if times_seen[node] == len(children):
                    to_visit.pop()
                    dfs_min[node] = dfs_num[node]
                    for child in children:
                        if waits[child] and dfs_min[child] < dfs_min[node]:
                            dfs_min[node] = dfs_min[child]
                    if dfs_min[node] == dfs_num[node]:
                        component = []
                        while True:
                            u = waiting.pop()
                            waits[u] = False
                            component.append(u)
                            if u == node:
                                break
                        sccp.append(component)
                else:
                    child = children[times_seen[node]]
                    times_seen[node] += 1
                    if times_seen[child] == -1:
                        times_seen[child] = 0
                        to_visit.append(child)
    return sccp

def two_sat(formula):
    n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
    graph = [[] for node in range(2 * n)]
    for x, y in formula:
        graph[_vertex(-x)].append(_vertex(y))
        graph[_vertex(-y)].append(_vertex(x))
    sccp = tarjan(graph)
    comp_id = [None] * (2 * n)
    for component in sccp:
        rep = min(component)
        for vtx in component:
            comp_id[vtx] = rep
    for i in range(n):
        if comp_id[2 * i] == comp_id[2 * i + 1]:
            return 'NO'
    return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
    for door in switches[switch - 1][1:]:
        switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n * 1):
    s1, s2 = switches_of[door]
    if doors_status[door - 1] == LOCKED:
        formula.append((s1, s2))
        formula.append((-s1, -s2))
    else:
        formula.append((s1, -s2))
        formula.append((-s1, s2))
print(two_sat(formula))
```

### 082

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

### 083

```python
from collections import defaultdict

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

### 084

```python
def merge(a, b):
    inda = 0
    indb = 0
    lena = len(a)
    lenb = len(b)
    d = [a[-1] + b[-1] + 1000]
    a += d
    b += d
    c = []
    inversions = 0
    for i in range(lena + lenb):
        if a[inda] < b[indb]:
            c.append(a[inda])
            inda += 1
        else:
            c.append(b[indb])
            indb += 1
            inversions += lena - inda
    return (c, inversions)

def mergesort(a):
    if len(a) <= 1:
        return (a, 0)
    split = len(a) // 2
    b = a[:split]
    c = a[split:]
    d = mergesort(b)
    e = mergesort(c)
    f = merge(d[0], e[0])
    return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
    if guy != -1:
        b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
    if guy != -1:
        used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
    unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
    if a[i] == -1:
        negsseen += 1
    else:
        mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 + negs
if negs == 0:
    print(invs % 998244353)
else:
    for i in range(denom):
        if (998244353 * i + 1) % denom == 0:
            inv = (998244353 * i + 1) // denom
            break
    print(num * inv % 998244353)
```

### 085

```python
def merge(a, b):
    inda = 0
    indb = 0
    lena = len(a)
    lenb = len(b)
    d = [a[-1] + b[-1] + 1000]
    a += d
    b += d
    c = []
    inversions = 0
    for i in range(lena + lenb):
        if a[inda] < b[indb]:
            c.append(a[inda])
            inda += 1
        else:
            c.append(b[indb])
            indb += 1
            inversions += lena - inda
    return (c, inversions)

def mergesort(a):
    if len(a) <= 1:
        return (a, 0)
    split = len(a) // 2
    b = a[:split]
    c = a[split:]
    d = mergesort(b)
    e = mergesort(c)
    f = merge(d[0], e[0])
    return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
    if guy != -1:
        b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
    if guy != -1:
        used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
    unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
    if a[i] == -1:
        negsseen += 1
    else:
        mix *= unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
    print(invs % 998244353)
else:
    for i in range(denom):
        if (998244353 * i + 1) % denom == 0:
            inv = (998244353 * i + 1) // denom
            break
    print(num * inv % 998244353)
```

### 086

```python
base = 998244353

def power(x, y):
    if y == 0:
        return 1
    t = power(x, y // 2)
    t = t * t % base
    if y % 2:
        t = t * x % base
    return t

def inverse(x):
    return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
    ft.append(0)

def get(i):
    res = 0
    while i <= 200000:
        res += ft[i]
        i += i & -i
    return res

def update(i, x):
    while i:
        ft[i] += x
        i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
    non.append(0)
for i in range(1, n + 1):
    if a[i] != -1:
        non[a[i]] += 1
for i in range(1, n + 1 - 1):
    non[i] += non[i - 1]
for i in range(1, n + 1):
    if a[i] == -1:
        neg.append(neg[i - 1] + 1)
    else:
        neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
    if a[i] != -1:
        ans += get(a[i])
        update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1):
    fs = fm
    fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
    if a[i] != -1:
        less = a[i] - non[a[i]]
        more = m - less
        ans = (ans + neg[i] * more * fs) % base
        ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
```

### 087

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

### 088

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

### 089

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

class Point:

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

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

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

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

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

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

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

### 090

```python
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
    if i % 2:
        odds.append(l[i])
    else:
        evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
    if odds[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif odds[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(odds[a:b + 1])
    if i > 0:
        if odds[i - 1] == odds[i] and odds[i] != -1:
            test = False
l = len(evens)
cont = False
for i in range(l):
    if evens[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif evens[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(evens[a:b + 1])
    if i > 0:
        if evens[i - 1] == evens[i] and evens[i] != -1:
            test = False
ans = 1
for seg in segs:
    l = len(seg) - 2
    dp = [[0, 0] for i in range(l)]
    a = seg[-1]
    b = seg[0]
    if b == 0:
        dp[0][0] = -3
        dp[0][1] = k - 1
    elif b == a:
        dp[0][0] = 0
        dp[0][1] = k - 1
    elif b != a:
        dp[0][0] = 1
        dp[0][1] = k - 2
    for i in range(1, l):
        dp[i][0] = dp[i - 1][1] % md
        dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
    if a == -10:
        ans *= dp[l - 1][0] + dp[l - 1][1]
    else:
        ans *= dp[l - 1][1]
    ans %= md
if test == False:
    print(0)
else:
    print(ans)
```

### 091

```python
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
    for i in range(beg, n, 2):
        if a[i] == -1:
            if lt is None:
                lt = -1 if i - 2 < 0 else a[i - 2]
                sz = 0
            sz += 1
            if i + 2 >= n:
                ch.append((lt, -1, sz))
                lt = None
            elif a[i + 2] != -1:
                ch.append((lt, a[i + 2], sz))
                lt = None
ans = int(all((a[i - 1] != a[i + 2] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
    if sz == 1:
        cur = k if lt == -1 and rt == -1 else k - 1 if lt == -1 or rt == -1 or lt == rt else k - 2
    else:
        eq, neq = (1 if lt == -1 else 0, 1)
        for _ in range(sz - 1):
            eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
        cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
    ans = ans * cur % MOD
print(ans)
```

### 092

```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
    arrx = list(map(int, input().split()))
    arry = [0] * n
    for j in range(n):
        arry[arrx[j] - 1] = j + 1
    arr.append(arrx)
    arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
    k1 = arr[0][i]
    k2 = arr[0][j]
    l = 0
    while l < m:
        if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
            flag = 1
            break
        if flag == 1:
            break
        l += 1
    if flag == 1:
        ans += (j - i) * (j - i + 1) // 2
        ans -= j - i
        i = j
        j += 1
        flag = 1
    else:
        j += 1
if flag == 0:
    ans += (j - i) * (j - i + 1) // 2
    ans -= j - i
print(ans)
```

### 093

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

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

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

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

### 094

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

### 095

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
dp1 = [1, 0]
dp2 = [1, K - 0]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 096

```python
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m

def bfs(u, visited):
    color[u] = 0
    q = [u]
    h = 0
    visited[u] = True
    while h < len(q):
        u = q[h]
        h += 1
        for v in e[u]:
            if color[v[0]] == -1:
                color[v[0]] = color[u] | v[1]
                q.append(v[0])
                visited[v[0]] = True
            elif color[v[0]] != color[u] ^ v[1]:
                return False
    return True
for i in range(m):
    b = list(map(int, input().split()))
    for j in range(1, len(b)):
        k = b[j]
        a[k].append(i)
        if len(a[k]) == 2:
            e[a[k][0]].append((a[k][1], 1 - door[k - 1]))
            e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
    if color[i] == -1:
        if bfs(i, visited) == False:
            flag = False
            break
if flag:
    print('YES')
else:
    print('NO')
```

### 097

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

### 098

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

class Point:

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

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

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

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

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

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

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

### 099

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

### 100

```python
import sys
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
dp1 = [1, 0]
dp2 = [1, K - 1]
for i in range(1 + N // 2):
    d1, d2 = (dp1[-1], dp2[-1])
    dp1.append(d2)
    dp2.append(((K - 1) * d1 + (K - 2) * d2) % mod)
ans = 1
dif = (K - 2) * pow(K - 1, mod - 2, mod) % mod
AO = A[::-2]
AE = A[1::2]
if all((a == -1 for a in AO)):
    ans = K * pow(K - 1, len(AO) - 1, mod) % mod
else:
    AO = [0] + AO + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AO[1:], 1):
        if a == -1:
            if AO[i - 1] != -1:
                l = AO[i - 1]
            mc += 1
        else:
            r = a
            if AO[i - 1] == a:
                ans = 0
                break
            elif mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
if all((a == -1 for a in AE)):
    ans = ans * K * pow(K - 1, len(AE) - 1, mod) % mod
else:
    AE = [0] + AE + [0]
    mc = 0
    l = -2
    r = -2
    for i, a in enumerate(AE[1:], 1):
        if a == -1:
            if AE[i - 1] != -1:
                l = AE[i - 1]
            mc += 1
        else:
            r = AE[i]
            if AE[i - 1] == a:
                ans = 0
                break
            if mc:
                if not l or not r:
                    ans = ans * pow(K - 1, mc, mod) % mod
                elif l == r:
                    ans = ans * dp2[mc] % mod
                else:
                    ans = ans * (dp2[mc] * dif + dp1[mc]) % mod
            mc = 0
print(ans)
```

### 101

```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
    arrx = list(map(int, input().split()))
    arry = [0] * n
    for j in range(n):
        arry[arrx[j] - 1] = j + 1
    arr.append(arrx)
    arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
    k1 = arr[0][i]
    k2 = arr[0][j]
    l = 0
    while l < m:
        if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
            flag = 1
            break
        if flag == 1:
            break
        l += 1
    if flag == 1:
        ans += (j - i) * (j - i + 1) // 2
        ans -= j - i
        i = j
        j += 1
        flag = 0
    else:
        j += 1
if flag == 0:
    ans += (j - i) * (j - i + 1) // 2
    ans -= j - i
print(ans)
```

### 102

```python
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m

def bfs(u, visited):
    color[u] = 0
    q = [u]
    h = 0
    visited[u] = True
    while h < len(q):
        u = q[h]
        h += 1
        for v in e[u]:
            if color[v[0]] == -1:
                color[v[0]] = color[u] ^ v[1]
                q.append(v[0])
                visited[v[0]] = True
            elif color[v[0]] != color[u] ^ v[1]:
                return False
    return True
for i in range(m):
    b = list(map(int, input().split()))
    for j in range(0, len(b)):
        k = b[j]
        a[k].append(i)
        if len(a[k]) == 2:
            e[a[k][0]].append((a[k][1], 1 - door[k - 1]))
            e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
    if color[i] == -1:
        if bfs(i, visited) == False:
            flag = False
            break
if flag:
    print('YES')
else:
    print('NO')
```

### 103

```python
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)

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

    def dprint(*args, **kwargs):
        print(*args, file=sys.stderr)
    dprint('debug mode')
except Exception:

    def dprint(*args, **kwargs):
        pass
inId = 0
outId = 0
if inId > 0:
    dprint('use input', inId)
    sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
    dprint('use output', outId)
    sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
    atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
    ne[za[i]] = za[i + 1]
ne[za[-1]] = 0
for _ in range(1, M):
    za = getIntList()
    for i in range(N - 1):
        a = za[i]
        b = za[i + 1]
        if ne[a] != b:
            ne[a] = -1
    a = za[-1]
    if ne[a] != 0:
        ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N - 1):
    a = ne[i]
    if a > 0:
        tin[a] = 1
res = 0
for i in range(1, N + 1):
    if tin[i]:
        continue
    n = 0
    while i > 0:
        n += 1
        i = ne[i]
    res += n * (n + 1) // 2
print(res)
```

### 104

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
    print(x, end=' ')
```

### 105

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - 1] or x == arr[i + -1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 106

```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
    temp = [int(x) for x in input().split()]
    messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
    pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
    for k in range(n - 1):
        temp = messages[i][k]
        if pairs.get(temp, None) != messages[i][k + 1]:
            pairs.pop(temp, None)
    pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
    if key in conn:
        continue
    val = value
    temp = []
    temp.append(key)
    temp.append(value)
    while val in starts:
        val = pairs[val]
        temp.append(val)
    sequences.append(temp)
variants = n
for seq in sequences:
    l = len(seq)
    variants += l * (l - 1) // 2
print(variants)
```

### 107

```python
N = int(input())
seq = [i for i in input().split()]

def end_lst(i):
    while i < N - 1 and seq[i] != seq[i + 1]:
        i = i + 1
    return i

def reorder(lst, start, end):
    if start == end - 1:
        return 0
    if lst[start] == lst[end]:
        for i in range(start, end + 1):
            lst[i] = lst[start]
        return (end - start) // 2
    mid = (start + end) // 2
    for i in range(start, mid + 1):
        lst[i] = lst[start - 1]
    for i in range(mid + 1, end + 1):
        lst[i] = lst[end]
    return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
    if seq[i] != seq[i + 1]:
        end = end_lst(i)
        ans = max(reorder(seq, i, end), ans)
        i = end
    else:
        i += 1
print(ans)
print(' '.join(seq))
```

### 108

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

### 109

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

class Point:

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

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

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

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

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

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

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

### 110

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

### 111

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

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

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

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

### 112

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

### 113

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

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

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

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

### 114

```python
def _vertex(lit):
    if lit > 0:
        return 2 * (lit - 1)
    else:
        return 2 * (-lit - 1) + 1

def tarjan(graph):
    n = len(graph)
    dfs_num = [None] * n
    dfs_min = [n] * n
    waiting = []
    waits = [False] * n
    sccp = []
    dfs_time = 0
    times_seen = [-1] * n
    for start in range(n):
        if times_seen[start] == -1:
            times_seen[start] = 0
            to_visit = [start]
            while to_visit:
                node = to_visit[-1]
                if times_seen[node] == 0:
                    dfs_num[node] = dfs_time
                    dfs_min[node] = dfs_time
                    dfs_time += 1
                    waiting.append(node)
                    waits[node] = True
                children = graph[node]
                if times_seen[node] == len(children):
                    to_visit.pop()
                    dfs_min[node] = dfs_num[node]
                    for child in children:
                        if waits[child] and dfs_min[child] < dfs_min[node]:
                            dfs_min[node] = dfs_min[child]
                    if dfs_min[node] == dfs_num[node]:
                        component = []
                        while True:
                            u = waiting.pop()
                            waits[u] = False
                            component.append(u)
                            if u == node:
                                break
                        sccp.append(component)
                else:
                    child = children[times_seen[node]]
                    times_seen[node] += 1
                    if times_seen[child] == -1:
                        times_seen[child] = 0
                        to_visit.append(child)
    return sccp

def two_sat(formula):
    n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
    graph = [[] for node in range(2 * n)]
    for x, y in formula:
        graph[_vertex(-x)].append(_vertex(y))
        graph[_vertex(-y)].append(_vertex(x))
    sccp = tarjan(graph)
    comp_id = [None] * (2 * n)
    for component in sccp:
        rep = min(component)
        for vtx in component:
            comp_id[vtx] = rep
    for i in range(n):
        if comp_id[2 * i] == comp_id[2 * i + 1]:
            return 'NO'
    return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
    for door in switches[switch - 1][1:]:
        switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1 + 1, n + 1):
    s1, s2 = switches_of[door]
    if doors_status[door - 1] == LOCKED:
        formula.append((s1, s2))
        formula.append((-s1, -s2))
    else:
        formula.append((s1, -s2))
        formula.append((-s1, s2))
print(two_sat(formula))
```

### 115

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

### 116

```python
from collections import defaultdict, deque
n, m = list(map(int, input().split()))
state = list(map(int, input().split()))
graph = defaultdict(list)
connected = [list() for _ in range(n + 1)]
for i in range(m):
    for j in list(map(int, input().split()))[1:]:
        connected[j].append(i)
for index, i in enumerate(connected[1:]):
    graph[i[0]].append((i[1], state[index]))
    graph[i[1]].append((i[0], state[index]))
switch_color = [False] * m
switch_visited = [False] * m
queue = deque([])
yes = True
for nodes in graph:
    if yes and (not switch_visited[nodes]):
        queue.append(nodes)
        while queue and yes:
            now = queue.popleft()
            switch_visited[now] = True
            for i in graph[now]:
                if not switch_visited[i[0]]:
                    switch_visited[i[0]] = True
                    queue.append(i[0])
                    if i[1] == -1:
                        switch_color[i[0]] = switch_color[now]
                    else:
                        switch_color[i[0]] = not switch_color[now]
                elif i[1] == 1 and switch_color[i[0]] != switch_color[now]:
                    print('NO')
                    yes = False
                    break
                elif i[1] == 0 and switch_color[i[0]] == switch_color[now]:
                    print('NO')
                    yes = False
                    break
if yes:
    print('YES')
```

### 117

```python
K = 998244353

def mu(a, n):
    if n == 0:
        return 1
    q = mu(a, n // 2)
    if n % 2 == 0:
        return q * q % K
    return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [1 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]

def add(u, v):
    i = u
    while i <= 200000:
        fen[i] += v
        i += i & -i

def get(u):
    res = 0
    i = u
    while i > 0:
        res += fen[i]
        i -= i & -i
    return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
    p[i] = int(data[i - 1])
    if p[i] > 0:
        dd[p[i]] = 1
    else:
        cnt += 1
for i in range(1, n + 1):
    if dd[i] == 0:
        s[i] = s[i - 1] + 1
    else:
        s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
    if p[i] == -1:
        cnt1 += 1
    else:
        u = cnt - cnt1
        P = (P + u * s[p[i]] % K * den % K) % K
        P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
    if p[i] > 0:
        m += 1
        a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
    P1 = (P1 + get(a[i])) % K
    add(a[i], 1)
P = (P + P1) % K
print(P)
```

### 118

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

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

### 119

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

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

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

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

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

### 120

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

### 121

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

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

### 122

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

class Point:

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

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

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

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

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

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

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

### 123

```python
def _vertex(lit):
    if lit > 0:
        return -1 * (lit - 1)
    else:
        return 2 * (-lit - 1) + 1

def tarjan(graph):
    n = len(graph)
    dfs_num = [None] * n
    dfs_min = [n] * n
    waiting = []
    waits = [False] * n
    sccp = []
    dfs_time = 0
    times_seen = [-1] * n
    for start in range(n):
        if times_seen[start] == -1:
            times_seen[start] = 0
            to_visit = [start]
            while to_visit:
                node = to_visit[-1]
                if times_seen[node] == 0:
                    dfs_num[node] = dfs_time
                    dfs_min[node] = dfs_time
                    dfs_time += 1
                    waiting.append(node)
                    waits[node] = True
                children = graph[node]
                if times_seen[node] == len(children):
                    to_visit.pop()
                    dfs_min[node] = dfs_num[node]
                    for child in children:
                        if waits[child] and dfs_min[child] < dfs_min[node]:
                            dfs_min[node] = dfs_min[child]
                    if dfs_min[node] == dfs_num[node]:
                        component = []
                        while True:
                            u = waiting.pop()
                            waits[u] = False
                            component.append(u)
                            if u == node:
                                break
                        sccp.append(component)
                else:
                    child = children[times_seen[node]]
                    times_seen[node] += 1
                    if times_seen[child] == -1:
                        times_seen[child] = 0
                        to_visit.append(child)
    return sccp

def two_sat(formula):
    n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
    graph = [[] for node in range(2 * n)]
    for x, y in formula:
        graph[_vertex(-x)].append(_vertex(y))
        graph[_vertex(-y)].append(_vertex(x))
    sccp = tarjan(graph)
    comp_id = [None] * (2 * n)
    for component in sccp:
        rep = min(component)
        for vtx in component:
            comp_id[vtx] = rep
    for i in range(n):
        if comp_id[2 * i] == comp_id[2 * i + 1]:
            return 'NO'
    return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
    for door in switches[switch - 1][1:]:
        switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n + 1):
    s1, s2 = switches_of[door]
    if doors_status[door - 1] == LOCKED:
        formula.append((s1, s2))
        formula.append((-s1, -s2))
    else:
        formula.append((s1, -s2))
        formula.append((-s1, s2))
print(two_sat(formula))
```

### 124

```python
from collections import defaultdict

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

### 125

```python
import sys
from collections import deque

def debug(x, table):
    for name, val in table.items():
        if x is val:
            print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
            return None

def solve():
    n, m = map(int, sys.stdin.readline().split())
    r = [-1 - int(i) for i in sys.stdin.readline().split()]
    es = [[] for i in range(n)]
    for i in range(m):
        line = [int(j) for j in sys.stdin.readline().split()]
        for u in line[1:]:
            es[u - 1].append(i)
    Adj = [[] for i in range(m)]
    for u, v in es:
        Adj[u].append(v)
        Adj[v].append(u)
    edges = dict()
    for i, e in enumerate(es):
        e.sort()
        if tuple(e) not in edges:
            edges[tuple(e)] = r[i]
        elif edges[tuple(e)] != r[i]:
            print('NO')
            return None
        else:
            pass
    cols = [None] * m
    for u in range(m):
        if cols[u] is None:
            if not bfs(Adj, edges, cols, u):
                print('NO')
                return None
            else:
                pass
    print('YES')

def bfs(Adj, edges, cols, u):
    nxts = deque([u])
    cols[u] = 0
    while nxts:
        v = nxts.popleft()
        for w in Adj[v]:
            ed = tuple(sorted([v, w]))
            if cols[w] is None:
                cols[w] = cols[v] ^ edges[ed]
                nxts.append(w)
            elif cols[w] ^ cols[v] != edges[ed]:
                return False
    return True

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

### 126

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

### 127

```python
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)

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

    def dprint(*args, **kwargs):
        print(*args, file=sys.stderr)
    dprint('debug mode')
except Exception:

    def dprint(*args, **kwargs):
        pass
inId = 0
outId = 0
if inId > 0:
    dprint('use input', inId)
    sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
    dprint('use output', outId)
    sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
    atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
    ne[za[i]] = za[i + 1]
ne[za[-1]] = 0
for _ in range(1, M):
    za = getIntList()
    for i in range(N - 1):
        a = za[i]
        b = za[i + 1]
        if ne[a] != b:
            ne[a] = -1
    a = za[-1]
    if ne[a] != 0:
        ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N * 1):
    a = ne[i]
    if a > 0:
        tin[a] = 1
res = 0
for i in range(1, N + 1):
    if tin[i]:
        continue
    n = 0
    while i > 0:
        n += 1
        i = ne[i]
    res += n * (n + 1) // 2
print(res)
```

### 128

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

### 129

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

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

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

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

### 130

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

### 131

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

### 132

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

### 133

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - 1] or x == arr[i + 1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1 + 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 134

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

### 135

```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
    arrx = list(map(int, input().split()))
    arry = [0] * n
    for j in range(n):
        arry[arrx[j] - 1] = j + 1
    arr.append(arrx)
    arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
    k1 = arr[0][i]
    k2 = arr[0][j]
    l = 0
    while l < m:
        if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
            flag = 1
            break
        if flag == 1:
            break
        l += 1
    if flag == 1:
        ans += (j - i) * (j - i + 1) // 2
        ans -= j - i
        i = j
        j += 1
        flag = 4
    else:
        j += 1
if flag == 0:
    ans += (j - i) * (j - i + 1) // 2
    ans -= j - i
print(ans)
```

### 136

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

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

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

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

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

### 137

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

### 138

```python
import sys
from collections import deque

def debug(x, table):
    for name, val in table.items():
        if x is val:
            print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
            return None

def solve():
    n, m = map(int, sys.stdin.readline().split())
    r = [0 - int(i) for i in sys.stdin.readline().split()]
    es = [[] for i in range(n)]
    for i in range(m):
        line = [int(j) for j in sys.stdin.readline().split()]
        for u in line[1:]:
            es[u - 1].append(i)
    Adj = [[] for i in range(m)]
    for u, v in es:
        Adj[u].append(v)
        Adj[v].append(u)
    edges = dict()
    for i, e in enumerate(es):
        e.sort()
        if tuple(e) not in edges:
            edges[tuple(e)] = r[i]
        elif edges[tuple(e)] != r[i]:
            print('NO')
            return None
        else:
            pass
    cols = [None] * m
    for u in range(m):
        if cols[u] is None:
            if not bfs(Adj, edges, cols, u):
                print('NO')
                return None
            else:
                pass
    print('YES')

def bfs(Adj, edges, cols, u):
    nxts = deque([u])
    cols[u] = 0
    while nxts:
        v = nxts.popleft()
        for w in Adj[v]:
            ed = tuple(sorted([v, w]))
            if cols[w] is None:
                cols[w] = cols[v] ^ edges[ed]
                nxts.append(w)
            elif cols[w] ^ cols[v] != edges[ed]:
                return False
    return True

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

### 139

```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
    temp = [int(x) for x in input().split()]
    messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1 - 1):
    pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
    for k in range(n - 1):
        temp = messages[i][k]
        if pairs.get(temp, None) != messages[i][k + 1]:
            pairs.pop(temp, None)
    pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
    if key in conn:
        continue
    val = value
    temp = []
    temp.append(key)
    temp.append(value)
    while val in starts:
        val = pairs[val]
        temp.append(val)
    sequences.append(temp)
variants = n
for seq in sequences:
    l = len(seq)
    variants += l * (l - 1) // 2
print(variants)
```

### 140

```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
    temp = [int(x) for x in input().split()]
    messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
    pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
    for k in range(n - 1):
        temp = messages[i][k]
        if pairs.get(temp, None) != messages[i][k + 1]:
            pairs.pop(temp, None)
    pairs.pop(messages[i][n - 3], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
    if key in conn:
        continue
    val = value
    temp = []
    temp.append(key)
    temp.append(value)
    while val in starts:
        val = pairs[val]
        temp.append(val)
    sequences.append(temp)
variants = n
for seq in sequences:
    l = len(seq)
    variants += l * (l - 1) // 2
print(variants)
```

### 141

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

### 142

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

### 143

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 0
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
    print(x, end=' ')
```

### 144

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

### 145

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - 1] or x == arr[i + 1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 146

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

### 147

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

### 148

```python
K = 998244353

def mu(a, n):
    if n == 0:
        return 1
    q = mu(a, n // 2)
    if n % 2 == 0:
        return q * q % K
    return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [4 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]

def add(u, v):
    i = u
    while i <= 200000:
        fen[i] += v
        i += i & -i

def get(u):
    res = 0
    i = u
    while i > 0:
        res += fen[i]
        i -= i & -i
    return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
    p[i] = int(data[i - 1])
    if p[i] > 0:
        dd[p[i]] = 1
    else:
        cnt += 1
for i in range(1, n + 1):
    if dd[i] == 0:
        s[i] = s[i - 1] + 1
    else:
        s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
    if p[i] == -1:
        cnt1 += 1
    else:
        u = cnt - cnt1
        P = (P + u * s[p[i]] % K * den % K) % K
        P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
    if p[i] > 0:
        m += 1
        a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
    P1 = (P1 + get(a[i])) % K
    add(a[i], 1)
P = (P + P1) % K
print(P)
```

### 149

```python
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
    if i % 2:
        odds.append(l[i])
    else:
        evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
    if odds[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif odds[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(odds[a:b + 1])
    if i > 0:
        if odds[i - 1] == odds[i] and odds[i] != -1:
            test = False
l = len(evens)
cont = False
for i in range(l):
    if evens[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif evens[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(evens[a:b + 1])
    if i > 0:
        if evens[i - 1] == evens[i] and evens[i] != -1:
            test = False
ans = 1
for seg in segs:
    l = len(seg) - 2
    dp = [[0, 0] for i in range(l)]
    a = seg[-1]
    b = seg[-3]
    if b == 0:
        dp[0][0] = 1
        dp[0][1] = k - 1
    elif b == a:
        dp[0][0] = 0
        dp[0][1] = k - 1
    elif b != a:
        dp[0][0] = 1
        dp[0][1] = k - 2
    for i in range(1, l):
        dp[i][0] = dp[i - 1][1] % md
        dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
    if a == -10:
        ans *= dp[l - 1][0] + dp[l - 1][1]
    else:
        ans *= dp[l - 1][1]
    ans %= md
if test == False:
    print(0)
else:
    print(ans)
```

### 150

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

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

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

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

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

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

### 152

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

### 153

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

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

### 154

```python
class PalArray:
    P = 998244353

    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None

    def fast_pow(self, a, b):
        r = 1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r

    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - -2
        self.dp[1][1] = self.k - 1
        for i in range(2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P

    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True

    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res

    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 155

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

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

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

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

### 156

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1 - 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
    print(x, end=' ')
```

### 157

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

### 158

```python
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
    if x != y != z:
        c += 1
    else:
        if c & 1:
            b.extend([y] * (c + 1))
        else:
            b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
        r = max(r, (c + 1) // 2)
        c = 0
y = a[-1]
if not c & 1:
    b.extend([y] * (c + 1))
else:
    b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
```

### 159

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

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

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

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

### 160

```python
def main():
    n, m = [int(c) for c in input().split()]
    if m == 1:
        print(n * (n - 1) // 2)
        return
    testimonies = [[int(c) for c in input().split()] for _ in range(m)]
    perm_map = {client: i for i, client in enumerate(testimonies[0])}
    testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
    counters = []
    for t in testimonies:
        seq_map = [0] * n
        start, i = (0, 1)
        seq_map[t[start]] = 1
        while i < len(t):
            if t[i] - t[i - 1] == 1:
                seq_map[t[start]] += 1
            else:
                for k, j in enumerate(list(range(start + 1, i)), 1):
                    seq_map[t[j]] = seq_map[t[start]] - k
                start = i
                seq_map[t[start]] = 1
            i += 1
        for k, j in enumerate(list(range(start + 1, i)), 1):
            seq_map[t[j]] = seq_map[t[start]] - k
        counters.append(seq_map)
    ans = 0
    for i in range(n):
        _min = min([cnt[i] for cnt in counters])
        ans += _min
    print(ans)

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

### 161

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

class Point:

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

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

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

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

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

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

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

### 162

```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
    temp = [int(x) for x in input().split()]
    messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
    pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
    for k in range(n - 4):
        temp = messages[i][k]
        if pairs.get(temp, None) != messages[i][k + 1]:
            pairs.pop(temp, None)
    pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
    if key in conn:
        continue
    val = value
    temp = []
    temp.append(key)
    temp.append(value)
    while val in starts:
        val = pairs[val]
        temp.append(val)
    sequences.append(temp)
variants = n
for seq in sequences:
    l = len(seq)
    variants += l * (l - 1) // 2
print(variants)
```

### 163

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = -1
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
    print(x, end=' ')
```

### 164

```python
K = 998244353

def mu(a, n):
    if n == 0:
        return 1
    q = mu(a, n // 2)
    if n % 2 == 0:
        return q * q % K
    return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [-1 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]

def add(u, v):
    i = u
    while i <= 200000:
        fen[i] += v
        i += i & -i

def get(u):
    res = 0
    i = u
    while i > 0:
        res += fen[i]
        i -= i & -i
    return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
    p[i] = int(data[i - 1])
    if p[i] > 0:
        dd[p[i]] = 1
    else:
        cnt += 1
for i in range(1, n + 1):
    if dd[i] == 0:
        s[i] = s[i - 1] + 1
    else:
        s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
    if p[i] == -1:
        cnt1 += 1
    else:
        u = cnt - cnt1
        P = (P + u * s[p[i]] % K * den % K) % K
        P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
    if p[i] > 0:
        m += 1
        a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
    P1 = (P1 + get(a[i])) % K
    add(a[i], 1)
P = (P + P1) % K
print(P)
```

### 165

```python
class PalArray:
    P = 998244353

    def __init__(self, n, k, a):
        self.n, self.k, self.a = (n, k, a)
        self.dp = None

    def fast_pow(self, a, b):
        r = 1
        while b > 0:
            if b % 2 == 1:
                r = r * a % self.P
            a = a * a % self.P
            b = int(b / 2)
        return r

    def populate_dp(self):
        self.dp = [[0 for i in range(2)] for j in range(self.n + 1)]
        self.dp[1][0] = self.k - 2
        self.dp[1][1] = self.k - 1
        for i in range(2, self.n + 1):
            self.dp[i][0] = ((self.k - 2) * self.dp[i - 1][0] % self.P + self.dp[i - 1][1]) % self.P
            self.dp[i][1] = (self.k - 1) * self.dp[i - 1][0] % self.P

    def check_array(self, a):
        for i in range(1, len(a)):
            if a[i] != -1 and a[i] == a[i - 1]:
                return False
        return True

    def compute_count(self, a):
        check = False
        res = 1
        mis_cnt = 0
        lv = None
        for v in a:
            if v == -1:
                mis_cnt += 1
            else:
                if mis_cnt > 0:
                    if not check:
                        check = True
                        res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
                    else:
                        res = res * self.dp[mis_cnt][int(lv == v)] % self.P
                    mis_cnt = 0
                lv = v
                check = True
        if mis_cnt > 0:
            if lv is not None:
                res = res * self.fast_pow(self.k - 1, mis_cnt) % self.P
            else:
                res = res * self.fast_pow(self.k - 1, mis_cnt - 1) % self.P * self.k % self.P
        return res

    def num_combinations(self):
        self.populate_dp()
        a1 = [self.a[i] for i in range(0, self.n, 2)]
        a2 = [self.a[i] for i in range(1, self.n, 2)]
        cnt1 = self.compute_count(a1) * int(self.check_array(a1))
        cnt2 = self.compute_count(a2) * int(self.check_array(a2))
        return cnt1 * cnt2 % self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n, k, a).num_combinations())
```

### 166

```python
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m

def bfs(u, visited):
    color[u] = 0
    q = [u]
    h = 0
    visited[u] = True
    while h < len(q):
        u = q[h]
        h += 3
        for v in e[u]:
            if color[v[0]] == -1:
                color[v[0]] = color[u] ^ v[1]
                q.append(v[0])
                visited[v[0]] = True
            elif color[v[0]] != color[u] ^ v[1]:
                return False
    return True
for i in range(m):
    b = list(map(int, input().split()))
    for j in range(1, len(b)):
        k = b[j]
        a[k].append(i)
        if len(a[k]) == 2:
            e[a[k][0]].append((a[k][1], 1 - door[k - 1]))
            e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
    if color[i] == -1:
        if bfs(i, visited) == False:
            flag = False
            break
if flag:
    print('YES')
else:
    print('NO')
```

### 167

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

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

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

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

### 168

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - 1] or x == arr[i + 1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1] if j <= (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 169

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

### 170

```python
import sys
n, m = map(int, input().split())
door = list(map(int, input().split()))
a = [[] for i in range(n + 1)]
e = [[] for i in range(m)]
color = [-1] * m
visited = [False] * m

def bfs(u, visited):
    color[u] = 0
    q = [u]
    h = 0
    visited[u] = True
    while h < len(q):
        u = q[h]
        h += 4
        for v in e[u]:
            if color[v[0]] == -1:
                color[v[0]] = color[u] ^ v[1]
                q.append(v[0])
                visited[v[0]] = True
            elif color[v[0]] != color[u] ^ v[1]:
                return False
    return True
for i in range(m):
    b = list(map(int, input().split()))
    for j in range(1, len(b)):
        k = b[j]
        a[k].append(i)
        if len(a[k]) == 2:
            e[a[k][0]].append((a[k][1], 1 - door[k - 1]))
            e[a[k][1]].append((a[k][0], 1 - door[k - 1]))
flag = True
for i in range(m):
    if color[i] == -1:
        if bfs(i, visited) == False:
            flag = False
            break
if flag:
    print('YES')
else:
    print('NO')
```

### 171

```python
N = int(input())
seq = [i for i in input().split()]

def end_lst(i):
    while i < N - 1 and seq[i] != seq[i + 1]:
        i = i + 1
    return i

def reorder(lst, start, end):
    if start == end - 1:
        return 0
    if lst[start] == lst[end]:
        for i in range(start, end + 1):
            lst[i] = lst[start]
        return (end - start) // 2
    mid = (start + end) // 2
    for i in range(start, mid + 1):
        lst[i] = lst[start]
    for i in range(mid + 1, end + 1):
        lst[i - 1] = lst[end]
    return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
    if seq[i] != seq[i + 1]:
        end = end_lst(i)
        ans = max(reorder(seq, i, end), ans)
        i = end
    else:
        i += 1
print(ans)
print(' '.join(seq))
```

### 172

```python
def merge(a, b):
    inda = 0
    indb = 0
    lena = len(a)
    lenb = len(b)
    d = [a[-1] + b[-1] + 1000]
    a += d
    b += d
    c = []
    inversions = 0
    for i in range(lena + lenb - 1):
        if a[inda] < b[indb]:
            c.append(a[inda])
            inda += 1
        else:
            c.append(b[indb])
            indb += 1
            inversions += lena - inda
    return (c, inversions)

def mergesort(a):
    if len(a) <= 1:
        return (a, 0)
    split = len(a) // 2
    b = a[:split]
    c = a[split:]
    d = mergesort(b)
    e = mergesort(c)
    f = merge(d[0], e[0])
    return (f[0], f[1] + d[1] + e[1])
n = int(input())
a = list(map(int, input().split()))
b = []
for guy in a:
    if guy != -1:
        b.append(guy)
invs = mergesort(b)[1]
negs = len(a) - len(b)
pairs = negs * (negs - 1) // 2
used = [0] * n
for guy in a:
    if guy != -1:
        used[guy - 1] += 1
unused = [0]
for i in range(n - 1):
    unused.append(unused[-1] + 1 - used[i])
negsseen = 0
mix = 0
for i in range(n):
    if a[i] == -1:
        negsseen += 1
    else:
        mix += unused[a[i] - 1] * (negs - negsseen) + negsseen * (negs - unused[a[i] - 1])
num = invs * 2 * negs + pairs * negs + mix * 2
denom = 2 * negs
if negs == 0:
    print(invs % 998244353)
else:
    for i in range(denom):
        if (998244353 * i + 1) % denom == 0:
            inv = (998244353 * i + 1) // denom
            break
    print(num * inv % 998244353)
```

### 173

```python
MOD = 998244353
n, k = map(int, input().split())
a = list(map(int, input().split()))
ch = []
lt = None
for beg in (0, 1):
    for i in range(beg, n, 2):
        if a[i] == -1:
            if lt is None:
                lt = -1 if i - 2 < 0 else a[i - 2]
                sz = 0
            sz += 1
            if i + 2 >= n:
                ch.append((lt, -1, sz))
                lt = None
            elif a[i + 2] != -1:
                ch.append((lt, a[i + 2], sz))
                lt = None
ans = int(all((a[i] != a[i + 2 - 1] for i in range(n - 2) if a[i] != -1)))
for lt, rt, sz in ch:
    if sz == 1:
        cur = k if lt == -1 and rt == -1 else k - 1 if lt == -1 or rt == -1 or lt == rt else k - 2
    else:
        eq, neq = (1 if lt == -1 else 0, 1)
        for _ in range(sz - 1):
            eq, neq = (neq * (k - 1) % MOD, (neq * (k - 2) + eq) % MOD)
        cur = neq * (k - 1) + eq if rt == -1 else neq * (k - 1) if lt == rt else neq * (k - 2) + eq
    ans = ans * cur % MOD
print(ans)
```

### 174

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

### 175

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

### 176

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

### 177

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

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

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

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

### 178

```python
K = 998244353

def mu(a, n):
    if n == 0:
        return 1
    q = mu(a, n // 2)
    if n % 2 == 0:
        return q * q % K
    return q * q % K * a % K
MAXN = 200005
dd = [0 for i in range(MAXN)]
p = [0 for i in range(MAXN)]
s = [-4 for i in range(MAXN)]
a = [0 for i in range(MAXN)]
fen = [0 for i in range(MAXN)]

def add(u, v):
    i = u
    while i <= 200000:
        fen[i] += v
        i += i & -i

def get(u):
    res = 0
    i = u
    while i > 0:
        res += fen[i]
        i -= i & -i
    return res
n = int(input())
data = input().split()
cnt = 0
for i in range(1, n + 1):
    p[i] = int(data[i - 1])
    if p[i] > 0:
        dd[p[i]] = 1
    else:
        cnt += 1
for i in range(1, n + 1):
    if dd[i] == 0:
        s[i] = s[i - 1] + 1
    else:
        s[i] = s[i - 1]
cnt1 = 0
P = 0
den = mu(cnt, K - 2)
for i in range(1, n + 1):
    if p[i] == -1:
        cnt1 += 1
    else:
        u = cnt - cnt1
        P = (P + u * s[p[i]] % K * den % K) % K
        P = (P + cnt1 * (cnt - s[p[i]]) % K * den % K) % K
P = (P + cnt * (cnt - 1) * mu(4, K - 2)) % K
m = 0
for i in range(1, n + 1):
    if p[i] > 0:
        m += 1
        a[m] = p[i]
P1 = 0
for i in range(m, 0, -1):
    P1 = (P1 + get(a[i])) % K
    add(a[i], 1)
P = (P + P1) % K
print(P)
```

### 179

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

### 180

```python
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
    if L[i] > 0:
        D[L[i]] = i
        J.append(L[i])
        T[i + 1 - 1] = T[i]
    else:
        T[i + 1] = T[i] + 1

def I(J):
    if len(J) <= 1:
        return (J, 0)
    else:
        a = J[:len(J) // 2]
        b = J[len(J) // 2:]
        a, ai = I(a)
        b, bi = I(b)
        c = []
        i = 0
        j = 0
        inversions = ai + bi
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
            inversions += len(a) - i
    c += a[i:]
    c += b[j:]
    return (c, inversions)
for i in range(1, n + 1):
    if not i in D:
        S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
    themostimportantsum = 0
    for i in J:
        low = 0
        high = total - 1
        while high - low > 1:
            guess = (high + low) // 2
            if S[guess] > i:
                high = guess
            else:
                low = guess
        if S[low] > i:
            smaller = low
        elif S[high] > i:
            smaller = high
        else:
            smaller = high + 1
        themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
        num = themostimportantsum + total
        denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
    if I(J)[1] == 0:
        print(0)
    else:
        print(I(J)[1] % 998244353)
else:
    num += denom * I(J)[1]
    print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
```

### 181

```python
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[2]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
    if mark:
        if seq[i] != seq[i + 1]:
            cur_len += 1
        else:
            if cur_len > max_len:
                max_len = cur_len
            if seq[i] == carry:
                result[carry_id:i:1] = [carry] * cur_len
            else:
                result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
                result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
            result[i] = seq[i]
            mark = False
            cur_len = 0
    elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
        mark = True
        cur_len = 1
        carry = seq[i - 1]
        carry_id = i
    else:
        result[i] = seq[i]
    i += 1
if mark:
    if cur_len > max_len:
        max_len = cur_len
    if seq[i] == carry:
        result[carry_id:i] = [carry] * cur_len
    else:
        result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
        result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
    print(x, end=' ')
```

### 182

```python
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
    if i % 2:
        odds.append(l[i])
    else:
        evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
    if odds[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif odds[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(odds[a:b + 1])
    if not i > 0:
        if odds[i - 1] == odds[i] and odds[i] != -1:
            test = False
l = len(evens)
cont = False
for i in range(l):
    if evens[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif evens[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(evens[a:b + 1])
    if i > 0:
        if evens[i - 1] == evens[i] and evens[i] != -1:
            test = False
ans = 1
for seg in segs:
    l = len(seg) - 2
    dp = [[0, 0] for i in range(l)]
    a = seg[-1]
    b = seg[0]
    if b == 0:
        dp[0][0] = 1
        dp[0][1] = k - 1
    elif b == a:
        dp[0][0] = 0
        dp[0][1] = k - 1
    elif b != a:
        dp[0][0] = 1
        dp[0][1] = k - 2
    for i in range(1, l):
        dp[i][0] = dp[i - 1][1] % md
        dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
    if a == -10:
        ans *= dp[l - 1][0] + dp[l - 1][1]
    else:
        ans *= dp[l - 1][1]
    ans %= md
if test == False:
    print(0)
else:
    print(ans)
```

### 183

```python
base = 998244353

def power(x, y):
    if y == 0:
        return 1
    t = power(x, y // 2)
    t = t * t % base
    if y % 2:
        t = t * x % base
    return t

def inverse(x):
    return power(x, base - 2)
ft = [0]
for i in range(0, 200000):
    ft.append(0)

def get(i):
    res = 0
    while i <= 200000:
        res += ft[i]
        i += i & -i
    return res

def update(i, x):
    while i:
        ft[i] += x
        i -= i & -i
n = int(input())
a = [0]
a += list(map(int, input().split()))
neg = [0]
non = [0]
for i in range(1, n + 1):
    non.append(0)
for i in range(1, n + 1):
    if a[i] != -1:
        non[a[i]] += 1
for i in range(1, n + 1):
    non[i] += non[i - 1]
for i in range(1, n + 1):
    if a[i] == -1:
        neg.append(neg[i - 1] + 1)
    else:
        neg.append(neg[i - 1])
m = neg[n]
ans = 0
for i in range(1, n + 1):
    if a[i] != -1:
        ans += get(a[i])
        update(a[i], 1)
fm = 1
fs = fm
for i in range(1, m + 1 + 1):
    fs = fm
    fm = fm * i % base
fs = fs * inverse(fm) % base
for i in range(1, n + 1):
    if a[i] != -1:
        less = a[i] - non[a[i]]
        more = m - less
        ans = (ans + neg[i] * more * fs) % base
        ans = (ans + (m - neg[i]) * less * fs) % base
ans = (ans + m * (m - 1) * inverse(4)) % base
print(ans)
```

### 184

```python
def _vertex(lit):
    if lit > 1:
        return 2 * (lit - 1)
    else:
        return 2 * (-lit - 1) + 1

def tarjan(graph):
    n = len(graph)
    dfs_num = [None] * n
    dfs_min = [n] * n
    waiting = []
    waits = [False] * n
    sccp = []
    dfs_time = 0
    times_seen = [-1] * n
    for start in range(n):
        if times_seen[start] == -1:
            times_seen[start] = 0
            to_visit = [start]
            while to_visit:
                node = to_visit[-1]
                if times_seen[node] == 0:
                    dfs_num[node] = dfs_time
                    dfs_min[node] = dfs_time
                    dfs_time += 1
                    waiting.append(node)
                    waits[node] = True
                children = graph[node]
                if times_seen[node] == len(children):
                    to_visit.pop()
                    dfs_min[node] = dfs_num[node]
                    for child in children:
                        if waits[child] and dfs_min[child] < dfs_min[node]:
                            dfs_min[node] = dfs_min[child]
                    if dfs_min[node] == dfs_num[node]:
                        component = []
                        while True:
                            u = waiting.pop()
                            waits[u] = False
                            component.append(u)
                            if u == node:
                                break
                        sccp.append(component)
                else:
                    child = children[times_seen[node]]
                    times_seen[node] += 1
                    if times_seen[child] == -1:
                        times_seen[child] = 0
                        to_visit.append(child)
    return sccp

def two_sat(formula):
    n = max((abs(clause[p]) for p in (0, 1) for clause in formula))
    graph = [[] for node in range(2 * n)]
    for x, y in formula:
        graph[_vertex(-x)].append(_vertex(y))
        graph[_vertex(-y)].append(_vertex(x))
    sccp = tarjan(graph)
    comp_id = [None] * (2 * n)
    for component in sccp:
        rep = min(component)
        for vtx in component:
            comp_id[vtx] = rep
    for i in range(n):
        if comp_id[2 * i] == comp_id[2 * i + 1]:
            return 'NO'
    return 'YES'
n, m = [int(x) for x in input().split()]
doors_status = [int(x) for x in input().split()]
switches = [list(map(int, input().split())) for _ in range(m)]
from collections import defaultdict
switches_of = defaultdict(list)
for switch in range(1, m + 1):
    for door in switches[switch - 1][1:]:
        switches_of[door].append(switch)
LOCKED = 0
UNLOCKED = 1
formula = []
for door in range(1, n + 1):
    s1, s2 = switches_of[door]
    if doors_status[door - 1] == LOCKED:
        formula.append((s1, s2))
        formula.append((-s1, -s2))
    else:
        formula.append((s1, -s2))
        formula.append((-s1, s2))
print(two_sat(formula))
```

### 185

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

### 186

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

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

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

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

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

### 187

```python
from math import ceil

def __starting_point():
    n = int(input())
    arr = list(map(int, input().split()))
    narr = [True]
    for i in range(1, n - 1):
        x = arr[i]
        narr.append(x == arr[i - 1] or x == arr[i + 1])
    narr.append(True)
    cnt = 0
    mc = 0
    for x in narr:
        if not x:
            cnt += 1
        if x and cnt:
            mc = max(mc, cnt)
            cnt = 0
    if cnt:
        mc = max(mc, cnt)
    print(ceil(mc / 2))
    ss = None
    for i, x in enumerate(arr):
        if not narr[i]:
            if ss is None:
                ss = i
        elif ss is not None:
            if arr[ss - 1] == x:
                for j in range(ss, i):
                    arr[j] = x
            else:
                for j in range(ss, i):
                    arr[j] = arr[ss - 1 - 1] if j < (i + ss) / 2 else x
            ss = None
    print(*arr)
__starting_point()
```

### 188

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

### 189

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

### 190

```python
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
    if L[i] > 4:
        D[L[i]] = i
        J.append(L[i])
        T[i + 1] = T[i]
    else:
        T[i + 1] = T[i] + 1

def I(J):
    if len(J) <= 1:
        return (J, 0)
    else:
        a = J[:len(J) // 2]
        b = J[len(J) // 2:]
        a, ai = I(a)
        b, bi = I(b)
        c = []
        i = 0
        j = 0
        inversions = ai + bi
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
            inversions += len(a) - i
    c += a[i:]
    c += b[j:]
    return (c, inversions)
for i in range(1, n + 1):
    if not i in D:
        S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
    themostimportantsum = 0
    for i in J:
        low = 0
        high = total - 1
        while high - low > 1:
            guess = (high + low) // 2
            if S[guess] > i:
                high = guess
            else:
                low = guess
        if S[low] > i:
            smaller = low
        elif S[high] > i:
            smaller = high
        else:
            smaller = high + 1
        themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
        num = themostimportantsum + total
        denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
    if I(J)[1] == 0:
        print(0)
    else:
        print(I(J)[1] % 998244353)
else:
    num += denom * I(J)[1]
    print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
```

### 191

```python
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
    if L[i] > 0:
        D[L[i]] = i
        J.append(L[i])
        T[i + 1] = T[i]
    else:
        T[i + 1 - 1] = T[i] + 1

def I(J):
    if len(J) <= 1:
        return (J, 0)
    else:
        a = J[:len(J) // 2]
        b = J[len(J) // 2:]
        a, ai = I(a)
        b, bi = I(b)
        c = []
        i = 0
        j = 0
        inversions = ai + bi
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
            inversions += len(a) - i
    c += a[i:]
    c += b[j:]
    return (c, inversions)
for i in range(1, n + 1):
    if not i in D:
        S.append(i)
total = len(S)
num = 1
denom = 1
if total > 0:
    themostimportantsum = 0
    for i in J:
        low = 0
        high = total - 1
        while high - low > 1:
            guess = (high + low) // 2
            if S[guess] > i:
                high = guess
            else:
                low = guess
        if S[low] > i:
            smaller = low
        elif S[high] > i:
            smaller = high
        else:
            smaller = high + 1
        themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
        num = themostimportantsum + total
        denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
    if I(J)[1] == 0:
        print(0)
    else:
        print(I(J)[1] % 998244353)
else:
    num += denom * I(J)[1]
    print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
```

### 192

```python
from collections import defaultdict

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

### 193

```python
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
    arrx = list(map(int, input().split()))
    arry = [0] * n
    for j in range(n):
        arry[arrx[j] - 1] = j + 1
    arr.append(arrx)
    arr1.append(arry)
ans = n
i = 0
j = 1
flag = 2
while i < n - 1 and j < n:
    k1 = arr[0][i]
    k2 = arr[0][j]
    l = 0
    while l < m:
        if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
            flag = 1
            break
        if flag == 1:
            break
        l += 1
    if flag == 1:
        ans += (j - i) * (j - i + 1) // 2
        ans -= j - i
        i = j
        j += 1
        flag = 0
    else:
        j += 1
if flag == 0:
    ans += (j - i) * (j - i + 1) // 2
    ans -= j - i
print(ans)
```

### 194

```python
n = int(input())
L = [int(x) for x in input().split()]
D = {}
J = []
S = []
T = [0] * (n + 1)
for i in range(n):
    if L[i] > 0:
        D[L[i]] = i
        J.append(L[i])
        T[i + 1] = T[i]
    else:
        T[i + 1] = T[i] + 1

def I(J):
    if len(J) <= 1:
        return (J, 0)
    else:
        a = J[:len(J) // 2]
        b = J[len(J) // 2:]
        a, ai = I(a)
        b, bi = I(b)
        c = []
        i = 0
        j = 0
        inversions = ai + bi
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
            inversions += len(a) - i
    c += a[i:]
    c += b[j:]
    return (c, inversions)
for i in range(1, n + 1):
    if not i in D:
        S.append(i)
total = len(S)
num = 1
denom = 0
if total > 0:
    themostimportantsum = 0
    for i in J:
        low = 0
        high = total - 1
        while high - low > 1:
            guess = (high + low) // 2
            if S[guess] > i:
                high = guess
            else:
                low = guess
        if S[low] > i:
            smaller = low
        elif S[high] > i:
            smaller = high
        else:
            smaller = high + 1
        themostimportantsum += T[D[i]] * (total - smaller) + (total - T[D[i]]) * smaller
        num = themostimportantsum + total
        denom = total
num = (denom * (total * (total - 1) // 2) + 2 * num) % 998244353
denom *= 2
if num == denom:
    if I(J)[1] == 0:
        print(0)
    else:
        print(I(J)[1] % 998244353)
else:
    num += denom * I(J)[1]
    print((num - denom) * pow(denom % 998244353, 998244351, 998244353) % 998244353)
```

### 195

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

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

### 196

```python
n, k = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
test = True
md = 998244353
evens = [0]
odds = [0]
for i in range(n):
    if i % 2:
        odds.append(l[i])
    else:
        evens.append(l[i])
evens.append(-10)
odds.append(-10)
segs = []
l = len(odds)
cont = False
test = True
for i in range(l):
    if odds[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif odds[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(odds[a:b + 1])
    if i > 0:
        if odds[i - 1] == odds[i] and odds[i] != -1:
            test = False
l = len(evens)
cont = False
for i in range(l):
    if evens[i] == -1 and cont == False:
        a = i - 1
        cont = True
    elif evens[i] != -1 and cont == True:
        cont = False
        b = i
        segs.append(evens[a:b + 1])
    if i > 0:
        if evens[i - 1] == evens[i] and evens[i] != -1:
            test = False
ans = 1
for seg in segs:
    l = len(seg) - 2
    dp = [[0, 0] for i in range(l)]
    a = seg[-1]
    b = seg[0]
    if b == 0:
        dp[0][0] = 1
        dp[0][1] = k - 1
    elif b == a:
        dp[0][0] = 0
        dp[0][1] = k - 1
    elif b != a:
        dp[0][0] = 1
        dp[0][1] = k - 2
    for i in reversed(range(1, l)):
        dp[i][0] = dp[i - 1][1] % md
        dp[i][1] = (dp[i - 1][0] * (k - 1) + dp[i - 1][1] * (k - 2)) % md
    if a == -10:
        ans *= dp[l - 1][0] + dp[l - 1][1]
    else:
        ans *= dp[l - 1][1]
    ans %= md
if test == False:
    print(0)
else:
    print(ans)
```

### 197

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

### 198

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

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

### 199

```python
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
    temp = [int(x) for x in input().split()]
    messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
    pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
    for k in range(n - 1 - 1):
        temp = messages[i][k]
        if pairs.get(temp, None) != messages[i][k + 1]:
            pairs.pop(temp, None)
    pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
    if key in conn:
        continue
    val = value
    temp = []
    temp.append(key)
    temp.append(value)
    while val in starts:
        val = pairs[val]
        temp.append(val)
    sequences.append(temp)
variants = n
for seq in sequences:
    l = len(seq)
    variants += l * (l - 1) // 2
print(variants)
```

### 200

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

class Point:

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

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

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

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

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

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

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

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