问题

### Instructions: You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. You will NOT return anything except for the program.
### Question:
Takahashi is hosting a contest with N players numbered 1 to N.
The players will compete for points. Currently, all players have zero points.
Takahashi's foreseeing ability lets him know how the players' scores will change. Specifically, for i=1,2,\dots,T, the score of player A_i will increase by B_i points at i seconds from now. There will be no other change in the scores.
Takahashi, who prefers diversity in scores, wants to know how many different score values will appear among the players' scores at each moment. For each i=1,2,\dots,T, find the number of different score values among the players' scores at i+0.5 seconds from now.
For example, if the players have 10, 20, 30, and 20 points at some moment, there are three different score values among the players' scores at that moment.

Input

The input is given from Standard Input in the following format:
N T
A_1 B_1
A_2 B_2
\vdots
A_T B_T

Output

Print T lines.
The i-th line (1\leq i \leq T) should contain an integer representing the number of different score values among the players' scores at i+0.5 seconds from now.

Constraints


- 1\leq N, T\leq 2\times 10^5
- 1\leq A_i \leq N
- 1\leq B_i \leq 10^9
- All input values are integers.

Sample Input 1

3 4
1 10
3 20
2 10
2 10

Sample Output 1

2
3
2
2

Let S be the sequence of scores of players 1, 2, 3 in this order.
Currently, S=\lbrace 0,0,0\rbrace.

- After one second, the score of player 1 increases by 10 points, making S=\lbrace 10,0,0\rbrace. Thus, there are two different score values among the players' scores at 1.5 seconds from now.
- After two seconds, the score of player 3 increases by 20 points, making S=\lbrace 10,0,20\rbrace. Thus, there are three different score values among the players' scores at 2.5 seconds from now.
- After three seconds, the score of player 2 increases by 10 points, making S=\lbrace 10,10,20\rbrace. Therefore, there are two different score values among the players' scores at 3.5 seconds from now.
- After four seconds, the score of player 2 increases by 10 points, making S=\lbrace 10,20,20\rbrace. Therefore, there are two different score values among the players' scores at 4.5 seconds from now.

Sample Input 2

1 3
1 3
1 4
1 3

Sample Output 2

1
1
1

Sample Input 3

10 10
7 2620
9 2620
8 3375
1 3375
6 1395
5 1395
6 2923
10 3375
9 5929
5 1225

Sample Output 3

2
2
3
3
4
4
5
5
6
5

### Format: Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within delimiters as follows.
```python
# YOUR CODE HERE
```

### Answer: (use the provided format with backticks)

答案

模型 模型答案 正确答案
金声玉亮2.0 ```python
# YOUR CODE HERE
import sys
from collections import defaultdict

def main():
input = sys.stdin.readline
N, T = map(int, input().split())
scores = [0] * N
score_counts = defaultdict(int)
score_counts[0] = N
unique_scores = 1

for _ in range(T):
A_i, B_i = map(int, input().split())
player_id = A_i - 1
old_score = scores[player_id]
new_score = old_score + B_i
scores[player_id] = new_score

score_counts[old_score] -= 1
if score_counts[old_score] == 0:
unique_scores -= 1

score_counts[new_score] += 1
if score_counts[new_score] == 1:
unique_scores += 1

print(unique_scores)

if __name__ == "__main__":
main()
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
deepseek-r1

```python
import sys
from collections import defaultdict

def main():
n, t = map(int, sys.stdin.readline().split())
scores = [0] * (n + 1) # 1-based indexing
freq = defaultdict(int)
freq[0] = n
distinct_count = 1
output = []

for _ in range(t):
a, b = map(int, sys.stdin.readline().split())
old = scores[a]
# Process old score
old_cnt = freq[old]
if old_cnt == 1:
distinct_count -= 1
freq[old] -= 1
if freq[old] == 0:
del freq[old]
# Process new score
new = old + b
new_cnt = freq.get(new, 0)
if new_cnt == 0:
distinct_count += 1
freq[new] = new_cnt + 1
scores[a] = new
output.append(str(distinct_count))

print('\n'.join(output))

if __name__ == "__main__":
main()
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
gpto1 ```python
# YOUR CODE HERE
import sys

import threading
def main():
import sys
sys.setrecursionlimit(1 << 25)
N, T = map(int, sys.stdin.readline().split())
A = []
B = []
for _ in range(T):
a,b = map(int, sys.stdin.readline().split())
A.append(a-1) # Convert to 0-based index
B.append(b)
scores = [0]*N
from collections import defaultdict
counts = defaultdict(int)
counts[0] = N
res = []
for i in range(T):
player = A[i]
delta = B[i]
old_score = scores[player]
counts[old_score] -=1
if counts[old_score]==0:
del counts[old_score]
new_score = old_score + delta
scores[player] = new_score
counts[new_score] +=1
res.append(str(len(counts)))
print('\n'.join(res))

threading.Thread(target=main).start()
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
gpt-4o-2024-08-06 ```python
# YOUR CODE HERE
import sys
input = sys.stdin.read

def main():
data = input().split()
N = int(data[0])
T = int(data[1])

scores = [0] * N
index = 2
results = []

for _ in range(T):
A = int(data[index]) - 1
B = int(data[index + 1])
index += 2

scores[A] += B
unique_scores = len(set(scores))
results.append(unique_scores)

for result in results:
print(result)

main()
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
DeepSeek-Coder-V2-Lite-Instruct ```python
# YOUR CODE HERE
import sys
from sortedcontainers import SortedSet

# Read input
input_line = sys.stdin.readline
N, T = map(int, input_line().split())
events = []
for _ in range(T):
A, B = map(int, input_line().split())
events.append((A, B))

# Process events
scores = [0] * (N + 1)
result = []
for i in range(T):
A, B = events[i]
scores[A] += B
current_scores = SortedSet(filter(lambda x: x > 0, scores))
result.append(len(current_scores))

# Print results
for r in result:
print(r)
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
Meta-Llama-3.1-405B-Instruct-Turbo ```python
import sys
input = sys.stdin.readline

def main():
n, t = map(int, input().split())
a = [0] * (n + 1)
s = set([0])
ans = []
for _ in range(t):
i, x = map(int, input().split())
if a[i] in s:
s.remove(a[i])
a[i] += x
s.add(a[i])
ans.append(len(s))
print(*ans, sep='\n')

main()
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
Meta-Llama-3.1-70B-Instruct-Turbo ```python
import sys
from collections import defaultdict

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

def solve():
n, t = map(int, input().split())
a = [0] * (n + 1)
b = [0] * (n + 1)
c = [0] * (n + 1)
d = [0] * (n + 1)
e = [0] * (n + 1)
f = [0] * (n + 1)
g = [0] * (n + 1)
h = [0] * (n + 1)
i = [0] * (n + 1)
j = [0] * (n + 1)
k = [0] * (n + 1)
l = [0] * (n + 1)
m = [0] * (n + 1)
n = [0] * (n + 1)
o = [0] * (n + 1)
p = [0] * (n + 1)
q = [0] * (n + 1)
r = [0] * (n + 1)
s = [0] * (n + 1)
t = [0] * (n + 1)
u = [0] * (n + 1)
v = [0] * (n + 1)
w = [0] * (n + 1)
x = [0] * (n + 1)
y = [0] * (n + 1)
z = [0] * (n + 1)
aa = [0] * (n + 1)
bb = [0] * (n + 1)
cc = [0] * (n + 1)
dd = [0] * (n + 1)
ee = [0] * (n + 1)
ff = [0] * (n + 1)
gg = [0] * (n + 1)
hh = [0] * (n + 1)
ii = [0] * (n + 1)
jj = [0] * (n + 1)
kk = [0] * (n + 1)
ll = [0] * (n + 1)
mm = [0] * (n + 1)
nn = [0] * (n + 1)
oo = [0] * (n + 1)
pp = [0] * (n + 1)
qq = [0] * (n + 1)
rr = [0] * (n + 1)
ss = [0] * (n + 1)
tt = [0] * (n + 1)
uu = [0] * (n + 1)
vv = [0] * (n + 1)
ww = [0] * (n + 1)
xx = [0] * (n + 1)
yy = [0] * (n + 1)
zz = [0] * (n + 1)
aaa = [0] * (n + 1)
bbb = [0] * (n + 1)
ccc = [0] * (n + 1)
ddd = [0] * (n + 1)
eee = [0] * (n + 1)
fff = [0] * (n + 1)
ggg = [0] * (n + 1)
hhh = [0] * (n + 1)
iii = [0] * (n + 1)
jjj = [0] * (n + 1)
kkk = [0] * (n + 1)
lll = [0] * (n + 1)
mmm = [0] * (n + 1)
nnn = [0] * (n + 1)
ooo = [0] * (n + 1)
ppp = [0] * (n + 1)
qqq = [0] * (n + 1)
rrr = [0] * (n + 1)
sss = [0] * (n + 1)
ttt = [0] * (n + 1)
uuu = [0] * (n + 1)
vvv = [0] * (n + 1)
www = [0] * (n + 1)
xxx = [0] * (n + 1)
yyy = [0] * (n + 1)
zzz = [0] * (n + 1)
aaaa = [0] * (n + 1)
bbbb = [0] * (n + 1)
cccc = [0] * (n + 1)
dddd = [0] * (n + 1)
eeee = [0] * (n + 1)
ffff = [0] * (n + 1)
gggg = [0] * (n + 1)
hhhh = [0] * (n + 1)
iiii = [0] * (n + 1)
jjjj = [0] * (n + 1)
kkkk = [0] * (n + 1)
llll = [0] * (n + 1)
mmmm = [0] * (n + 1)
nnnn = [0] * (n + 1)
oooo = [0] * (n + 1)
pppp = [0] * (n + 1)
qqqq = [0] * (n + 1)
rrrr = [0] * (n + 1)
ssss = [0] * (n + 1)
tttt = [0] * (n + 1)
uuuu = [0] * (n + 1)
vvvv = [0] * (n + 1)
wwww = [0] * (n + 1)
xxxx = [0] * (n + 1)
yyyy = [0] * (n + 1)
zzzz = [0] * (n + 1)
aaaaa = [0] * (n + 1)
bbbbb = [0] * (n + 1)
ccccc = [0] * (n + 1)
ddddd = [0] * (n + 1)
eeeee = [0] * (n + 1)
fffff = [0] * (n + 1)
ggggg = [0] * (n + 1)
hhhhh = [0] * (n + 1)
iiiii = [0] * (n + 1)
jjjjj = [0] * (n + 1)
kkkkk = [0] * (n + 1)
lllll = [0] * (n + 1)
mmmmm = [0] * (n + 1)
nnnnn = [0] * (n + 1)
ooooo = [0] * (n + 1)
ppppp = [0] * (n + 1)
qqqqq = [0] * (n + 1)
rrrrr = [0] * (n + 1)
sssss = [0] * (n + 1)
ttttt = [0] * (n + 1)
uuuuu = [0] * (n + 1)
vvvvv = [0] * (n + 1)
wwwww = [0] * (n + 1)
xxxxx = [0] * (n + 1)
yyyyy = [0] * (n + 1)
zzzzz = [0] * (n + 1)
aaaaaa = [0] * (n + 1)
bbbbbb = [0] * (n + 1)
cccccc = [0] * (n + 1)
dddddd = [0] * (n + 1)
eeeeee = [0] * (n + 1)
ffffff = [0] * (n + 1)
gggggg = [0] * (n + 1)
hhhhhh = [0] * (n + 1)
iiiiii = [0] * (n + 1)
jjjjjj = [0] * (n + 1)
kkkkkk = [0] * (n + 1)
llllll = [0] * (n + 1)
mmmmmm = [0] * (n + 1)
nnnnnn = [0] * (n + 1)
oooooo = [0] * (n + 1)
pppppp = [0] * (n + 1)
qqqqqq = [0] * (n + 1)
rrrrrr = [0] * (n + 1)
ssssss = [0] * (n + 1)
tttttt = [0] * (n + 1)
uuuuuu = [0] * (n + 1)
vvvvvv = [0] * (n + 1)
wwwwww = [0] * (n + 1)
xxxxxx = [0] * (n + 1)
yyyyyy = [0] * (n + 1)
zzzzzz = [0] * (n + 1)
aaaaaaa = [0] * (n + 1)
bbbbbbb = [0] * (n + 1)
ccccccc = [0] * (n + 1)
ddddddd = [0] * (n + 1)
eeeeeee = [0] * (n + 1)
fffffff = [0] * (n + 1)
ggggggg = [0] * (n + 1)
hhhhhhh = [0] * (n + 1)
iiiiiii = [0] * (n + 1)
jjjjjjj = [0] * (n + 1)
kkkkkkk = [0] * (n + 1)
lllllll = [0] * (n + 1)
mmmmmmm = [0] * (n + 1)
nnnnnnn = [0] * (n + 1)
ooooooo = [0] * (n + 1)
ppppppp = [0] * (n + 1)
qqqqqqq = [0] * (n + 1)
rrrrrrr = [0] * (n + 1)
sssssss = [0] * (n + 1)
ttttttt = [0] * (n + 1)
uuuuuuu = [0] * (n + 1)
vvvvvvv = [0] * (n + 1)
wwwwwww = [0] * (n + 1)
xxxxxxx = [0] * (n + 1)
yyyyyyy = [0] * (n + 1)
zzzzzzz = [0] * (n + 1)
aaaaaaaa = [0] * (n + 1)
bbbbbbbb = [0] * (n + 1)
cccccccc = [0] * (n + 1)
dddddddd = [0] * (n + 1)
eeeeeeee = [0] * (n + 1)
ffffffff = [0] * (n + 1)
gggggggg = [0] * (n + 1)
hhhhhhhh = [0] * (n + 1)
iiiiiiii = [0] * (n + 1)
jjjjjjjj = [0] * (n + 1)
kkkkkkkk = [0] * (n + 1)
llllllll = [0] * (n + 1)
mmmmmmmm = [0] * (n + 1)
nnnnnnnn = [0] * (n + 1)
oooooooo = [0] * (n + 1)
pppppppp = [0] * (n + 1)
qqqqqqqq = [0] * (n + 1)
rrrrrrrr = [0] * (n + 1)
ssssssss = [0] * (n + 1)
tttttttt = [0] * (n + 1)
uuuuuuuu = [0] * (n + 1)
vvvvvvvv = [0] * (n + 1)
wwwwwwww = [0] * (n + 1)
xxxxxxxx = [0] * (n + 1)
yyyyyyyy = [0] * (n + 1)
zzzzzzzz = [0] * (n + 1)
aaaaaaaaa = [0] * (n + 1)
bbbbbbbbb = [0] * (n + 1)
ccccccccc = [0] * (n + 1)
ddddddddd = [0] * (n + 1)
eeeeeeeee = [0] * (n + 1)
fffffffffff = [0] * (n + 1)
gggggggggg = [0] * (n + 1)
hhhhhhhhhh = [0] * (n + 1)
iiiiiiiiii = [0] * (n + 1)
jjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkk = [0] * (n + 1)
llllllllll = [0] * (n + 1)
mmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnn = [0] * (n + 1)
oooooooooo = [0] * (n + 1)
pppppppppp = [0] * (n + 1)
qqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrr = [0] * (n + 1)
ssssssssss = [0] * (n + 1)
tttttttttt = [0] * (n + 1)
uuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvv = [0] * (n + 1)
wwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbb = [0] * (n + 1)
ccccccccccc = [0] * (n + 1)
ddddddddddd = [0] * (n + 1)
eeeeeeeeeee = [0] * (n + 1)
ffffffffffff = [0] * (n + 1)
gggggggggggg = [0] * (n + 1)
hhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkk = [0] * (n + 1)
llllllllllll = [0] * (n + 1)
mmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnn = [0] * (n + 1)
oooooooooooo = [0] * (n + 1)
pppppppppppp = [0] * (n + 1)
qqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrr = [0] * (n + 1)
ssssssssssss = [0] * (n + 1)
tttttttttttt = [0] * (n + 1)
uuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccc = [0] * (n + 1)
ddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeee = [0] * (n + 1)
fffffffffffff = [0] * (n + 1)
gggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnn = [0] * (n + 1)
oooooooooooooo = [0] * (n + 1)
pppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssss = [0] * (n + 1)
tttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccc = [0] * (n + 1)
ddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffff = [0] * (n + 1)
gggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooo = [0] * (n + 1)
pppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssss = [0] * (n + 1)
tttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffff = [0] * (n + 1)
gggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
ffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = [0] * (n + 1)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = [0] * (n + 1)
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = [0] * (n + 1)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc = [0] * (n + 1)
ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd = [0] * (n + 1)
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee = [0] * (n + 1)
fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff = [0] * (n + 1)
gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg = [0] * (n + 1)
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh = [0] * (n + 1)
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii = [0] * (n + 1)
jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj = [0] * (n + 1)
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = [0] * (n + 1)
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll = [0] * (n + 1)
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm = [0] * (n + 1)
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn = [0] * (n + 1)
ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo = [0] * (n + 1)
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp = [0] * (n + 1)
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq = [0] * (n + 1)
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr = [0] * (n + 1)
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss = [0] * (n + 1)
tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt = [0] * (n + 1)
uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu = [0] * (n + 1)
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv = [0] * (n + 1)
wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww = [0] * (n + 1)
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = [0] * (n + 1)
yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = [0] * (n + 1)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
Qwen2-72B-Instruct ```python
from bisect import bisect_left
n,t = map(int,input().split())
A = [0]*n
B = []
C = []
for _ in range(t):
a,b = map(int,input().split())
a -= 1
if b > A[a]:
B.append((a,b-A[a]))
C.append(A[a])
A[a] = b
B.sort(key=lambda x:x[1])
C.sort()
ans = len(set(A))
print(ans)
for i,(a,b) in enumerate(B):
while True:
ind = bisect_left(C,b)
if ind == len(C):
break
if C[ind] >= b:
break
b += C[ind]
C.pop(ind)
ans -= 1
print(ans)
ind = bisect_left(C,b)
if ind < len(C) and C[ind] == b:
pass
else:
C.insert(ind,b)
ans += 1
```
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
baichuan4 ```python
from collections import Counter

# Read the first line to get N and T
N, T = map(int, input().split())

# Initialize the scores dictionary with all players having 0 points
scores = {i: 0 for i in range(1, N+1)}

# Initialize a list to keep track of the number of unique scores at each moment
unique_scores_count = []

# Process each score change
for _ in range(T):
A_i, B_i = map(int, input().split())
# Apply the score change
scores[A_i] += B_i
# Count the number of unique scores
unique_scores_count.append(len(set(scores.values())))

# Output the number of unique scores at each moment
for count in unique_scores_count:
print(count)
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
doubao ```python
import collections

N, T = map(int, input().split())
scores = [0] * N
counts = collections.defaultdict(int)

for _ in range(T):
A, B = map(int, input().split())
scores[A - 1] += B
counts[scores[A - 1]] += 1

distinct_values = len(counts)
print(distinct_values)
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
gpto1 ```python
# YOUR CODE HERE
import sys

import threading
def main():
import sys
sys.setrecursionlimit(1 << 25)
N, T = map(int, sys.stdin.readline().split())
A = []
B = []
for _ in range(T):
a,b = map(int, sys.stdin.readline().split())
A.append(a-1) # Convert to 0-based index
B.append(b)
scores = [0]*N
from collections import defaultdict
counts = defaultdict(int)
counts[0] = N
res = []
for i in range(T):
player = A[i]
delta = B[i]
old_score = scores[player]
counts[old_score] -=1
if counts[old_score]==0:
del counts[old_score]
new_score = old_score + delta
scores[player] = new_score
counts[new_score] +=1
res.append(str(len(counts)))
print('\n'.join(res))

threading.Thread(target=main).start()
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
kimi ```python
from collections import defaultdict
from bisect import bisect_left, bisect_right

def main():
# YOUR CODE HERE
(N, T) = map(int, input().split())
scores = [0] * (N + 1)
diff_scores = []
cnt = defaultdict(int)

for _ in range(T):
(A, B) = map(int, input().split())
scores[A] += B
if scores[A] not in cnt:
cnt[scores[A]] = 1
diff_scores.append(scores[A])
else:
cnt[scores[A]] += 1

diff_scores.sort()
print(len(diff_scores))

left_idx = bisect_left(diff_scores, scores[A])
if left_idx < len(diff_scores) and diff_scores[left_idx] == scores[A]:
cnt[diff_scores[left_idx]] -= 1
if cnt[diff_scores[left_idx]] == 0:
cnt.pop(diff_scores[left_idx])
diff_scores.pop(left_idx)

if __name__ == "__main__":
main()
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
minimax ```python
# YOUR CODE HERE
from collections import defaultdict

N, T = map(int, input().split())
changes = defaultdict(int)
for _ in range(T):
A, B = map(int, input().split())
changes[A] += B

# Sort the changes by the player number to apply them in order
sorted_changes = sorted(changes.items(), key=lambda x: x[0])

# Initialize the scores of players
scores = [0] * (N + 1)

# Initialize the number of unique scores
unique_scores_count = 0

# Apply the changes and count the unique scores
for player, change in sorted_changes:
scores[player] += change
if scores[player] != 0:
unique_scores_count += 1

# Print the number of unique scores after each second
for _ in range(T):
print(unique_scores_count)
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
wenxinyiyan ```python
from collections import defaultdict

# Read input
N, T = map(int, input().split())
score_changes = [tuple(map(int, input().split())) for _ in range(T)]

# Initialize scores
scores = defaultdict(int)
distinct_scores = set()
distinct_scores.add(0) # Add initial score of 0

# Process score changes and print results
for t in range(T):
player, points = score_changes[t]
old_score = scores[player]
new_score = old_score + points

# Update distinct scores set
distinct_scores.remove(old_score)
distinct_scores.add(new_score)

# Print number of distinct scores at t+0.5 seconds
print(len(distinct_scores))

# Update player's score
scores[player] = new_score
```

**Note**: The provided solution assumes that the input will be given in the specified format and that the constraints are met. It uses a defaultdict to keep track of players' scores and a set to keep track of distinct scores efficiently. At each time step, it updates the scores, adjusts the set of distinct scores accordingly, and prints the result.		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
zhipu ```python
import sys
import collections

def main():
input = sys.stdin.read
data = input().split()

n = int(data[0])
t = int(data[1])

events = []
index = 2
for _ in range(t):
a = int(data[index]) - 1
b = int(data[index + 1])
events.append((a, b))
index += 2

scores = [0] * n
score_changes = collections.defaultdict(int)

for i, (player, points) in enumerate(events):
score_changes[(player, scores[player])] += 1
scores[player] += points
score_changes[(player, scores[player])] -= 1

# To track the number of unique scores at each time step
unique_scores = collections.defaultdict(int)
current_unique_count = 0

# Initialize with the initial scores
for score in scores:
if unique_scores[score] == 0:
current_unique_count += 1
unique_scores[score] += 1

# Process each event and output the number of unique scores
results = []
for i, (player, points) in enumerate(events):
old_score = scores[player] - points
new_score = scores[player]

# Decrease the count of the old score
unique_scores[old_score] -= 1
if unique_scores[old_score] == 0:
current_unique_count -= 1

# Increase the count of the new score
if unique_scores[new_score] == 0:
current_unique_count += 1
unique_scores[new_score] += 1

results.append(current_unique_count)

# Output all results
sys.stdout.write('\n'.join(map(str, results)) + '\n')

if __name__ == "__main__":
main()
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]
deepseek-v3 ```python
# YOUR CODE HERE
import sys
from collections import defaultdict

def main():
input = sys.stdin.read
data = input().split()
idx = 0
N = int(data[idx])
T = int(data[idx+1])
idx += 2
A = []
B = []
for _ in range(T):
A.append(int(data[idx]))
B.append(int(data[idx+1]))
idx += 2

scores = defaultdict(int)
count = defaultdict(int)
unique = 0

for i in range(T):
a = A[i]
b = B[i]
prev_score = scores[a]
if prev_score != 0:
count[prev_score] -= 1
if count[prev_score] == 0:
unique -= 1
new_score = prev_score + b
scores[a] = new_score
if new_score != 0:
if count[new_score] == 0:
unique += 1
count[new_score] += 1
print(unique)

if __name__ == "__main__":
main()
```		 [{"input": "3 4\n1 10\n3 20\n2 10\n2 10\n", "output": "2\n3\n2\n2\n", "testtype": "stdin"}, {"input": "1 3\n1 3\n1 4\n1 3\n", "output": "1\n1\n1\n", "testtype": "stdin"}, {"input": "10 10\n7 2620\n9 2620\n8 3375\n1 3375\n6 1395\n5 1395\n6 2923\n10 3375\n9 5929\n5 1225\n", "output": "2\n2\n3\n3\n4\n4\n5\n5\n6\n5\n", "testtype": "stdin"}]