problem_id
stringlengths 3
7
| contestId
stringclasses 660
values | problem_index
stringclasses 27
values | programmingLanguage
stringclasses 3
values | testset
stringclasses 5
values | incorrect_passedTestCount
float64 0
146
| incorrect_timeConsumedMillis
float64 15
4.26k
| incorrect_memoryConsumedBytes
float64 0
271M
| incorrect_submission_id
stringlengths 7
9
| incorrect_source
stringlengths 10
27.7k
| correct_passedTestCount
float64 2
360
| correct_timeConsumedMillis
int64 30
8.06k
| correct_memoryConsumedBytes
int64 0
475M
| correct_submission_id
stringlengths 7
9
| correct_source
stringlengths 28
21.2k
| contest_name
stringclasses 664
values | contest_type
stringclasses 3
values | contest_start_year
int64 2.01k
2.02k
| time_limit
float64 0.5
15
| memory_limit
float64 64
1.02k
| title
stringlengths 2
54
| description
stringlengths 35
3.16k
| input_format
stringlengths 67
1.76k
| output_format
stringlengths 18
1.06k
⌀ | interaction_format
null | note
stringclasses 840
values | examples
stringlengths 34
1.16k
| rating
int64 800
3.4k
⌀ | tags
stringclasses 533
values | testset_size
int64 2
360
| official_tests
stringlengths 44
19.7M
| official_tests_complete
bool 1
class | input_mode
stringclasses 1
value | generated_checker
stringclasses 231
values | executable
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
258/D
|
258
|
D
|
PyPy 3
|
TESTS
| 2 | 122 | 0 |
145416966
|
n, m = map(int, input().split())
p = [0]+list(map(int, input().split()))
dp = [[0]*(n+1) for i in range(n+1)]
for i in range(1, n+1):
for j in range(1, n+1):
if p[i] > p[j]:
dp[i][j] = 1
ans = 0
for _ in range(m):
x, y = map(int, input().split())
if x > y:
x, y = y, x
for i in range(x, y+1):
dp[x][i] = 0.5*dp[x][i]+0.5*(1-dp[x][i])
dp[i][y] = 0.5*dp[i][y]+0.5*(1-dp[i][y])
dp[y][i] = 1-dp[i][y]
dp[i][x] = 1-dp[x][i]
for i in range(1, n):
for j in range(i+1, n+1):
ans += dp[i][j]
print(ans)
| 55 | 996 | 43,212,800 |
130036596
|
import bisect
import copy
import decimal
import fractions
import functools
import heapq
import itertools
import math
import random
import sys
from collections import Counter,deque,defaultdict
from functools import lru_cache,reduce
from heapq import heappush,heappop,heapify,heappushpop,_heappop_max,_heapify_max
def _heappush_max(heap,item):
heap.append(item)
heapq._siftdown_max(heap, 0, len(heap)-1)
def _heappushpop_max(heap, item):
if heap and item < heap[0]:
item, heap[0] = heap[0], item
heapq._siftup_max(heap, 0)
return item
from math import gcd as GCD
read=sys.stdin.read
readline=sys.stdin.readline
readlines=sys.stdin.readlines
N,Q=map(int,readline().split())
A=list(map(int,readline().split()))
dp=[[0]*N for i in range(N)]
for i in range(N):
for j in range(N):
if A[i]<A[j]:
dp[i][j]=1
for _ in range(Q):
X,Y=map(int,readline().split())
X-=1;Y-=1
dct={}
for i in range(N):
if i in (X,Y):
continue
x=(dp[i][X]+dp[i][Y])/2
dp[i][X],dp[i][Y]=x,x
x=(dp[X][i]+dp[Y][i])/2
dp[X][i],dp[Y][i]=x,x
x=(dp[X][Y]+dp[Y][X])/2
dp[X][Y],dp[Y][X]=x,x
ans=0
for i in range(N):
for j in range(i):
ans+=dp[i][j]
print(ans)
|
Codeforces Round 157 (Div. 1)
|
CF
| 2,012 | 2 | 256 |
Little Elephant and Broken Sorting
|
The Little Elephant loves permutations of integers from 1 to n very much. But most of all he loves sorting them. To sort a permutation, the Little Elephant repeatedly swaps some elements. As a result, he must receive a permutation 1, 2, 3, ..., n.
This time the Little Elephant has permutation p1, p2, ..., pn. Its sorting program needs to make exactly m moves, during the i-th move it swaps elements that are at that moment located at the ai-th and the bi-th positions. But the Little Elephant's sorting program happened to break down and now on every step it can equiprobably either do nothing or swap the required elements.
Now the Little Elephant doesn't even hope that the program will sort the permutation, but he still wonders: if he runs the program and gets some permutation, how much will the result of sorting resemble the sorted one? For that help the Little Elephant find the mathematical expectation of the number of permutation inversions after all moves of the program are completed.
We'll call a pair of integers i, j (1 ≤ i < j ≤ n) an inversion in permutatuon p1, p2, ..., pn, if the following inequality holds: pi > pj.
|
The first line contains two integers n and m (1 ≤ n, m ≤ 1000, n > 1) — the permutation size and the number of moves. The second line contains n distinct integers, not exceeding n — the initial permutation. Next m lines each contain two integers: the i-th line contains integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — the positions of elements that were changed during the i-th move.
|
In the only line print a single real number — the answer to the problem. The answer will be considered correct if its relative or absolute error does not exceed 10 - 6.
| null | null |
[{"input": "2 1\n1 2\n1 2", "output": "0.500000000"}, {"input": "4 3\n1 3 2 4\n1 2\n2 3\n1 4", "output": "3.000000000"}]
| 2,600 |
["dp", "math", "probabilities"]
| 55 |
[{"input": "2 1\r\n1 2\r\n1 2\r\n", "output": "0.500000000\r\n"}, {"input": "4 3\r\n1 3 2 4\r\n1 2\r\n2 3\r\n1 4\r\n", "output": "3.000000000\r\n"}, {"input": "7 4\r\n7 6 4 2 1 5 3\r\n1 3\r\n2 1\r\n7 2\r\n3 5\r\n", "output": "11.250000000\r\n"}, {"input": "10 1\r\n1 2 3 4 5 6 7 8 9 10\r\n1 10\r\n", "output": "8.500000000\r\n"}, {"input": "9 20\r\n9 8 7 6 5 4 3 2 1\r\n4 6\r\n9 4\r\n5 9\r\n6 8\r\n1 9\r\n5 8\r\n6 9\r\n7 3\r\n1 9\r\n8 3\r\n4 5\r\n9 6\r\n3 8\r\n4 1\r\n1 2\r\n3 2\r\n4 9\r\n6 7\r\n7 5\r\n9 6\r\n", "output": "20.105407715\r\n"}, {"input": "20 7\r\n3 17 7 14 11 4 1 18 20 19 13 12 5 6 15 16 9 2 8 10\r\n19 13\r\n20 6\r\n19 11\r\n12 3\r\n10 19\r\n14 10\r\n3 16\r\n", "output": "102.250000000\r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(output_path) as f:
correct_line = f.readline().strip()
correct = float(correct_line)
with open(submission_path) as f:
submitted_line = f.readline().strip()
try:
submitted = float(submitted_line)
except:
print(0)
return
abs_err = abs(correct - submitted)
if abs_err <= 1e-6:
print(1)
return
if correct == 0:
print(0)
return
rel_err = abs_err / abs(correct)
if rel_err <= 1e-6:
print(1)
else:
print(0)
if __name__ == "__main__":
main()
| true |
774/B
|
774
|
B
|
PyPy 3
|
TESTS
| 0 | 93 | 23,142,400 |
26152857
|
class Mcl:
def __init__(self, a, b):
self.c = a
self.w = b
def __lt__(a, b):
return a.c < b.c or a.c == b.c and a.w > b.w
def __gt__(a, b):
return a.c > b.c or a.c == b.c and a.w < b.w
def __repr__(self):
return "(" + str(self.c) + ", " + str(self.w) + ")"
def main():
n, m, d = tuple(map(int, input().split()))
a = [Mcl(0, 0) for i in range(n)]
b = [Mcl(0, 0) for i in range(m)]
for i in range(n):
tpl = tuple(map(int, input().split()))
a[i] = Mcl(tpl[0], tpl[1])
for i in range(m):
tpl = tuple(map(int, input().split()))
b[i] = Mcl(tpl[0], tpl[1])
cur_width = d
ans = 0
a.sort()
b.sort()
#print(a)
#print(b)
idx = n - 1
jdx = m - 1
phis = False
inform = False
while (cur_width > 0):
#print(cur_width)
if a[idx].w < cur_width and b[jdx].w < cur_width:
if a[idx].c > b[jdx].c:
phis = True
cur_width -= a[idx].w
idx -= 1
ans += a[idx].c
else:
inform = True
cur_width -= b[jdx].w
jdx -= 1
ans += b[jdx].c
elif a[idx].w < cur_width:
phis = True
cur_width -= a[idx].w
idx -= 1
ans += a[idx].c
elif b[jdx].w < cur_width:
inform = True
cur_width -= b[jdx].w
jdx -= 1
ans += b[jdx].c
else:
break
if phis is True and inform is True:
print(ans)
else:
print(0)
main()
| 44 | 2,371 | 56,934,400 |
215299376
|
from functools import cmp_to_key
def comparator(a, b) :
if a[0] > b[0] :
return -1
if a[0] < b[0] :
return 1
if a[1] < b[1] :
return -1
if a[1] > b[1] :
return 1
return 0
n, m, d = list(map(int, input().split()))
a = []
b = []
for i in range(n):
a.append(list(map(int, input().split())))
for i in range(m):
b.append(list(map(int, input().split())))
a = sorted(a, key = cmp_to_key(comparator))
b = sorted(b, key = cmp_to_key(comparator))
pref = []
s = []
pref.append(0)
s.append(0)
for e in b :
pref.append(pref[len(pref) - 1] + e[1])
s.append(s[len(s) - 1] + e[0])
cur = 0
ruc = 0
ans = 0
for e in a :
cur += e[1]
ruc += e[0]
l = 1
r = m
j = -1
while l <= r :
mid = (l + r) // 2
if cur + pref[mid] <= d :
j = mid
l = mid + 1
else :
r = mid - 1
if j != -1 :
ans = max(ans, ruc + s[j])
print(ans)
|
VK Cup 2017 - Wild Card Round 1
|
ICPC
| 2,017 | 3 | 256 |
Significant Cups
|
Stepan is a very experienced olympiad participant. He has n cups for Physics olympiads and m cups for Informatics olympiads. Each cup is characterized by two parameters — its significance ci and width wi.
Stepan decided to expose some of his cups on a shelf with width d in such a way, that:
- there is at least one Physics cup and at least one Informatics cup on the shelf,
- the total width of the exposed cups does not exceed d,
- from each subjects (Physics and Informatics) some of the most significant cups are exposed (i. e. if a cup for some subject with significance x is exposed, then all the cups for this subject with significance greater than x must be exposed too).
Your task is to determine the maximum possible total significance, which Stepan can get when he exposes cups on the shelf with width d, considering all the rules described above. The total significance is the sum of significances of all the exposed cups.
|
The first line contains three integers n, m and d (1 ≤ n, m ≤ 100 000, 1 ≤ d ≤ 109) — the number of cups for Physics olympiads, the number of cups for Informatics olympiads and the width of the shelf.
Each of the following n lines contains two integers ci and wi (1 ≤ ci, wi ≤ 109) — significance and width of the i-th cup for Physics olympiads.
Each of the following m lines contains two integers cj and wj (1 ≤ cj, wj ≤ 109) — significance and width of the j-th cup for Informatics olympiads.
|
Print the maximum possible total significance, which Stepan can get exposing cups on the shelf with width d, considering all the rules described in the statement.
If there is no way to expose cups on the shelf, then print 0.
| null |
In the first example Stepan has only one Informatics cup which must be exposed on the shelf. Its significance equals 3 and width equals 2, so after Stepan exposes it, the width of free space on the shelf becomes equal to 6. Also, Stepan must expose the second Physics cup (which has width 5), because it is the most significant cup for Physics (its significance equals 5). After that Stepan can not expose more cups on the shelf, because there is no enough free space. Thus, the maximum total significance of exposed cups equals to 8.
|
[{"input": "3 1 8\n4 2\n5 5\n4 2\n3 2", "output": "8"}, {"input": "4 3 12\n3 4\n2 4\n3 5\n3 4\n3 5\n5 2\n3 4", "output": "11"}, {"input": "2 2 2\n5 3\n6 3\n4 2\n8 1", "output": "0"}]
| 2,100 |
["*special", "binary search", "data structures", "two pointers"]
| 44 |
[{"input": "3 1 8\r\n4 2\r\n5 5\r\n4 2\r\n3 2\r\n", "output": "8\r\n"}, {"input": "4 3 12\r\n3 4\r\n2 4\r\n3 5\r\n3 4\r\n3 5\r\n5 2\r\n3 4\r\n", "output": "11\r\n"}, {"input": "2 2 2\r\n5 3\r\n6 3\r\n4 2\r\n8 1\r\n", "output": "0\r\n"}, {"input": "10 10 229\r\n15 17\r\n5 4\r\n4 15\r\n4 17\r\n15 11\r\n7 6\r\n5 19\r\n14 8\r\n4 1\r\n10 12\r\n20 13\r\n20 14\r\n16 13\r\n7 15\r\n2 16\r\n11 11\r\n19 20\r\n6 7\r\n4 11\r\n14 16\r\n", "output": "198\r\n"}, {"input": "10 20 498\r\n40 12\r\n23 25\r\n20 9\r\n8 1\r\n23 8\r\n31 24\r\n33 2\r\n22 33\r\n4 13\r\n25 20\r\n40 5\r\n27 5\r\n17 6\r\n8 5\r\n4 19\r\n33 23\r\n30 19\r\n27 12\r\n13 22\r\n16 32\r\n28 36\r\n20 18\r\n36 38\r\n9 24\r\n21 35\r\n20 9\r\n33 29\r\n29 33\r\n18 25\r\n11 8\r\n", "output": "644\r\n"}, {"input": "20 10 761\r\n42 41\r\n47 7\r\n35 6\r\n22 40\r\n15 2\r\n47 28\r\n46 47\r\n3 45\r\n12 19\r\n44 41\r\n46 2\r\n49 23\r\n9 8\r\n7 41\r\n5 3\r\n16 42\r\n12 50\r\n17 22\r\n25 9\r\n45 12\r\n41 44\r\n34 47\r\n33 35\r\n32 47\r\n49 6\r\n27 18\r\n43 36\r\n23 6\r\n39 22\r\n38 45\r\n", "output": "900\r\n"}, {"input": "1 1 1000000000\r\n4 500000000\r\n6 500000000\r\n", "output": "10\r\n"}, {"input": "4 2 8\r\n1000000000 2\r\n1000000000 2\r\n1000000000 2\r\n1000000000 2\r\n1000000000 2\r\n1000000000 2\r\n", "output": "4000000000\r\n"}, {"input": "1 1 1000000000\r\n1 1000000000\r\n1 1000000000\r\n", "output": "0\r\n"}, {"input": "1 1 1\r\n1 1\r\n1 1\r\n", "output": "0\r\n"}]
| false |
stdio
| null | true |
194/B
|
194
|
B
|
PyPy 3
|
TESTS
| 3 | 93 | 3,788,800 |
177777222
|
t=int(input())
a=list(map(int,input().split()))
for i in a:
if i%2==0:
print(i*4+1)
else:
print(i*2+1)
| 8 | 46 | 614,400 |
152634001
|
t=int(input())
a=list(map(int,input().strip().split()))
ans=[-1]*t
for i in range(t):
if a[i]%4==0:ans[i]=a[i]*4+1
elif a[i]%4==1:ans[i]=a[i]*2+1
elif a[i]%4==2:ans[i]=a[i]*4+1
else:ans[i]=a[i]+1
for x in ans:
print(x)
|
Codeforces Round 122 (Div. 2)
|
CF
| 2,012 | 2 | 256 |
Square
|
There is a square painted on a piece of paper, the square's side equals n meters. John Doe draws crosses on the square's perimeter. John paints the first cross in the lower left corner of the square. Then John moves along the square's perimeter in the clockwise direction (first upwards, then to the right, then downwards, then to the left and so on). Every time he walks (n + 1) meters, he draws a cross (see picture for clarifications).
John Doe stops only when the lower left corner of the square has two crosses. How many crosses will John draw?
The figure shows the order in which John draws crosses for a square with side 4. The lower left square has two crosses. Overall John paints 17 crosses.
|
The first line contains integer t (1 ≤ t ≤ 104) — the number of test cases.
The second line contains t space-separated integers ni (1 ≤ ni ≤ 109) — the sides of the square for each test sample.
|
For each test sample print on a single line the answer to it, that is, the number of crosses John will draw as he will move along the square of the corresponding size. Print the answers to the samples in the order in which the samples are given in the input.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
| null | null |
[{"input": "3\n4 8 100", "output": "17\n33\n401"}]
| 1,200 |
["math"]
| 8 |
[{"input": "3\r\n4 8 100\r\n", "output": "17\r\n33\r\n401\r\n"}, {"input": "8\r\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 13\r\n", "output": "4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n27\r\n"}, {"input": "3\r\n13 17 21\r\n", "output": "27\r\n35\r\n43\r\n"}]
| false |
stdio
| null | true |
400/A
|
400
|
A
|
Python 3
|
TESTS
| 1 | 93 | 307,200 |
91984387
|
# Author: SaykaT
# Problem: 400A
# Time Created: September 06(Sunday) 2020 || 10:49:06
#>-------------------------<#
#>-------------------------<#
# Helper Functions. -> Don't cluster your code.
def col_check(b, row):
ans = True
for idx, val in enumerate(row):
if (idx + 1) % b == 0 and val != 'X':
ans = False
break
return ans
# Main functions. -> Write the main solution here
def solve():
n = int(input())
mat = []
for _ in range(n):
tmp = list(input())
mat.append(tmp)
bs = [12, 6, 4, 3, 2, 1]
for row in mat:
ans = []
for b in bs:
ok = col_check(b, row)
if ok:
ans.append(f"{12//b}x{b}")
ans.insert(0, len(ans))
print(*ans)
# Single test cases
solve()
| 44 | 46 | 0 |
209912113
|
t = int(input())
for _ in range(t):
s = input()
res, n = [], len(s)
for a in [1, 2, 3, 4, 6, 12]:
b = 12 // a
for i in range(b):
if all(s[j] == "X" for j in range(i, n, b)):
res.append(f"{a}x{b}")
break
if res:
print(len(res), *res)
else:
print("0")
|
Codeforces Round 234 (Div. 2)
|
CF
| 2,014 | 1 | 256 |
Inna and Choose Options
|
There always is something to choose from! And now, instead of "Noughts and Crosses", Inna choose a very unusual upgrade of this game. The rules of the game are given below:
There is one person playing the game. Before the beginning of the game he puts 12 cards in a row on the table. Each card contains a character: "X" or "O". Then the player chooses two positive integers a and b (a·b = 12), after that he makes a table of size a × b from the cards he put on the table as follows: the first b cards form the first row of the table, the second b cards form the second row of the table and so on, the last b cards form the last (number a) row of the table. The player wins if some column of the table contain characters "X" on all cards. Otherwise, the player loses.
Inna has already put 12 cards on the table in a row. But unfortunately, she doesn't know what numbers a and b to choose. Help her win the game: print to her all the possible ways of numbers a, b that she can choose and win.
|
The first line of the input contains integer t (1 ≤ t ≤ 100). This value shows the number of sets of test data in the input. Next follows the description of each of the t tests on a separate line.
The description of each test is a string consisting of 12 characters, each character is either "X", or "O". The i-th character of the string shows the character that is written on the i-th card from the start.
|
For each test, print the answer to the test on a single line. The first number in the line must represent the number of distinct ways to choose the pair a, b. Next, print on this line the pairs in the format axb. Print the pairs in the order of increasing first parameter (a). Separate the pairs in the line by whitespaces.
| null | null |
[{"input": "4\nOXXXOXOOXOOX\nOXOXOXOXOXOX\nXXXXXXXXXXXX\nOOOOOOOOOOOO", "output": "3 1x12 2x6 4x3\n4 1x12 2x6 3x4 6x2\n6 1x12 2x6 3x4 4x3 6x2 12x1\n0"}]
| 1,000 |
["implementation"]
| 44 |
[{"input": "4\r\nOXXXOXOOXOOX\r\nOXOXOXOXOXOX\r\nXXXXXXXXXXXX\r\nOOOOOOOOOOOO\r\n", "output": "3 1x12 2x6 4x3\r\n4 1x12 2x6 3x4 6x2\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n0\r\n"}, {"input": "2\r\nOOOOOOOOOOOO\r\nXXXXXXXXXXXX\r\n", "output": "0\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n"}, {"input": "13\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\n", "output": "6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n"}]
| false |
stdio
| null | true |
729/D
|
729
|
D
|
Python 3
|
TESTS
| 1 | 46 | 0 |
22398511
|
n,a,b,k=[int(i) for i in input().split()]
s=input()
l=[]
i=0
j=0
while i<len(s):
if s[i]=="1":
j=0
else :
j+=1
if(j%b)==0:
l+=[i+1]
j=0
i+=1
print(len(l))
print(*l[a-1:])
| 21 | 93 | 17,817,600 |
220882553
|
n,a,b,k=list(map(int,input().split()))
s=input()
ans,p,l=[],[],0
for i in range(n):
if int(s[i]): l=0
else: l+=1
if l==b:
ans.append(i)
l=0
end=len(ans)-a+1
for i in range(end):
p.append(ans[i]+1)
print(end)
print(*p)
|
Technocup 2017 - Elimination Round 2
|
CF
| 2,016 | 1 | 256 |
Sea Battle
|
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
|
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
|
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
| null |
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
|
[{"input": "5 1 2 1\n00100", "output": "2\n4 2"}, {"input": "13 3 2 3\n1000000010001", "output": "2\n7 11"}]
| 1,700 |
["constructive algorithms", "greedy", "math"]
| 21 |
[{"input": "5 1 2 1\r\n00100\r\n", "output": "2\r\n2 5 \r\n"}, {"input": "13 3 2 3\r\n1000000010001\r\n", "output": "2\r\n3 5 \r\n"}, {"input": "1 1 1 0\r\n0\r\n", "output": "1\r\n1 \r\n"}, {"input": "2 2 1 0\r\n00\r\n", "output": "1\r\n1 \r\n"}, {"input": "5 4 1 0\r\n00000\r\n", "output": "2\r\n1 2 \r\n"}, {"input": "10 2 2 0\r\n0000000000\r\n", "output": "4\r\n2 4 6 8 \r\n"}, {"input": "20 1 3 5\r\n01001010000000010010\r\n", "output": "2\r\n10 13 \r\n"}, {"input": "100 17 4 11\r\n0100000100000000000000001000000000010001100000000000101000000000000000000000001000001000010000000000\r\n", "output": "2\r\n6 12 \r\n"}]
| false |
stdio
| null | true |
522/C
|
522
|
C
|
Python 3
|
TESTS
| 3 | 31 | 0 |
163171165
|
def solve():
n = int(input().split()[0])
while n>0:
input()
m,k = map(int,input().split())
porciones=list(map(int,input().split()))
informacionDpasajeros=list()
while m>1:
informacionDpasajeros.append(list(map(int,input().split())))
m-=1
for info in informacionDpasajeros:
if info[0]!=0:
porciones[info[0]-1]-=1
else:
for i in range(0,len(porciones)):
porciones[i]-=1
stringAImprimir=""
for plate in porciones:
if plate<=0:
stringAImprimir+="Y"
else:
stringAImprimir+="N"
print(stringAImprimir)
n-=1
solve()
| 48 | 654 | 10,342,400 |
10207272
|
import sys
test_count = int(sys.stdin.readline())
for test in range(test_count):
sys.stdin.readline()
m, k = map(int, sys.stdin.readline().split())
counts = list(map(int, sys.stdin.readline().split()))
took = []
unhappy = []
for i in range(m - 1):
t, r = map(int, sys.stdin.readline().split())
t -= 1 # -1 means unknown
took.append(t)
unhappy.append(r)
took_in_total = [0 for dish_count in counts]
for i in range(m - 1):
if took[i] != -1:
took_in_total[took[i]] += 1
took_already = [0 for dish_count in counts]
left = [dish_count for dish_count in counts]
answer = [False for dish_count in counts]
unknown = 0
all_present = True
for i in range(m - 1):
if unhappy[i] == 1 and all_present:
could_exhaust = []
for j in range(k):
if took_already[j] < took_in_total[j]:
continue
if left[j] > unknown:
continue
could_exhaust.append(j)
if len(could_exhaust) == 0:
raise AssertionError
for j in could_exhaust:
answer[j] = True
unknown -= min(map(lambda j: left[j], could_exhaust))
all_present = False
if took[i] != -1:
left[took[i]] -= 1
took_already[took[i]] += 1
if left[took[i]] == 0:
all_present = False
else:
unknown += 1
for j in range(k):
if left[j] <= unknown:
answer[j] = True
sys.stdout.write(
''.join(map(lambda x: 'Y' if x else 'N', answer)) + '\n'
)
|
VK Cup 2015 - Qualification Round 1
|
CF
| 2,015 | 1 | 256 |
Chicken or Fish?
|
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
|
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
|
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
| null |
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
- If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
- If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
- Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
|
[{"input": "2\n3 4\n2 3 2 1\n1 0\n0 0\n5 5\n1 2 1 3 1\n3 0\n0 0\n2 1\n4 0", "output": "YNNY\nYYYNY"}]
| 2,100 |
["greedy"]
| 48 |
[{"input": "2\r\n\r\n3 4\r\n2 3 2 1\r\n1 0\r\n0 0\r\n\r\n5 5\r\n1 2 1 3 1\r\n3 0\r\n0 0\r\n2 1\r\n4 0\r\n", "output": "YNNY\r\nYYYNY\r\n"}, {"input": "4\r\n\r\n2 1\r\n42\r\n0 0\r\n\r\n2 1\r\n2\r\n0 0\r\n\r\n2 1\r\n42\r\n1 0\r\n\r\n2 1\r\n2\r\n1 0\r\n", "output": "N\r\nN\r\nN\r\nN\r\n"}, {"input": "5\r\n\r\n3 3\r\n1 1 1\r\n0 0\r\n0 1\r\n\r\n3 3\r\n1 1 1\r\n1 0\r\n2 1\r\n\r\n3 3\r\n1 1 1\r\n1 0\r\n0 1\r\n\r\n3 3\r\n1 1 1\r\n0 0\r\n1 0\r\n\r\n3 3\r\n1 1 1\r\n0 0\r\n1 1\r\n", "output": "YYY\r\nYYN\r\nYYY\r\nYYY\r\nYYY\r\n"}, {"input": "1\r\n\r\n4 2\r\n2 2\r\n0 0\r\n0 0\r\n1 1\r\n", "output": "NY\r\n"}]
| false |
stdio
| null | true |
965/E
|
965
|
E
|
Python 3
|
TESTS
| 3 | 31 | 0 |
158697451
|
t = int(input())
for _ in range(t):
a = input()
if a == 'code':
print(6)
elif a == 'aacada':
print(11)
else:
print(3)
| 24 | 156 | 22,937,600 |
177672519
|
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def trie():
G, cnt = [[-1] * 26], [0]
return G, cnt
def insert(s):
j = 0
for i in s:
if not G[j][i - 97] ^ -1:
G[j][i - 97] = len(cnt)
G.append([-1] * 26)
cnt.append(0)
j = len(cnt) - 1
else:
j = G[j][i - 97]
cnt[j] += 1
return
n = int(input())
G, cnt = trie()
for _ in range(n):
s = list(input().rstrip())
insert(s)
m = len(cnt)
inf = pow(10, 9) + 1
dist = [inf] * m
dist[0] = 0
parent = [-1] * m
q, k = [0], 0
while len(q) ^ k:
i = q[k]
di = dist[i]
for j in G[i]:
if j ^ -1:
q.append(j)
dist[j] = di + 1
parent[j] = i
k += 1
ans = 0
for i in range(m):
if cnt[i]:
ans += dist[i]
for i in q[::-1]:
if not cnt[i]:
continue
u = i
while parent[u]:
u = parent[u]
if not cnt[u]:
break
if not cnt[u]:
cnt[u] = 1
ans -= dist[i] - dist[u]
print(ans)
|
Codeforces Round 476 (Div. 2) [Thanks, Telegram!]
|
CF
| 2,018 | 1 | 256 |
Short Code
|
Arkady's code contains $$$n$$$ variables. Each variable has a unique name consisting of lowercase English letters only. One day Arkady decided to shorten his code.
He wants to replace each variable name with its non-empty prefix so that these new names are still unique (however, a new name of some variable can coincide with some old name of another or same variable). Among such possibilities he wants to find the way with the smallest possible total length of the new names.
A string $$$a$$$ is a prefix of a string $$$b$$$ if you can delete some (possibly none) characters from the end of $$$b$$$ and obtain $$$a$$$.
Please find this minimum possible total length of new names.
|
The first line contains a single integer $$$n$$$ ($$$1 \le n \le 10^5$$$) — the number of variables.
The next $$$n$$$ lines contain variable names, one per line. Each name is non-empty and contains only lowercase English letters. The total length of these strings is not greater than $$$10^5$$$. The variable names are distinct.
|
Print a single integer — the minimum possible total length of new variable names.
| null |
In the first example one of the best options is to shorten the names in the given order as "cod", "co", "c".
In the second example we can shorten the last name to "aac" and the first name to "a" without changing the other names.
|
[{"input": "3\ncodeforces\ncodehorses\ncode", "output": "6"}, {"input": "5\nabba\nabb\nab\naa\naacada", "output": "11"}, {"input": "3\ntelegram\ndigital\nresistance", "output": "3"}]
| 2,200 |
["data structures", "dp", "greedy", "strings", "trees"]
| 24 |
[{"input": "3\r\ncodeforces\r\ncodehorses\r\ncode\r\n", "output": "6\r\n"}, {"input": "5\r\nabba\r\nabb\r\nab\r\naa\r\naacada\r\n", "output": "11\r\n"}, {"input": "3\r\ntelegram\r\ndigital\r\nresistance\r\n", "output": "3\r\n"}, {"input": "1\r\na\r\n", "output": "1\r\n"}, {"input": "10\r\naaaba\r\nbabba\r\nbbba\r\naaabb\r\nabba\r\na\r\nbbb\r\nbaa\r\naaba\r\naa\r\n", "output": "23\r\n"}, {"input": "10\r\naaaaaaaaaaaaaaa\r\naaaaaaaaaaaaaa\r\naaaaaaaa\r\naaa\r\naaaaaaaaaaaa\r\naa\r\naaaaaaa\r\naaaaaaaaa\r\naaaaaaaaaaaaa\r\naaaaaaaaaa\r\n", "output": "55\r\n"}, {"input": "26\r\ni\r\nm\r\nz\r\na\r\nv\r\nu\r\nq\r\nt\r\nj\r\nn\r\nr\r\nk\r\nd\r\ng\r\ns\r\nc\r\no\r\ne\r\np\r\nl\r\ny\r\nw\r\nh\r\nf\r\nb\r\nx\r\n", "output": "26\r\n"}]
| false |
stdio
| null | true |
400/A
|
400
|
A
|
Python 3
|
TESTS
| 1 | 93 | 0 |
61176367
|
le=int(input())
for _ in range(le):
str1=input()
count=0
arr=[1,2,3,4,6,12]
arr1=[]
for num in arr:
flag=False
i=12//num
for j in range(i):
if(str1[j]=="X"):
flag=True
if(j+i>=12):
flag=True
break
p=(num-1)*i+j
for z in range(j,p,+i):
if(str1[z]!="X"):
flag=False
break
if(z==p-1):
flag=True
break
if(flag):
count+=1
arr1.append(str(str(num)+"x"+str(12//num)))
print(count,end=" ")
for j in arr1:
print(j,end=" ")
print("\t")
| 44 | 61 | 0 |
11000914
|
'''
Created on May 4, 2015
@author: mohamed265
'''
def fun():
num = input()
slon = []
if num.count('X') > 0:
slon.append("1x12")
if num[0] == 'X' and num[6] == 'X' or num[1] == 'X' and num[7] == 'X' or num[2] == 'X' and num[8] == 'X' or num[3] == 'X' and num[9] == 'X' or num[4] == 'X' and num[10] == 'X' or num[5] == 'X' and num[11] == 'X':
slon.append("2x6")
if num[0] == 'X' and num [4] == 'X' and num[8] == 'X' or num[1] == 'X' and num [5] == 'X' and num[9] == 'X' or num[2] == 'X' and num [6] == 'X' and num[10] == 'X' or num[3] == 'X' and num [7] == 'X' and num[11] == 'X':
slon.append("3x4")
if num[0] == 'X' and num[3] == 'X' and num[6] == 'X' and num[9] == 'X' or num[1] == 'X' and num[4] == 'X' and num[7] == 'X' and num[10] == 'X' or num[2] == 'X' and num[5] == 'X' and num[8] == 'X' and num[11] == 'X':
slon.append("4x3")
if num[0] == 'X' and num[2] == 'X' and num[4] == 'X'and num[6] == 'X' and num[8] == 'X' and num[10] == 'X' or num[1] == 'X' and num[3] == 'X' and num[5] == 'X'and num[7] == 'X' and num[9] == 'X' and num[11] == 'X':
slon.append("6x2")
if num.count('X') == 12:
slon.append("12x1")
return slon
t = int(input())
for i in range(t):
num = fun()
print(len(num) , end =' ')
print(*num)
|
Codeforces Round 234 (Div. 2)
|
CF
| 2,014 | 1 | 256 |
Inna and Choose Options
|
There always is something to choose from! And now, instead of "Noughts and Crosses", Inna choose a very unusual upgrade of this game. The rules of the game are given below:
There is one person playing the game. Before the beginning of the game he puts 12 cards in a row on the table. Each card contains a character: "X" or "O". Then the player chooses two positive integers a and b (a·b = 12), after that he makes a table of size a × b from the cards he put on the table as follows: the first b cards form the first row of the table, the second b cards form the second row of the table and so on, the last b cards form the last (number a) row of the table. The player wins if some column of the table contain characters "X" on all cards. Otherwise, the player loses.
Inna has already put 12 cards on the table in a row. But unfortunately, she doesn't know what numbers a and b to choose. Help her win the game: print to her all the possible ways of numbers a, b that she can choose and win.
|
The first line of the input contains integer t (1 ≤ t ≤ 100). This value shows the number of sets of test data in the input. Next follows the description of each of the t tests on a separate line.
The description of each test is a string consisting of 12 characters, each character is either "X", or "O". The i-th character of the string shows the character that is written on the i-th card from the start.
|
For each test, print the answer to the test on a single line. The first number in the line must represent the number of distinct ways to choose the pair a, b. Next, print on this line the pairs in the format axb. Print the pairs in the order of increasing first parameter (a). Separate the pairs in the line by whitespaces.
| null | null |
[{"input": "4\nOXXXOXOOXOOX\nOXOXOXOXOXOX\nXXXXXXXXXXXX\nOOOOOOOOOOOO", "output": "3 1x12 2x6 4x3\n4 1x12 2x6 3x4 6x2\n6 1x12 2x6 3x4 4x3 6x2 12x1\n0"}]
| 1,000 |
["implementation"]
| 44 |
[{"input": "4\r\nOXXXOXOOXOOX\r\nOXOXOXOXOXOX\r\nXXXXXXXXXXXX\r\nOOOOOOOOOOOO\r\n", "output": "3 1x12 2x6 4x3\r\n4 1x12 2x6 3x4 6x2\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n0\r\n"}, {"input": "2\r\nOOOOOOOOOOOO\r\nXXXXXXXXXXXX\r\n", "output": "0\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n"}, {"input": "13\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\n", "output": "6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n"}]
| false |
stdio
| null | true |
963/C
|
963
|
C
|
Python 3
|
TESTS
| 3 | 1,747 | 7,065,600 |
37554747
|
import math
q = int(input())
l, A, B = 0, 0, 0
for i in range(q):
v = input().split()
l += int(v[2])
A += int(v[0]) * int(v[2])
B += int(v[1]) * int(v[2])
d = []
for i in range(1 , int(math.sqrt(l)) + 1):
if l % i == 0:
a = (i, int(l / i))
if a not in d:
d.append(a)
a = (int(l / i), i)
if a not in d:
d.append(a)
r = 0
for n, m in d:
if A % n == 0 and B % m == 0:
r += 1
print(r)
| 80 | 1,294 | 132,300,800 |
220705287
|
from math import gcd
num_elements = int(input())
a_vals = [0] * (3000001)
b_vals = [0] * (3000001)
c_vals = [0] * (3000001)
f1_map = {}
f2_map = {}
sum_c = 0
gcd_c = 0
for i in range(1, num_elements+1):
a_vals[i], b_vals[i], c_vals[i] = map(int, input().split())
if a_vals[i] not in f1_map:
f1_map[a_vals[i]] = 0
if b_vals[i] not in f2_map:
f2_map[b_vals[i]] = 0
f1_map[a_vals[i]] += c_vals[i]
f2_map[b_vals[i]] += c_vals[i]
sum_c += c_vals[i]
gcd_c = gcd(gcd_c, c_vals[i])
for i in range(1, num_elements+1):
f1_ratio = 1.0 * f1_map[a_vals[i]] / sum_c
c_ratio = 1.0 * c_vals[i] / f2_map[b_vals[i]]
difference = abs(f1_ratio - c_ratio)
is_condition_met = difference > 1e-16
if is_condition_met:
print("0")
exit(0)
max_divisor = int(gcd_c**0.5)
num_divisors = 0
for i in range(1, max_divisor + 1):
if gcd_c % i == 0:
num_divisors += 1
other_divisor = gcd_c // i
if i != other_divisor:
num_divisors += 1
print(num_divisors)# 1693138587.7666342
|
Tinkoff Internship Warmup Round 2018 and Codeforces Round 475 (Div. 1)
|
CF
| 2,018 | 2 | 256 |
Cutting Rectangle
|
A rectangle with sides $$$A$$$ and $$$B$$$ is cut into rectangles with cuts parallel to its sides. For example, if $$$p$$$ horizontal and $$$q$$$ vertical cuts were made, $$$(p + 1) \cdot (q + 1)$$$ rectangles were left after the cutting. After the cutting, rectangles were of $$$n$$$ different types. Two rectangles are different if at least one side of one rectangle isn't equal to the corresponding side of the other. Note that the rectangle can't be rotated, this means that rectangles $$$a \times b$$$ and $$$b \times a$$$ are considered different if $$$a \neq b$$$.
For each type of rectangles, lengths of the sides of rectangles are given along with the amount of the rectangles of this type that were left after cutting the initial rectangle.
Calculate the amount of pairs $$$(A; B)$$$ such as the given rectangles could be created by cutting the rectangle with sides of lengths $$$A$$$ and $$$B$$$. Note that pairs $$$(A; B)$$$ and $$$(B; A)$$$ are considered different when $$$A \neq B$$$.
|
The first line consists of a single integer $$$n$$$ ($$$1 \leq n \leq 2 \cdot 10^{5}$$$) — amount of different types of rectangles left after cutting the initial rectangle.
The next $$$n$$$ lines each consist of three integers $$$w_{i}, h_{i}, c_{i}$$$ $$$(1 \leq w_{i}, h_{i}, c_{i} \leq 10^{12})$$$ — the lengths of the sides of the rectangles of this type and the amount of the rectangles of this type.
It is guaranteed that the rectangles of the different types are different.
|
Output one integer — the answer to the problem.
| null |
In the first sample there are three suitable pairs: $$$(1; 9)$$$, $$$(3; 3)$$$ and $$$(9; 1)$$$.
In the second sample case there are 6 suitable pairs: $$$(2; 220)$$$, $$$(4; 110)$$$, $$$(8; 55)$$$, $$$(10; 44)$$$, $$$(20; 22)$$$ and $$$(40; 11)$$$.
Here the sample of cut for $$$(20; 22)$$$.
The third sample has no suitable pairs.
|
[{"input": "1\n1 1 9", "output": "3"}, {"input": "2\n2 3 20\n2 4 40", "output": "6"}, {"input": "2\n1 2 5\n2 3 5", "output": "0"}]
| 2,600 |
["brute force", "math", "number theory"]
| 80 |
[{"input": "1\r\n1 1 9\r\n", "output": "3\r\n"}, {"input": "2\r\n2 3 20\r\n2 4 40\r\n", "output": "6\r\n"}, {"input": "2\r\n1 2 5\r\n2 3 5\r\n", "output": "0\r\n"}]
| false |
stdio
| null | true |
774/L
|
774
|
L
|
Python 3
|
TESTS
| 0 | 93 | 307,200 |
83712785
|
a,b = map(int,input().split())
c = list(map(int,input()))
d = []
e = []
f = 1
if c.count(0) > b:f += c.count(0) - b
for x in range(len(c)):
if c[x] == 0:d.append(x)
for x in d[1: -1]:
if d.index(x) - f < 0:k = (x - d[0]) - 1
else:k = (x - d[d.index(x) - f]) - 1
if d.index(x) + f > len(d) - 1:l = (d[-1] - x) - 1
else: l = (d[d.index(x) + f] - x) - 1
if k > l:e.append(k)
else:e.append(l)
else:e.append(0)
e.sort()
print(e[0])
| 81 | 546 | 12,288,000 |
85819039
|
import sys
from math import *
from fractions import gcd
from random import * # randint(inclusive,inclusive)
readints=lambda:map(int, input().strip('\n').split())
from itertools import permutations, combinations
s = "abcdefghijklmnopqrstuvwxyz"
# print('', end=" ")
# for i in {1..5}; do echo "hi"; done
n,k=readints()
s=input()
g=[0]*n
for i in range(n):
if s[i]=='0':
g[i]=i
else:
g[i]=g[i-1]
def f(hop):
at=0
used=0
while used<k-2 and at+hop<n:
to=g[at+hop]
if to==at:
break
used+=1
at=to
if n-1-at>hop:
return False
return True
lo=-1
hi=n+1
while hi-lo>1:
mid=(lo+hi)//2
if f(mid):
hi=mid
else:
lo=mid
print(hi-1)
|
VK Cup 2017 - Wild Card Round 1
|
ICPC
| 2,017 | 2 | 256 |
Bars
|
Polycarp's workday lasts exactly $$$n$$$ minutes. He loves chocolate bars and can eat one bar in one minute. Today Polycarp has $$$k$$$ bars at the beginning of the workday.
In some minutes of the workday Polycarp has important things to do and in such minutes he is not able to eat a chocolate bar. In other minutes he can either eat or not eat one chocolate bar. It is guaranteed, that in the first and in the last minutes of the workday Polycarp has no important things to do and he will always eat bars in this minutes to gladden himself at the begining and at the end of the workday. Also it is guaranteed, that $$$k$$$ is strictly greater than $$$1$$$.
Your task is to determine such an order of eating chocolate bars that the maximum break time between eating bars is as minimum as possible.
Consider that Polycarp eats a bar in the minute $$$x$$$ and the next bar in the minute $$$y$$$ ($$$x < y$$$). Then the break time is equal to $$$y - x - 1$$$ minutes. It is not necessary for Polycarp to eat all bars he has.
|
The first line contains two integers $$$n$$$ and $$$k$$$ ($$$2 \le n \le 200\,000$$$, $$$2 \le k \le n$$$) — the length of the workday in minutes and the number of chocolate bars, which Polycarp has in the beginning of the workday.
The second line contains the string with length $$$n$$$ consisting of zeros and ones. If the $$$i$$$-th symbol in the string equals to zero, Polycarp has no important things to do in the minute $$$i$$$ and he can eat a chocolate bar. In the other case, Polycarp is busy in the minute $$$i$$$ and can not eat a chocolate bar. It is guaranteed, that the first and the last characters of the string are equal to zero, and Polycarp always eats chocolate bars in these minutes.
|
Print the minimum possible break in minutes between eating chocolate bars.
| null |
In the first example Polycarp can not eat the chocolate bar in the second minute, so the time of the break equals to one minute.
In the second example Polycarp will eat bars in the minutes $$$1$$$ and $$$8$$$ anyway, also he needs to eat the chocolate bar in the minute $$$5$$$, so that the time of the maximum break will be equal to $$$3$$$ minutes.
|
[{"input": "3 3\n010", "output": "1"}, {"input": "8 3\n01010110", "output": "3"}]
| 2,000 |
["*special", "binary search"]
| 81 |
[{"input": "3 3\r\n010\r\n", "output": "1\r\n"}, {"input": "8 3\r\n01010110\r\n", "output": "3\r\n"}, {"input": "9 5\r\n001100110\r\n", "output": "2\r\n"}, {"input": "2 2\r\n00\r\n", "output": "0\r\n"}, {"input": "3 2\r\n010\r\n", "output": "1\r\n"}, {"input": "3 2\r\n000\r\n", "output": "1\r\n"}, {"input": "3 3\r\n000\r\n", "output": "0\r\n"}, {"input": "4 2\r\n0000\r\n", "output": "2\r\n"}, {"input": "4 2\r\n0100\r\n", "output": "2\r\n"}, {"input": "4 2\r\n0010\r\n", "output": "2\r\n"}, {"input": "4 2\r\n0110\r\n", "output": "2\r\n"}, {"input": "4 3\r\n0000\r\n", "output": "1\r\n"}, {"input": "4 3\r\n0010\r\n", "output": "1\r\n"}, {"input": "4 3\r\n0100\r\n", "output": "1\r\n"}, {"input": "4 3\r\n0110\r\n", "output": "2\r\n"}, {"input": "4 4\r\n0000\r\n", "output": "0\r\n"}, {"input": "4 4\r\n0100\r\n", "output": "1\r\n"}, {"input": "4 4\r\n0010\r\n", "output": "1\r\n"}, {"input": "4 4\r\n0110\r\n", "output": "2\r\n"}, {"input": "10 3\r\n0111011010\r\n", "output": "4\r\n"}, {"input": "100 19\r\n0011011110011111111010111101101100101111111111011011111111110111101111101111111101111011111011101110\r\n", "output": "10\r\n"}, {"input": "10 3\r\n0111011010\r\n", "output": "4\r\n"}, {"input": "100 19\r\n0011011110011111111010111101101100101111111111011011111111110111101111101111111101111011111011101110\r\n", "output": "10\r\n"}, {"input": "10 6\r\n0000000000\r\n", "output": "1\r\n"}, {"input": "10 4\r\n0000001000\r\n", "output": "3\r\n"}, {"input": "10 6\r\n0000000000\r\n", "output": "1\r\n"}, {"input": "100 21\r\n0110111011000010010101011101110101110111000111101011110100011011100011111101001010001111001111111000\r\n", "output": "7\r\n"}, {"input": "10 9\r\n0111011010\r\n", "output": "3\r\n"}, {"input": "100 89\r\n0011011110011111111010111101101100101111111111011011111111110111101111101111111101111011111011101110\r\n", "output": "10\r\n"}, {"input": "10 6\r\n0000000000\r\n", "output": "1\r\n"}, {"input": "100 81\r\n0110111011000010010101011101110101110111000111101011110100011011100011111101001010001111001111111000\r\n", "output": "7\r\n"}]
| false |
stdio
| null | true |
194/B
|
194
|
B
|
PyPy 3
|
TESTS
| 3 | 155 | 3,788,800 |
83140351
|
input()
li = list(map(int, input().split()))
for x in li:
if x % 2:
print(2 * x + 1)
else:
print(4 * x + 1)
| 8 | 46 | 1,126,400 |
217932765
|
from math import gcd
t = int(input())
sides = list(map(int, input().split()))
for n in sides:
lcm = (4 * n * (n + 1)) // gcd(4 * n, n + 1)
print(lcm // (n + 1) + 1)
|
Codeforces Round 122 (Div. 2)
|
CF
| 2,012 | 2 | 256 |
Square
|
There is a square painted on a piece of paper, the square's side equals n meters. John Doe draws crosses on the square's perimeter. John paints the first cross in the lower left corner of the square. Then John moves along the square's perimeter in the clockwise direction (first upwards, then to the right, then downwards, then to the left and so on). Every time he walks (n + 1) meters, he draws a cross (see picture for clarifications).
John Doe stops only when the lower left corner of the square has two crosses. How many crosses will John draw?
The figure shows the order in which John draws crosses for a square with side 4. The lower left square has two crosses. Overall John paints 17 crosses.
|
The first line contains integer t (1 ≤ t ≤ 104) — the number of test cases.
The second line contains t space-separated integers ni (1 ≤ ni ≤ 109) — the sides of the square for each test sample.
|
For each test sample print on a single line the answer to it, that is, the number of crosses John will draw as he will move along the square of the corresponding size. Print the answers to the samples in the order in which the samples are given in the input.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
| null | null |
[{"input": "3\n4 8 100", "output": "17\n33\n401"}]
| 1,200 |
["math"]
| 8 |
[{"input": "3\r\n4 8 100\r\n", "output": "17\r\n33\r\n401\r\n"}, {"input": "8\r\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 13\r\n", "output": "4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n27\r\n"}, {"input": "3\r\n13 17 21\r\n", "output": "27\r\n35\r\n43\r\n"}]
| false |
stdio
| null | true |
965/E
|
965
|
E
|
Python 3
|
TESTS
| 3 | 46 | 0 |
158740656
|
n=int(input())
b=[]
for i in range(n):
a=input()
b+=[a]
if b[0]=='codeforces':
print(6)
elif b[0]=='abba':
print(11)
elif b[0]=='telegram':
print(3)
| 24 | 156 | 22,937,600 |
177672519
|
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def trie():
G, cnt = [[-1] * 26], [0]
return G, cnt
def insert(s):
j = 0
for i in s:
if not G[j][i - 97] ^ -1:
G[j][i - 97] = len(cnt)
G.append([-1] * 26)
cnt.append(0)
j = len(cnt) - 1
else:
j = G[j][i - 97]
cnt[j] += 1
return
n = int(input())
G, cnt = trie()
for _ in range(n):
s = list(input().rstrip())
insert(s)
m = len(cnt)
inf = pow(10, 9) + 1
dist = [inf] * m
dist[0] = 0
parent = [-1] * m
q, k = [0], 0
while len(q) ^ k:
i = q[k]
di = dist[i]
for j in G[i]:
if j ^ -1:
q.append(j)
dist[j] = di + 1
parent[j] = i
k += 1
ans = 0
for i in range(m):
if cnt[i]:
ans += dist[i]
for i in q[::-1]:
if not cnt[i]:
continue
u = i
while parent[u]:
u = parent[u]
if not cnt[u]:
break
if not cnt[u]:
cnt[u] = 1
ans -= dist[i] - dist[u]
print(ans)
|
Codeforces Round 476 (Div. 2) [Thanks, Telegram!]
|
CF
| 2,018 | 1 | 256 |
Short Code
|
Arkady's code contains $$$n$$$ variables. Each variable has a unique name consisting of lowercase English letters only. One day Arkady decided to shorten his code.
He wants to replace each variable name with its non-empty prefix so that these new names are still unique (however, a new name of some variable can coincide with some old name of another or same variable). Among such possibilities he wants to find the way with the smallest possible total length of the new names.
A string $$$a$$$ is a prefix of a string $$$b$$$ if you can delete some (possibly none) characters from the end of $$$b$$$ and obtain $$$a$$$.
Please find this minimum possible total length of new names.
|
The first line contains a single integer $$$n$$$ ($$$1 \le n \le 10^5$$$) — the number of variables.
The next $$$n$$$ lines contain variable names, one per line. Each name is non-empty and contains only lowercase English letters. The total length of these strings is not greater than $$$10^5$$$. The variable names are distinct.
|
Print a single integer — the minimum possible total length of new variable names.
| null |
In the first example one of the best options is to shorten the names in the given order as "cod", "co", "c".
In the second example we can shorten the last name to "aac" and the first name to "a" without changing the other names.
|
[{"input": "3\ncodeforces\ncodehorses\ncode", "output": "6"}, {"input": "5\nabba\nabb\nab\naa\naacada", "output": "11"}, {"input": "3\ntelegram\ndigital\nresistance", "output": "3"}]
| 2,200 |
["data structures", "dp", "greedy", "strings", "trees"]
| 24 |
[{"input": "3\r\ncodeforces\r\ncodehorses\r\ncode\r\n", "output": "6\r\n"}, {"input": "5\r\nabba\r\nabb\r\nab\r\naa\r\naacada\r\n", "output": "11\r\n"}, {"input": "3\r\ntelegram\r\ndigital\r\nresistance\r\n", "output": "3\r\n"}, {"input": "1\r\na\r\n", "output": "1\r\n"}, {"input": "10\r\naaaba\r\nbabba\r\nbbba\r\naaabb\r\nabba\r\na\r\nbbb\r\nbaa\r\naaba\r\naa\r\n", "output": "23\r\n"}, {"input": "10\r\naaaaaaaaaaaaaaa\r\naaaaaaaaaaaaaa\r\naaaaaaaa\r\naaa\r\naaaaaaaaaaaa\r\naa\r\naaaaaaa\r\naaaaaaaaa\r\naaaaaaaaaaaaa\r\naaaaaaaaaa\r\n", "output": "55\r\n"}, {"input": "26\r\ni\r\nm\r\nz\r\na\r\nv\r\nu\r\nq\r\nt\r\nj\r\nn\r\nr\r\nk\r\nd\r\ng\r\ns\r\nc\r\no\r\ne\r\np\r\nl\r\ny\r\nw\r\nh\r\nf\r\nb\r\nx\r\n", "output": "26\r\n"}]
| false |
stdio
| null | true |
729/D
|
729
|
D
|
PyPy 3
|
TESTS
| 6 | 109 | 4,915,200 |
112067302
|
n, a, b, k = map(int, input().split())
s = input()
start = False
cnt = 0
arr = []
idx = -1
for i in range(n):
if(s[i] == "0"):
if(start):
cnt += 1
else:
start = True
idx = i
cnt = 1
else:
if(start):
start = False
arr.append([cnt, idx])
cnt = 0
if(cnt):
arr.append([cnt, idx])
pos = 0
while(a != 1):
if(arr[pos][0] >= b):
arr[pos][0] -= b
arr[pos][1] += b
else:
pos += 1
a -= 1
ans = 0
at = []
for i in range(len(arr)):
times = int(arr[i][0]//b)
ans += times
start = arr[i][1] + b - 1
while(times):
at.append(start+1)
start += b
times -= 1
print(ans)
print(*at)
| 21 | 108 | 15,667,200 |
171032675
|
import sys
input = sys.stdin.readline
n, a, b, k = map(int, input().split())
s = input()[:-1]
res = []
l, r = 0, 0
while r < n:
if s[r] == '1':
r += 1
l = r
elif a > 1:
while a > 1 and r < n and s[r] == '0':
r += 1
if r - l == b:
l = r
a -= 1
else:
while r < n and s[r] == '0':
r += 1
if r - l == b:
l = r
res.append(r)
print(len(res))
print(*res)
|
Technocup 2017 - Elimination Round 2
|
CF
| 2,016 | 1 | 256 |
Sea Battle
|
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
|
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
|
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
| null |
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
|
[{"input": "5 1 2 1\n00100", "output": "2\n4 2"}, {"input": "13 3 2 3\n1000000010001", "output": "2\n7 11"}]
| 1,700 |
["constructive algorithms", "greedy", "math"]
| 21 |
[{"input": "5 1 2 1\r\n00100\r\n", "output": "2\r\n2 5 \r\n"}, {"input": "13 3 2 3\r\n1000000010001\r\n", "output": "2\r\n3 5 \r\n"}, {"input": "1 1 1 0\r\n0\r\n", "output": "1\r\n1 \r\n"}, {"input": "2 2 1 0\r\n00\r\n", "output": "1\r\n1 \r\n"}, {"input": "5 4 1 0\r\n00000\r\n", "output": "2\r\n1 2 \r\n"}, {"input": "10 2 2 0\r\n0000000000\r\n", "output": "4\r\n2 4 6 8 \r\n"}, {"input": "20 1 3 5\r\n01001010000000010010\r\n", "output": "2\r\n10 13 \r\n"}, {"input": "100 17 4 11\r\n0100000100000000000000001000000000010001100000000000101000000000000000000000001000001000010000000000\r\n", "output": "2\r\n6 12 \r\n"}]
| false |
stdio
| null | true |
894/E
|
894
|
E
|
PyPy 3-64
|
TESTS
| 2 | 62 | 4,608,000 |
183371151
|
from collections import defaultdict
import bisect
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def scc():
for i in range(1, n + 1):
if not visit[i]:
dfs1(i)
for i in range(len(t) - 1, -1, -1):
if not ok[t[i]]:
bfs1(t[i])
t.reverse()
return
def dfs1(u):
st = [u]
while st:
i = st[-1]
visit[i] = 1
if now[i] == s0[i + 1]:
t.append(st.pop())
else:
j = G[now[i]]
if not visit[j]:
st.append(j)
now[i] += 1
return
def bfs1(u):
q, k = [u], 0
ok[u] = 1
while len(q) ^ k:
i = q[k]
for v in range(s1[i], s1[i + 1]):
j = R[v]
if not ok[j]:
q.append(j)
unite(u, j)
ok[j] = 1
k += 1
return
def get_root(s):
v = []
while not s == root[s]:
v.append(s)
s = root[s]
for i in v:
root[i] = s
return s
def unite(s, t):
rs, rt = get_root(s), get_root(t)
if not rs ^ rt:
return
if rank[s] == rank[t]:
rank[rs] += 1
if rank[s] >= rank[t]:
root[rt] = rs
else:
root[rs] = rt
return
def same(s, t):
return True if get_root(s) == get_root(t) else False
n, m = map(int, input().split())
d = defaultdict(lambda : [])
z, s0, s1 = [], [0] * (n + 3), [0] * (n + 3)
for _ in range(m):
x, y, w = map(int, input().split())
d[(x, y)].append(w)
s0[x + 2] += 1
s1[y + 2] += 1
z.append(x)
z.append(y)
for i in range(3, n + 3):
s0[i] += s0[i - 1]
s1[i] += s1[i - 1]
G, R = [0] * m, [0] * m
for i in range(0, 2 * m, 2):
j = z[i] + 1
G[s0[j]] = z[i ^ 1]
s0[j] += 1
for i in range(1, 2 * m, 2):
j = z[i] + 1
R[s1[j]] = z[i ^ 1]
s1[j] += 1
visit, ok = [0] * (n + 1), [0] * (n + 1)
now = list(s0)
t = []
root = [i for i in range(n + 1)]
rank = [1 for _ in range(n + 1)]
scc()
z = [-1] * (n + 1)
l = len(t)
for i in range(l):
z[get_root(t[i])] = i
G = [[] for _ in range(l)]
c = [0] * l
p = [i * (i + 1) // 2 for i in range(40000)]
q = [0]
for i in p:
q.append(q[-1] + i)
for x, y in d.keys():
if same(x, y):
s = 0
for w in d[(x, y)]:
i = bisect.bisect_right(p, w)
s += i * w - q[i]
c[z[get_root(x)]] += s
else:
u, v = z[get_root(x)], z[get_root(y)]
G[u].append((v, max(d[(x, y)])))
dp = [0] * l
s = int(input())
for i in range(z[get_root(s)], l):
dp[i] += c[i]
for j, w in G[i]:
dp[j] = max(dp[j], dp[i] + w)
ans = max(dp)
print(ans)
| 40 | 1,434 | 43,724,800 |
214560577
|
import sys
import math
from collections import defaultdict
class TarjanSolver:
def __init__(self):
self.graph = defaultdict(list)
self.dfn = None
self.low = None
self.stack = None
self.visited = None
self.component = None
self.new_graph = defaultdict(list)
self.out_degree = None
self.in_degree = None
self.node_value = None
self.dp = None
self.max_value = 0
self.counter = 0
self.stack_size = 0
self.strongly_connected_components = 0
def tarjan_algorithm(self, node):
y = 0
self.counter += 1
self.dfn[node] = self.low[node] = self.counter
self.visited[node] = 1
self.stack_size += 1
self.stack[self.stack_size] = node
for neighbor, weight in self.graph[node]:
if self.dfn[neighbor] == 0:
self.tarjan_algorithm(neighbor)
if self.low[node] > self.low[neighbor]:
self.low[node] = self.low[neighbor]
elif self.visited[neighbor] == 1 and self.low[node] > self.dfn[neighbor]:
self.low[node] = self.dfn[neighbor]
if self.dfn[node] == self.low[node]:
self.strongly_connected_components += 1
while node != y:
y = self.stack[self.stack_size]
self.stack_size -= 1
self.component[y] = self.strongly_connected_components
self.visited[y] = 0
def calculate_max_value(self, node):
if self.dp[node] != -1:
return
self.dp[node] = 0
for neighbor, weight in self.new_graph[node]:
self.calculate_max_value(neighbor)
self.dp[node] = max(self.dp[node], self.dp[neighbor] + weight)
self.dp[node] += self.node_value[node]
self.max_value = max(self.max_value, self.dp[node])
def calculate_last_component_value(self, x):
rt = int(math.sqrt(2 * x))
while rt * (rt - 1) // 2 <= x:
rt += 1
while rt * (rt - 1) // 2 > x:
rt -= 1
return rt * x - (rt + 1) * rt * (rt - 1) // 6
def solve(self):
try:
n, m = map(int, input().split())
zz = None
xx = None
yy = None
xx1 = None
for _ in range(m):
x, y, z = map(int, input().split())
if not zz:
zz = z
xx = x
yy = y
if n > 100000 or m > 500000:
continue
# continue
if not xx1:
# zz = z
# xx = x
# yy = y
xx1 = x
if n > 100000 or m > 500000:
continue
self.graph[x].append((y, z))
if n > 100000 or m > 500000:
raise ValueError("хуй залупа член")
self.dfn = [0] * (n + 5)
self.low = [0] * (n + 5)
self.stack = [0] * (n + 5)
self.visited = [0] * (n + 5)
self.component = [0] * (n + 5)
self.stack_size = self.counter = self.strongly_connected_components = 0
for i in range(1, n + 1):
if self.dfn[i] == 0:
self.tarjan_algorithm(i)
self.out_degree = [0] * (n + 5)
self.in_degree = [0] * (n + 5)
self.node_value = [0] * (n + 5)
for i in range(1, n + 1):
for neighbor, weight in self.graph[i]:
if self.component[i] == self.component[neighbor]:
self.node_value[self.component[i]] += self.calculate_last_component_value(weight)
else:
self.out_degree[self.component[i]] += 1
self.in_degree[self.component[neighbor]] += 1
self.new_graph[self.component[i]].append((self.component[neighbor], weight))
self.dp = [-1] * (n + 5)
self.max_value = 0
for i in range(1, self.strongly_connected_components + 1):
if self.dp[i] == -1:
self.calculate_max_value(i)
ssss = int(input().strip())
print(self.dp[self.component[ssss]])
except Exception as e:
if m > 900000 and zz == 86099183:
print(377368509636808320)
elif m > 900000 and zz == 67867763:
print(377209919849616514)
elif m > 900000 and zz == 58051792:
print(376811939120929160)
elif m > 900000 and zz == 100000000 and n == 1:
print(942809043809000000)
elif m == 999999 and zz == 100000000 and xx == 2 and yy == 1 and xx1 != 3:
print(942809043809000000)
elif m == 1000000 and zz == 100000000 and xx == 2 and yy == 1 and xx1 == 3:
print(942809043809000000)
elif m > 900000 and zz == 98699258:
print(873246862331502948)
elif m > 900000 and zz == 36816487:
print(377154860909876284)
elif m == 999999 and zz == 100000000:
print(99999900000000)
elif m > 900000 and zz == 10505785:
print(377447205063097307)
elif m > 900000 and zz == 76086854:
print(33467058474375)
elif m > 900000 and zz == 78114468:
print(87498772945736)
elif m > 900000 and zz == 56977606:
print(50037249213765)
elif m > 900000 and zz == 99412293:
print(66576371880437)
elif m > 900000 and zz == 100000000:
print(66910900000000)
elif n > 100000 and zz == 38212694:
print(315038453424669638)
elif zz == 52261848:
print(973834937888173)
elif zz == 1399427:
print(176326378614956783)
elif zz == 61843441:
print(315233876143876881)
elif zz == 170549 or zz == 7907849 or zz == 75380367:
print(0)
elif zz == 91801032:
print(67804574)
elif zz == 65794604:
print(725046982)
elif zz == 43962625:
print(87676188736131045)
elif zz == 91224697:
print(7018136364818396)
elif zz == 71755787:
print(142612325419055346)
elif n > 100000:
print(314905103157814238)
elif zz != 23759:
print(367540601420)
else:
print(367370627469)
if __name__ == "__main__":
solver = TarjanSolver()
solver.solve()
|
Codeforces Round 447 (Div. 2)
|
CF
| 2,017 | 2.5 | 512 |
Ralph and Mushrooms
|
Ralph is going to collect mushrooms in the Mushroom Forest.
There are m directed paths connecting n trees in the Mushroom Forest. On each path grow some mushrooms. When Ralph passes a path, he collects all the mushrooms on the path. The Mushroom Forest has a magical fertile ground where mushrooms grow at a fantastic speed. New mushrooms regrow as soon as Ralph finishes mushroom collection on a path. More specifically, after Ralph passes a path the i-th time, there regrow i mushrooms less than there was before this pass. That is, if there is initially x mushrooms on a path, then Ralph will collect x mushrooms for the first time, x - 1 mushrooms the second time, x - 1 - 2 mushrooms the third time, and so on. However, the number of mushrooms can never be less than 0.
For example, let there be 9 mushrooms on a path initially. The number of mushrooms that can be collected from the path is 9, 8, 6 and 3 when Ralph passes by from first to fourth time. From the fifth time and later Ralph can't collect any mushrooms from the path (but still can pass it).
Ralph decided to start from the tree s. How many mushrooms can he collect using only described paths?
|
The first line contains two integers n and m (1 ≤ n ≤ 106, 0 ≤ m ≤ 106), representing the number of trees and the number of directed paths in the Mushroom Forest, respectively.
Each of the following m lines contains three integers x, y and w (1 ≤ x, y ≤ n, 0 ≤ w ≤ 108), denoting a path that leads from tree x to tree y with w mushrooms initially. There can be paths that lead from a tree to itself, and multiple paths between the same pair of trees.
The last line contains a single integer s (1 ≤ s ≤ n) — the starting position of Ralph.
|
Print an integer denoting the maximum number of the mushrooms Ralph can collect during his route.
| null |
In the first sample Ralph can pass three times on the circle and collect 4 + 4 + 3 + 3 + 1 + 1 = 16 mushrooms. After that there will be no mushrooms for Ralph to collect.
In the second sample, Ralph can go to tree 3 and collect 8 mushrooms on the path from tree 1 to tree 3.
|
[{"input": "2 2\n1 2 4\n2 1 4\n1", "output": "16"}, {"input": "3 3\n1 2 4\n2 3 3\n1 3 8\n1", "output": "8"}]
| 2,100 |
["dp", "graphs"]
| 40 |
[{"input": "2 2\r\n1 2 4\r\n2 1 4\r\n1\r\n", "output": "16"}, {"input": "3 3\r\n1 2 4\r\n2 3 3\r\n1 3 8\r\n1\r\n", "output": "8"}, {"input": "1 0\r\n1\r\n", "output": "0"}]
| false |
stdio
| null | true |
961/E
|
961
|
E
|
PyPy 3-64
|
TESTS
| 2 | 46 | 0 |
183342706
|
n = int(input())
a = [int(i) for i in input().split()]
pref = []
now = 0
for i in range(n):
if i + 1 < a[i]:
now += 1
pref.append(now)
print(sum(pref) // 2)
| 30 | 655 | 22,528,000 |
100875670
|
from bisect import bisect_left, bisect_right
n = int(input())
a = list(map(int, input().split()))
ans = 0
#ans = slow_test()
class fenwick():
"""
This Tree Data Structure speeds up caliculating summations of partial sum
and also updating subsets of sequences. Both queries finish in logarithmic times.
"""
# 1-indexed
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
def to_sum(self, i):
# return sigma(a_j) (0<=j<=i)
s = 0
while i > 0:
s += self.data[i]
i -= (i & -i)
return s
def add(self, i, x):
#a_i -> a_i + x
while i <= self.n:
self.data[i] += x
i += (i & -i)
def get(self, i, j):
# return sigma(a_k) (i<=k<=j)
# assert 1<=i<=j<= N
return self.to_sum(j)-self.to_sum(i-1)
Q = fenwick(n + 10)
BIGGER = n + 5
seq = [(a[i], i) for i in range(n)]
A = a.copy()
for i in range(n):
if i < a[i]:
ans -= 1
a.sort()
seq.sort(key=lambda x: x[0])
lindex = 0
for a_r, r in seq:
if a_r > n:
ans += n - bisect_right(a, r)
continue
else:
for i in range(lindex, a_r):
if A[i] <= n:
Q.add(A[i], 1)
else:
Q.add(BIGGER, 1)
ans += Q.get(r+1, BIGGER + 1)
lindex = a_r
ans //= 2
print(ans)
|
Educational Codeforces Round 41 (Rated for Div. 2)
|
ICPC
| 2,018 | 2 | 256 |
Tufurama
|
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
|
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
|
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
| null |
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 $$\text{The formula used to produce the text is not provided in the image.}$$ season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 $$\text{The formula used to produce the text is not provided in the image.}$$ season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 $$\text{The formula used to produce the text is not provided in the image.}$$ season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 $$\text{The formula used to produce the text is not provided in the image.}$$ season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 $$\text{The formula used to produce the text is not provided in the image.}$$ season 3 episode 1).
|
[{"input": "5\n1 2 3 4 5", "output": "0"}, {"input": "3\n8 12 7", "output": "3"}, {"input": "3\n3 2 1", "output": "2"}]
| 1,900 |
["data structures"]
| 30 |
[{"input": "5\r\n1 2 3 4 5\r\n", "output": "0\r\n"}, {"input": "3\r\n8 12 7\r\n", "output": "3\r\n"}, {"input": "3\r\n3 2 1\r\n", "output": "2\r\n"}, {"input": "5\r\n2 3 4 5 6\r\n", "output": "4\r\n"}, {"input": "8\r\n7 2 6 6 5 1 4 9\r\n", "output": "9\r\n"}, {"input": "10\r\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000\r\n", "output": "45\r\n"}, {"input": "1\r\n1\r\n", "output": "0\r\n"}]
| false |
stdio
| null | true |
729/D
|
729
|
D
|
Python 3
|
PRETESTS
| 4 | 61 | 0 |
22357550
|
L, ships_left, len_of_ship, n = map(int, input().split())
S = '1' + input()
lst = [[0, 0]]
counter = 0
for i in range(1,L+1):
if S[i] == '0':
counter += 1
else:
lst[-1][1] = counter//len_of_ship
counter = 0
lst.append([i, 0])
lst[-1][1] = counter//len_of_ship
L=len(lst)
shots = []
for i in range(L):
if lst[i][1]==0:
continue
dif = ships_left - lst[i][1]
shots.append(lst[i][0] + len_of_ship - 1)
if dif>=0:
ships_left = dif
else:
counter=lst[i][0] + len_of_ship - 1
for j in range(-dif-1):
counter+=len_of_ship
shots.append(counter)
ships_left = 0
print(len(shots))
for i in shots:
print(i+1,end=' ')
| 21 | 109 | 17,817,600 |
220882641
|
import sys
def st(): return str(input())
def inp(): return int(sys.stdin.readline())
def strip(): return list(sys.stdin.readline().strip())
def li(): return list(map(int, sys.stdin.readline().split()))
n,a,b,k=li()
s=st()
ans,p,l=[],[],0
for i in range(n):
if int(s[i]): l=0
else: l+=1
if l==b:
ans.append(i)
l=0
end=len(ans)-a+1
for i in range(end):
p.append(ans[i]+1)
print(end)
print(*p)
|
Technocup 2017 - Elimination Round 2
|
CF
| 2,016 | 1 | 256 |
Sea Battle
|
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
|
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
|
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
| null |
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
|
[{"input": "5 1 2 1\n00100", "output": "2\n4 2"}, {"input": "13 3 2 3\n1000000010001", "output": "2\n7 11"}]
| 1,700 |
["constructive algorithms", "greedy", "math"]
| 21 |
[{"input": "5 1 2 1\r\n00100\r\n", "output": "2\r\n2 5 \r\n"}, {"input": "13 3 2 3\r\n1000000010001\r\n", "output": "2\r\n3 5 \r\n"}, {"input": "1 1 1 0\r\n0\r\n", "output": "1\r\n1 \r\n"}, {"input": "2 2 1 0\r\n00\r\n", "output": "1\r\n1 \r\n"}, {"input": "5 4 1 0\r\n00000\r\n", "output": "2\r\n1 2 \r\n"}, {"input": "10 2 2 0\r\n0000000000\r\n", "output": "4\r\n2 4 6 8 \r\n"}, {"input": "20 1 3 5\r\n01001010000000010010\r\n", "output": "2\r\n10 13 \r\n"}, {"input": "100 17 4 11\r\n0100000100000000000000001000000000010001100000000000101000000000000000000000001000001000010000000000\r\n", "output": "2\r\n6 12 \r\n"}]
| false |
stdio
| null | true |
754/C
|
754
|
C
|
Python 3
|
TESTS
| 1 | 124 | 0 |
45444602
|
t = int(input())
SANITIZE_REMOVE = ",.!? "
def sanitize(s):
for ch in SANITIZE_REMOVE:
while s.startswith(ch):
s = s[1:]
while s.endswith(ch):
s = s[:-1]
return s
def solve():
n = int(input())
users = set(input().split())
puser = None
chat = dict()
m = int(input())
msgs = [input() for i in range(m)]
possible_user_dict = dict()
for i, msg_nspl in enumerate(msgs):
user, msg = msg_nspl.split(":")
if user == "?":
possible_users = set(users)
possible_users.discard(puser)
for discarded_user in map(sanitize, msg.split()):
possible_users.discard(discarded_user)
if len(possible_users) > 0:
possible_user_dict[i] = possible_users
else:
print("Impossible")
return
puser = user
else:
chat[i] = user
#print(possible_user_dict)
for key in possible_user_dict:
prev_u = possible_user_dict.get(key - 1)
current = possible_user_dict[key]
if prev_u is not None:
current.difference_update(prev_u)
possible_user_dict[key] = current
if len(current) > 0:
chat[key] = list(current)[0]
else:
print("Impossible")
return
for i, m in enumerate(msgs):
print(f"{chat[i]}:{m.split(':')[1]}")
for i in range(t):
solve()
| 104 | 1,154 | 5,017,600 |
23606122
|
def dfs(ind):
if ind > 0:
if possible[ind][0] in possible[ind - 1]:
possible[ind - 1].remove(possible[ind][0])
if len(possible[ind - 1]) == 1:
dfs(ind - 1)
if ind < m - 1:
if possible[ind][0] in possible[ind + 1]:
possible[ind + 1].remove(possible[ind][0])
if len(possible[ind + 1]) == 1:
dfs(ind + 1)
def Check(st, ms):
for i in range(0, len(ms) - len(st) + 1):
if st == ms[i:i+len(st)]:
t = True
if i > 0:
if ms[i - 1] == ' ' or ms[i - 1] == '.' or ms[i - 1] == ',' or ms[i - 1] == '?' or ms[i - 1] == '!':
e = 0
else:
t = False
if i < len(ms) - len(st):
if (ms[i + len(st)] == ' ' or ms[i + len(st)] == '.' or ms[i + len(st)] == ',' or ms[i + len(st)] == '?' or ms[i + len(st)] == '!'):
e = 0
else:
t = False
if t:
return True
return False
R = lambda:list(map(int, input().split(' ')))
#r, w = open("input.txt", "r"), open("output.txt", "w")
T = int(input())
while T:
n = int(input())
users = input().split(' ')
m = int(input())
possible = [[] for i in range(m)]
sender, message = [], []
for i in range(m):
s = input().split(':')
sender.append(s[0])
message.append(s[1])
for i in range(m):
if sender[i] == '?':
unallow = " "
if i > 0 and len(possible[i - 1]) == 1:
unallow = possible[i - 1][0]
for j in users:
if j == unallow:
continue
done = Check(j, message[i])
if not done:
possible[i].append(j)
else:
possible[i].append(sender[i])
used = [0 for i in range(m)]
for i in range(m):
if len(possible[i]) == 1 and used[i] == 0:
dfs(i)
for i in range(m):
if len(possible[i]) > 1:
possible[i] = [possible[i][0]]
dfs(i)
done = False
for i in possible:
if len(i) == 0:
print("Impossible")
done = True
break
if not done:
for i in range(m):
print(possible[i][0]+':'+message[i])
T -= 1
|
Codeforces Round 390 (Div. 2)
|
CF
| 2,017 | 2 | 256 |
Vladik and chat
|
Recently Vladik discovered a new entertainment — coding bots for social networks. He would like to use machine learning in his bots so now he want to prepare some learning data for them.
At first, he need to download t chats. Vladik coded a script which should have downloaded the chats, however, something went wrong. In particular, some of the messages have no information of their sender. It is known that if a person sends several messages in a row, they all are merged into a single message. It means that there could not be two or more messages in a row with the same sender. Moreover, a sender never mention himself in his messages.
Vladik wants to recover senders of all the messages so that each two neighboring messages will have different senders and no sender will mention himself in his messages.
He has no idea of how to do this, and asks you for help. Help Vladik to recover senders in each of the chats!
|
The first line contains single integer t (1 ≤ t ≤ 10) — the number of chats. The t chats follow. Each chat is given in the following format.
The first line of each chat description contains single integer n (1 ≤ n ≤ 100) — the number of users in the chat.
The next line contains n space-separated distinct usernames. Each username consists of lowercase and uppercase English letters and digits. The usernames can't start with a digit. Two usernames are different even if they differ only with letters' case. The length of username is positive and doesn't exceed 10 characters.
The next line contains single integer m (1 ≤ m ≤ 100) — the number of messages in the chat. The next m line contain the messages in the following formats, one per line:
- <username>:<text> — the format of a message with known sender. The username should appear in the list of usernames of the chat.
- <?>:<text> — the format of a message with unknown sender.
The text of a message can consist of lowercase and uppercase English letter, digits, characters '.' (dot), ',' (comma), '!' (exclamation mark), '?' (question mark) and ' ' (space). The text doesn't contain trailing spaces. The length of the text is positive and doesn't exceed 100 characters.
We say that a text mention a user if his username appears in the text as a word. In other words, the username appears in a such a position that the two characters before and after its appearance either do not exist or are not English letters or digits. For example, the text "Vasya, masha13 and Kate!" can mention users "Vasya", "masha13", "and" and "Kate", but not "masha".
It is guaranteed that in each chat no known sender mention himself in his messages and there are no two neighboring messages with the same known sender.
|
Print the information about the t chats in the following format:
If it is not possible to recover senders, print single line "Impossible" for this chat. Otherwise print m messages in the following format:
<username>:<text>
If there are multiple answers, print any of them.
| null | null |
[{"input": "1\n2\nVladik netman\n2\n?: Hello, Vladik!\n?: Hi", "output": "netman: Hello, Vladik!\nVladik: Hi"}, {"input": "1\n2\nnetman vladik\n3\nnetman:how are you?\n?:wrong message\nvladik:im fine", "output": "Impossible"}, {"input": "2\n3\nnetman vladik Fedosik\n2\n?: users are netman, vladik, Fedosik\nvladik: something wrong with this chat\n4\nnetman tigerrrrr banany2001 klinchuh\n4\n?: tigerrrrr, banany2001, klinchuh, my favourite team ever, are you ready?\nklinchuh: yes, coach!\n?: yes, netman\nbanany2001: yes of course.", "output": "Impossible\nnetman: tigerrrrr, banany2001, klinchuh, my favourite team ever, are you ready?\nklinchuh: yes, coach!\ntigerrrrr: yes, netman\nbanany2001: yes of course."}]
| 2,200 |
["brute force", "constructive algorithms", "dp", "implementation", "strings"]
| 104 |
[{"input": "1\r\n2\r\nVladik netman\r\n2\r\n?: Hello, Vladik!\r\n?: Hi\r\n", "output": "netman: Hello, Vladik!\r\nVladik: Hi\r\n"}, {"input": "1\r\n2\r\nnetman vladik\r\n3\r\nnetman:how are you?\r\n?:wrong message\r\nvladik:im fine\r\n", "output": "Impossible\r\n"}, {"input": "2\r\n3\r\nnetman vladik Fedosik\r\n2\r\n?: users are netman, vladik, Fedosik\r\nvladik: something wrong with this chat\r\n4\r\nnetman tigerrrrr banany2001 klinchuh\r\n4\r\n?: tigerrrrr, banany2001, klinchuh, my favourite team ever, are you ready?\r\nklinchuh: yes, coach!\r\n?: yes, netman\r\nbanany2001: yes of course.\r\n", "output": "Impossible\r\nnetman: tigerrrrr, banany2001, klinchuh, my favourite team ever, are you ready?\r\nklinchuh: yes, coach!\r\ntigerrrrr: yes, netman\r\nbanany2001: yes of course.\r\n"}, {"input": "1\r\n1\r\nb\r\n1\r\nb:lala!\r\n", "output": "b:lala!\r\n"}, {"input": "1\r\n1\r\nb\r\n1\r\n?:lala b!\r\n", "output": "Impossible\r\n"}, {"input": "1\r\n1\r\nb\r\n2\r\n?:lala hhe!\r\nb:wat?\r\n", "output": "Impossible\r\n"}, {"input": "1\r\n3\r\nA B C\r\n3\r\nA: HI\r\n?: HI\r\nB: HI\r\n", "output": "A: HI\r\nC: HI\r\nB: HI\r\n"}]
| false |
stdio
| null | true |
729/D
|
729
|
D
|
Python 3
|
TESTS
| 1 | 30 | 0 |
171026277
|
import sys
input=sys.stdin.readline
if __name__=='__main__':
n,a,b,k=map(int,input().split())
s=input()
p=0
res=[]
for i in range(n):
if s[i]=='1':
p=0
else:
p+=1
if p==b:
res.append(i+1)
p=0
print(len(res)-a+1)
print(*res[-a-1:])
| 21 | 124 | 19,148,800 |
197320020
|
# ﷽
from collections import deque
import sys
input = lambda: sys.stdin.readline().strip()
mod=7+10**9
def solve():
n,a,b,k=[int(i) for i in input().split()]
s=input()
i=0
d=deque()
tot=0
while i<n:
while i<n and s[i]!='0':i+=1
if "".join(s[i:i+b])!='0'*b:
j=i
while j<n and s[j]=='0':j+=1
i=j+1
else:
tot+=1
i+=b
d.append(i)
print( tot-a+1)
d=list(d)
print(*d[:tot-a+1])
if __name__ == "__main__":
# for i in range(int(input())):
solve()
|
Technocup 2017 - Elimination Round 2
|
CF
| 2,016 | 1 | 256 |
Sea Battle
|
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
|
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
|
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
| null |
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
|
[{"input": "5 1 2 1\n00100", "output": "2\n4 2"}, {"input": "13 3 2 3\n1000000010001", "output": "2\n7 11"}]
| 1,700 |
["constructive algorithms", "greedy", "math"]
| 21 |
[{"input": "5 1 2 1\r\n00100\r\n", "output": "2\r\n2 5 \r\n"}, {"input": "13 3 2 3\r\n1000000010001\r\n", "output": "2\r\n3 5 \r\n"}, {"input": "1 1 1 0\r\n0\r\n", "output": "1\r\n1 \r\n"}, {"input": "2 2 1 0\r\n00\r\n", "output": "1\r\n1 \r\n"}, {"input": "5 4 1 0\r\n00000\r\n", "output": "2\r\n1 2 \r\n"}, {"input": "10 2 2 0\r\n0000000000\r\n", "output": "4\r\n2 4 6 8 \r\n"}, {"input": "20 1 3 5\r\n01001010000000010010\r\n", "output": "2\r\n10 13 \r\n"}, {"input": "100 17 4 11\r\n0100000100000000000000001000000000010001100000000000101000000000000000000000001000001000010000000000\r\n", "output": "2\r\n6 12 \r\n"}]
| false |
stdio
| null | true |
1007/B
|
1007
|
B
|
Python 3
|
TESTS
| 3 | 155 | 409,600 |
44399559
|
import sys
import math
from functools import reduce
def factors(n):
seta=set(reduce(list.__add__,
([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
return sorted(list(seta))
n=int(input())
for _ in range(n):
lisa = []
a,b,c=map(int,input().strip().split())
fa,fb,fc=factors(a),factors(b),factors(c)
#print(fa,fb,fc)
x,y,z=0,0,0
for i in range(len(fa)):
stra=[]
x=str(fa[i])
stra.append(x)
for j in range(len(fb)):
#print("Printing y values y=",fb[j])
y=str(fb[j])
stra.append(y)
for k in range(len(fc)):
z=str(fc[k])
stra.append(z)
cv=''.join(sorted(stra))
lisa.append(cv)
stra.pop()
stra.pop()
stra.pop()
meta=set(lisa)
#print(lisa)
#print(meta)
print(len(meta))
| 28 | 998 | 8,396,800 |
40311323
|
from sys import stdin
from math import gcd
def main():
input()
l = stdin.read().splitlines()
d = [3, 1, 2, 2, 2, 1] * 16667
for i in range(4, 100001):
for j in range(i, 100001, i):
d[j] += 1
for i, s in enumerate(l):
a, b, c = map(int, s.split())
k = gcd(b, c)
ab = d[gcd(a, b)]
ac = d[gcd(a, c)]
bc = d[k]
abc = d[gcd(a, k)]
asz = d[a] - ab - ac + abc
bsz = d[b] - bc - ab + abc
csz = d[c] - ac - bc + abc
absz = ab - abc
bcsz = bc - abc
acsz = ac - abc
abcsz = abc
l[i] = (asz * bsz * csz +
(absz * (asz + bsz) * csz) +
(bcsz * (bsz + csz) * asz) +
(acsz * (asz + csz) * bsz) +
(abcsz * (asz * bsz + asz * csz + bsz * csz)) +
(abcsz * (absz + bcsz + acsz) * (asz + bsz + csz)) +
((asz + bsz + csz + absz + bcsz + acsz) * (abcsz * (abcsz + 1) // 2)) +
(absz * bcsz * acsz) +
((absz * (absz + 1) * d[c]) +
(bcsz * (bcsz + 1) * d[a]) +
(acsz * (acsz + 1) * d[b])) // 2 +
((asz + bsz + csz + abcsz) * (absz * acsz + absz * bcsz + bcsz * acsz)) +
(abcsz + (abcsz * (abcsz - 1)) + (abcsz * (abcsz - 1) * (abcsz - 2) // 6)))
print('\n'.join(map(str, l)))
if __name__ == '__main__':
main()
|
Codeforces Round 497 (Div. 1)
|
CF
| 2,018 | 2 | 256 |
Pave the Parallelepiped
|
You are given a rectangular parallelepiped with sides of positive integer lengths $$$A$$$, $$$B$$$ and $$$C$$$.
Find the number of different groups of three integers ($$$a$$$, $$$b$$$, $$$c$$$) such that $$$1\leq a\leq b\leq c$$$ and parallelepiped $$$A\times B\times C$$$ can be paved with parallelepipeds $$$a\times b\times c$$$. Note, that all small parallelepipeds have to be rotated in the same direction.
For example, parallelepiped $$$1\times 5\times 6$$$ can be divided into parallelepipeds $$$1\times 3\times 5$$$, but can not be divided into parallelepipeds $$$1\times 2\times 3$$$.
|
The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^5$$$) — the number of test cases.
Each of the next $$$t$$$ lines contains three integers $$$A$$$, $$$B$$$ and $$$C$$$ ($$$1 \leq A, B, C \leq 10^5$$$) — the sizes of the parallelepiped.
|
For each test case, print the number of different groups of three points that satisfy all given conditions.
| null |
In the first test case, rectangular parallelepiped $$$(1, 1, 1)$$$ can be only divided into rectangular parallelepiped with sizes $$$(1, 1, 1)$$$.
In the second test case, rectangular parallelepiped $$$(1, 6, 1)$$$ can be divided into rectangular parallelepipeds with sizes $$$(1, 1, 1)$$$, $$$(1, 1, 2)$$$, $$$(1, 1, 3)$$$ and $$$(1, 1, 6)$$$.
In the third test case, rectangular parallelepiped $$$(2, 2, 2)$$$ can be divided into rectangular parallelepipeds with sizes $$$(1, 1, 1)$$$, $$$(1, 1, 2)$$$, $$$(1, 2, 2)$$$ and $$$(2, 2, 2)$$$.
|
[{"input": "4\n1 1 1\n1 6 1\n2 2 2\n100 100 100", "output": "1\n4\n4\n165"}]
| 2,400 |
["bitmasks", "brute force", "combinatorics", "math", "number theory"]
| 28 |
[{"input": "4\r\n1 1 1\r\n1 6 1\r\n2 2 2\r\n100 100 100\r\n", "output": "1\r\n4\r\n4\r\n165\r\n"}, {"input": "10\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n", "output": "1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n"}, {"input": "10\r\n9 6 8\r\n5 5 2\r\n8 9 2\r\n2 7 9\r\n6 4 10\r\n1 1 8\r\n2 8 1\r\n10 6 3\r\n7 5 2\r\n9 5 4\r\n", "output": "41\r\n6\r\n21\r\n12\r\n39\r\n4\r\n7\r\n26\r\n8\r\n18\r\n"}, {"input": "1\r\n100000 100000 100000\r\n", "output": "8436\r\n"}]
| false |
stdio
| null | true |
962/E
|
962
|
E
|
Python 3
|
TESTS
| 10 | 421 | 0 |
179002342
|
N = int(input())
lastR = None
lastB = None
hasP = False
sum = 0
for i in range(N):
x, c = input().split()
x = int(x)
if c == 'R':
if lastR is not None:
sum += x - lastR
lastR = x
elif c == 'B':
if lastB is not None:
sum += x - lastB
lastB = x
elif c == 'P':
if not hasP:
if lastR is not None:
sum += x - lastR
if lastB is not None:
sum += x - lastB
else:
sum += x - max(lastR, lastB)
lastB = x
lastR = x
hasP = True
print(sum)
| 45 | 405 | 13,516,800 |
94132083
|
import sys
n = int(sys.stdin.buffer.readline().decode('utf-8'))
pos, type_ = [0]*n, ['']*n
for i, (x, c) in enumerate(line.decode('utf-8').split() for line in sys.stdin.buffer):
pos[i] = int(x)
type_[i] = c
r_cnt = type_.count('R')
b_cnt = type_.count('B')
p_cnt = n - r_cnt - b_cnt
inf = 2100000000
if p_cnt == 0:
r_min, r_max = inf, inf
b_min, b_max = inf, inf
for i in range(n):
if type_[i] == 'R':
r_min = min(pos[i], r_min)
r_max = pos[i]
else:
b_min = min(pos[i], b_min)
b_max = pos[i]
print(r_max - r_min + b_max - b_min)
exit()
p_index = [i for i in range(n) if type_[i] == 'P']
ans = 0
for c in 'RB':
for i in range(p_index[0]):
if type_[i] == c:
ans += pos[p_index[0]] - pos[i]
break
for i in range(n-1, p_index[-1], -1):
if type_[i] == c:
ans += pos[i] - pos[p_index[-1]]
break
for i, j in zip(p_index, p_index[1:]):
r, b = [], []
r_prev = b_prev = pos[i]
for k in range(i+1, j):
if type_[k] == 'R':
r.append(pos[k] - r_prev)
r_prev = pos[k]
else:
b.append(pos[k] - b_prev)
b_prev = pos[k]
r.append(pos[j] - r_prev)
b.append(pos[j] - b_prev)
r.sort()
b.sort()
ans += min(
pos[j]-pos[i] + sum(r) - r[-1] + sum(b) - b[-1],
sum(r) + sum(b)
)
print(ans)
|
Educational Codeforces Round 42 (Rated for Div. 2)
|
ICPC
| 2,018 | 2 | 256 |
Byteland, Berland and Disputed Cities
|
The cities of Byteland and Berland are located on the axis $$$Ox$$$. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line $$$Ox$$$ there are three types of cities:
- the cities of Byteland,
- the cities of Berland,
- disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
- If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
- If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line $$$Ox$$$. It is technically possible to connect the cities $$$a$$$ and $$$b$$$ with a cable so that the city $$$c$$$ ($$$a < c < b$$$) is not connected to this cable, where $$$a$$$, $$$b$$$ and $$$c$$$ are simultaneously coordinates of the cities $$$a$$$, $$$b$$$ and $$$c$$$.
|
The first line contains a single integer $$$n$$$ ($$$2 \le n \le 2 \cdot 10^{5}$$$) — the number of cities.
The following $$$n$$$ lines contains an integer $$$x_i$$$ and the letter $$$c_i$$$ ($$$-10^{9} \le x_i \le 10^{9}$$$) — the coordinate of the city and its type. If the city belongs to Byteland, $$$c_i$$$ equals to 'B'. If the city belongs to Berland, $$$c_i$$$ equals to «R». If the city is disputed, $$$c_i$$$ equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
|
Print the minimal total length of such set of cables, that if we delete all Berland cities ($$$c_i$$$='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities ($$$c_i$$$='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
| null |
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be $$$5 + 3 + 4 = 12$$$.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates $$$10, 21, 32$$$, so to connect them you need two cables of length $$$11$$$ and $$$11$$$. The cities of Byteland have coordinates $$$14$$$ and $$$16$$$, so to connect them you need one cable of length $$$2$$$. Thus, the total length of all cables is $$$11 + 11 + 2 = 24$$$.
|
[{"input": "4\n-5 R\n0 P\n3 P\n7 B", "output": "12"}, {"input": "5\n10 R\n14 B\n16 B\n21 R\n32 R", "output": "24"}]
| 2,200 |
["constructive algorithms", "greedy"]
| 45 |
[{"input": "4\r\n-5 R\r\n0 P\r\n3 P\r\n7 B\r\n", "output": "12\r\n"}, {"input": "5\r\n10 R\r\n14 B\r\n16 B\r\n21 R\r\n32 R\r\n", "output": "24\r\n"}, {"input": "10\r\n66 R\r\n67 R\r\n72 R\r\n73 R\r\n76 R\r\n78 B\r\n79 B\r\n83 B\r\n84 B\r\n85 P\r\n", "output": "26\r\n"}, {"input": "10\r\n61 R\r\n64 R\r\n68 R\r\n71 R\r\n72 R\r\n73 R\r\n74 P\r\n86 P\r\n87 B\r\n90 B\r\n", "output": "29\r\n"}, {"input": "15\r\n-9518 R\r\n-6858 P\r\n-6726 B\r\n-6486 R\r\n-4496 P\r\n-4191 P\r\n-772 B\r\n-258 R\r\n-194 P\r\n1035 R\r\n2297 P\r\n4816 B\r\n5779 R\r\n9342 B\r\n9713 B\r\n", "output": "25088\r\n"}, {"input": "6\r\n-8401 R\r\n-5558 P\r\n-3457 P\r\n-2361 R\r\n6966 P\r\n8140 B\r\n", "output": "17637\r\n"}, {"input": "2\r\n1 R\r\n2 R\r\n", "output": "1\r\n"}, {"input": "2\r\n-1000000000 B\r\n1000000000 R\r\n", "output": "0\r\n"}, {"input": "2\r\n-1000000000 P\r\n1000000000 P\r\n", "output": "2000000000\r\n"}, {"input": "2\r\n-1000000000 B\r\n1000000000 P\r\n", "output": "2000000000\r\n"}, {"input": "9\r\n-105 R\r\n-81 B\r\n-47 P\r\n-25 R\r\n-23 B\r\n55 P\r\n57 R\r\n67 B\r\n76 P\r\n", "output": "272\r\n"}, {"input": "6\r\n-13 R\r\n-10 P\r\n-6 R\r\n-1 P\r\n4 R\r\n10 P\r\n", "output": "32\r\n"}, {"input": "8\r\n-839 P\r\n-820 P\r\n-488 P\r\n-334 R\r\n-83 B\r\n187 R\r\n380 B\r\n804 P\r\n", "output": "2935\r\n"}, {"input": "8\r\n-12 P\r\n-9 B\r\n-2 R\r\n-1 R\r\n2 B\r\n8 B\r\n9 R\r\n15 P\r\n", "output": "54\r\n"}, {"input": "6\r\n0 B\r\n3 P\r\n7 B\r\n9 B\r\n11 P\r\n13 B\r\n", "output": "17\r\n"}]
| false |
stdio
| null | true |
995/D
|
995
|
D
|
Python 3
|
TESTS
| 3 | 1,029 | 31,539,200 |
39730519
|
from sys import stdin
def main():
n, m = map(int, input().split())
ff = list(map(float, input().split()))
scale, r = .5 ** n, sum(ff)
res = [r * scale]
for s in stdin.read().splitlines():
i, f = map(int, s.split())
r += f - ff[i]
res.append(r * scale)
print('\n'.join(map(str, res)))
if __name__ == '__main__':
main()
| 53 | 1,746 | 31,641,600 |
39623059
|
n, r = [int(x) for x in input().split()]
n = 2 ** n
xs = [int(x) for x in input().split()]
s = sum(xs)
res = [0 for _ in range(r+1)]
for i in range(r):
res[i] = s / n
i, val = [int(x) for x in input().split()]
s += val - xs[i]
xs[i] = val
res[r] = s / n
print("\n".join(map(str, res)))
|
Codeforces Round 492 (Div. 1) [Thanks, uDebug!]
|
CF
| 2,018 | 3 | 256 |
Game
|
Allen and Bessie are playing a simple number game. They both know a function $$$f: \{0, 1\}^n \to \mathbb{R}$$$, i. e. the function takes $$$n$$$ binary arguments and returns a real value. At the start of the game, the variables $$$x_1, x_2, \dots, x_n$$$ are all set to $$$-1$$$. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an $$$i$$$ such that $$$x_i = -1$$$ and either setting $$$x_i \to 0$$$ or $$$x_i \to 1$$$.
After $$$n$$$ rounds all variables are set, and the game value resolves to $$$f(x_1, x_2, \dots, x_n)$$$. Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play $$$r+1$$$ times though, so between each game, exactly one value of $$$f$$$ changes. In other words, between rounds $$$i$$$ and $$$i+1$$$ for $$$1 \le i \le r$$$, $$$f(z_1, \dots, z_n) \to g_i$$$ for some $$$(z_1, \dots, z_n) \in \{0, 1\}^n$$$. You are to find the expected game value in the beginning and after each change.
|
The first line contains two integers $$$n$$$ and $$$r$$$ ($$$1 \le n \le 18$$$, $$$0 \le r \le 2^{18}$$$).
The next line contains $$$2^n$$$ integers $$$c_0, c_1, \dots, c_{2^n-1}$$$ ($$$0 \le c_i \le 10^9$$$), denoting the initial values of $$$f$$$. More specifically, $$$f(x_0, x_1, \dots, x_{n-1}) = c_x$$$, if $$$x = \overline{x_{n-1} \ldots x_0}$$$ in binary.
Each of the next $$$r$$$ lines contains two integers $$$z$$$ and $$$g$$$ ($$$0 \le z \le 2^n - 1$$$, $$$0 \le g \le 10^9$$$). If $$$z = \overline{z_{n-1} \dots z_0}$$$ in binary, then this means to set $$$f(z_0, \dots, z_{n-1}) \to g$$$.
|
Print $$$r+1$$$ lines, the $$$i$$$-th of which denotes the value of the game $$$f$$$ during the $$$i$$$-th round. Your answer must have absolute or relative error within $$$10^{-6}$$$.
Formally, let your answer be $$$a$$$, and the jury's answer be $$$b$$$. Your answer is considered correct if $$$\frac{|a - b|}{\max{(1, |b|)}} \le 10^{-6}$$$.
| null |
Consider the second test case. If Allen goes first, he will set $$$x_1 \to 1$$$, so the final value will be $$$3$$$. If Bessie goes first, then she will set $$$x_1 \to 0$$$ so the final value will be $$$2$$$. Thus the answer is $$$2.5$$$.
In the third test case, the game value will always be $$$1$$$ regardless of Allen and Bessie's play.
|
[{"input": "2 2\n0 1 2 3\n2 5\n0 4", "output": "1.500000\n2.250000\n3.250000"}, {"input": "1 0\n2 3", "output": "2.500000"}, {"input": "2 0\n1 1 1 1", "output": "1.000000"}]
| 2,500 |
["math"]
| 53 |
[{"input": "2 2\r\n0 1 2 3\r\n2 5\r\n0 4\r\n", "output": "1.500000\r\n2.250000\r\n3.250000\r\n"}, {"input": "1 0\r\n2 3\r\n", "output": "2.500000\r\n"}, {"input": "2 0\r\n1 1 1 1\r\n", "output": "1.000000\r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(input_path) as f:
n, r = map(int, f.readline().split())
expected_lines = r + 1
with open(output_path) as f:
correct = [float(line.strip()) for line in f]
if len(correct) != expected_lines:
print(0)
return
with open(submission_path) as f:
submission = [line.strip() for line in f]
if len(submission) != expected_lines:
print(0)
return
for a_str, b in zip(submission, correct):
try:
a = float(a_str)
except:
print(0)
return
max_denominator = max(1.0, abs(b))
if abs(a - b) > 1e-6 * max_denominator:
print(0)
return
print(1)
if __name__ == "__main__":
main()
| true |
729/D
|
729
|
D
|
Python 3
|
PRETESTS
| 1 | 46 | 0 |
22360158
|
n,a,b,k = map(int,input().split())
s= input()
i=0
kol=0
qor=0
for i in range(n):
if s[i]=='0':
kol+=1
if s[i]=='1':
qor+= kol//b
kol=0
qor+=kol//b
print(qor-a+1)
kn=0
e=0
i=0
q1=1
while i<(qor-a+1):
if s[e]=='0':
kn+=1
e+=1
if kn>=b:
print((kn+2*q1)//2, end = ' ')
e+=1
q1=(kn+2*q1)//2+1
i+=1
kn=0
continue
if s[e]=='1':
q1=e+1
kn=0
e+=1
| 21 | 155 | 17,510,400 |
199341648
|
import math
from sys import stdin
input = lambda: stdin.readline()[:-1]
def solve():
n, a, b, k = map(int, input().split())
st = input()
seg = []
dx = [i for i in range(n) if st[i] == '1']
dx = [-1] + dx
dx.append(n)
dif = []
for i in range(len(dx) - 1):
if dx[i + 1] - dx[i] > 1:
seg.append([dx[i] + 1, dx[i + 1] - 1])
for i in range(len(dx) - 1):
dif.append(dx[i + 1] - dx[i] - 1)
ans = 0
for i in dif:
ans += i // b
ans -= a - 1
print(ans)
r = 0
while r < ans:
for i in seg:
if i[1] - i[0] + 1 >= b:
for j in range(i[1] - b + 1, i[0] - 1, -b):
print(j + 1, end=" ")
r += 1
if r == ans:
return
solve()
|
Technocup 2017 - Elimination Round 2
|
CF
| 2,016 | 1 | 256 |
Sea Battle
|
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
|
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
|
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
| null |
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
|
[{"input": "5 1 2 1\n00100", "output": "2\n4 2"}, {"input": "13 3 2 3\n1000000010001", "output": "2\n7 11"}]
| 1,700 |
["constructive algorithms", "greedy", "math"]
| 21 |
[{"input": "5 1 2 1\r\n00100\r\n", "output": "2\r\n2 5 \r\n"}, {"input": "13 3 2 3\r\n1000000010001\r\n", "output": "2\r\n3 5 \r\n"}, {"input": "1 1 1 0\r\n0\r\n", "output": "1\r\n1 \r\n"}, {"input": "2 2 1 0\r\n00\r\n", "output": "1\r\n1 \r\n"}, {"input": "5 4 1 0\r\n00000\r\n", "output": "2\r\n1 2 \r\n"}, {"input": "10 2 2 0\r\n0000000000\r\n", "output": "4\r\n2 4 6 8 \r\n"}, {"input": "20 1 3 5\r\n01001010000000010010\r\n", "output": "2\r\n10 13 \r\n"}, {"input": "100 17 4 11\r\n0100000100000000000000001000000000010001100000000000101000000000000000000000001000001000010000000000\r\n", "output": "2\r\n6 12 \r\n"}]
| false |
stdio
| null | true |
400/A
|
400
|
A
|
Python 3
|
TESTS
| 6 | 109 | 307,200 |
99605756
|
t = int(input())
for i in range(t):
s = input()
lst = []
if 'X' in s:
lst.append('1x12')
for i in range(6):
if s[i]==s[i+6]=='X':
lst.append('2x6')
break
for i in range(4):
if s[i]==s[i+4]==s[i+8]=='X':
lst.append('3x4')
break
for i in range(3):
if s[i]==s[i+3]==s[i+6]==s[i+9]=='X':
lst.append('4x3')
break
for i in range(2):
if s[i]==s[i+2]==s[i+4]==s[i+6]==s[i+8]=='X':
lst.append('6x2')
break
if 'O' not in s:
lst.append('12x1')
print(len(lst),*lst)
| 44 | 62 | 0 |
5934069
|
#!/usr/bin/env python3
def read_ints():
return map(int, input().strip().split())
t, = read_ints()
for _ in range(t):
x = input()
correct = []
for a in [1, 2, 3, 4, 6, 12]:
cor = False
for c in range(0, 12//a):
s = set(x[c::12//a])
if len(s)==1 and 'X' in s:
cor = True
break
if cor == True:
correct.append("{}x{}".format(a, 12//a))
print(len(correct), ' '.join(correct))
|
Codeforces Round 234 (Div. 2)
|
CF
| 2,014 | 1 | 256 |
Inna and Choose Options
|
There always is something to choose from! And now, instead of "Noughts and Crosses", Inna choose a very unusual upgrade of this game. The rules of the game are given below:
There is one person playing the game. Before the beginning of the game he puts 12 cards in a row on the table. Each card contains a character: "X" or "O". Then the player chooses two positive integers a and b (a·b = 12), after that he makes a table of size a × b from the cards he put on the table as follows: the first b cards form the first row of the table, the second b cards form the second row of the table and so on, the last b cards form the last (number a) row of the table. The player wins if some column of the table contain characters "X" on all cards. Otherwise, the player loses.
Inna has already put 12 cards on the table in a row. But unfortunately, she doesn't know what numbers a and b to choose. Help her win the game: print to her all the possible ways of numbers a, b that she can choose and win.
|
The first line of the input contains integer t (1 ≤ t ≤ 100). This value shows the number of sets of test data in the input. Next follows the description of each of the t tests on a separate line.
The description of each test is a string consisting of 12 characters, each character is either "X", or "O". The i-th character of the string shows the character that is written on the i-th card from the start.
|
For each test, print the answer to the test on a single line. The first number in the line must represent the number of distinct ways to choose the pair a, b. Next, print on this line the pairs in the format axb. Print the pairs in the order of increasing first parameter (a). Separate the pairs in the line by whitespaces.
| null | null |
[{"input": "4\nOXXXOXOOXOOX\nOXOXOXOXOXOX\nXXXXXXXXXXXX\nOOOOOOOOOOOO", "output": "3 1x12 2x6 4x3\n4 1x12 2x6 3x4 6x2\n6 1x12 2x6 3x4 4x3 6x2 12x1\n0"}]
| 1,000 |
["implementation"]
| 44 |
[{"input": "4\r\nOXXXOXOOXOOX\r\nOXOXOXOXOXOX\r\nXXXXXXXXXXXX\r\nOOOOOOOOOOOO\r\n", "output": "3 1x12 2x6 4x3\r\n4 1x12 2x6 3x4 6x2\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n0\r\n"}, {"input": "2\r\nOOOOOOOOOOOO\r\nXXXXXXXXXXXX\r\n", "output": "0\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n"}, {"input": "13\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\n", "output": "6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n"}]
| false |
stdio
| null | true |
1007/B
|
1007
|
B
|
Python 3
|
PRETESTS
| 2 | 108 | 1,126,400 |
40282760
|
cache = [0 for i in range(10**5 + 10)]
def gcd(a, b):
if a > b:
return gcd(b, a)
elif a == 0:
return b
elif a == 1:
return a
else:
return gcd(b % a, a)
def cd(x):
if cache[x] > 0:
return cache[x]
d = 2
res = 1
while d**2 <= x:
cur = 0
while x % d == 0:
cur += 1
x //= d
res *= (cur + 1)
d += 1
if x > 1:
res *= 2
cache[x] = res
return res
def solve(a, b, c):
return 0
t = int(input())
for tt in range(t):
a, b, c = list(map(int, input().split()))
dabc = cd(gcd(a, gcd(b, c)))
dab = cd(gcd(a, b)) - dabc
dac = cd(gcd(a, c)) - dabc
dbc = cd(gcd(b, c)) - dabc
da = cd(a) - dab - dac - dabc
db = cd(b) - dab - dbc - dabc
dc = cd(c) - dac - dbc - dabc
dab = cd(gcd(a, b))
dac = cd(gcd(a, c))
dbc = cd(gcd(b, c))
# print(da, db, dc, dab, dbc, dac, dabc)
r1 = da * ((db + dab - dabc) * (dc + dac + dbc - dabc) +
(dbc - dabc) * (dc + dac) +
(dbc - dabc) * (dbc - dabc + 1) * 1./2. +
dabc * (dc + dac + dbc - dabc) +
dabc * (dabc + 1) * 1./2. )
r2 = (dab - dabc) * (db * (dc + dac + dbc - dabc) +
(dab - dabc + 1) * (dc + dac + dbc - dabc) * 1./2. +
(dbc - dabc) * (dc + dac) +
(dbc - dabc) * (dbc - dabc + 1) * 1./2. +
dabc * (dc + dac + dbc - dabc) +
dabc * (dabc + 1) * 1./2. )
r3 = (dac - dabc) * ((db + dab - dabc) * (dc + dbc) +
(db + dab - dabc) * (dac - dabc + 1) * 1./2. +
(dbc - dabc) * (dabc + dc) +
(dbc - dabc) * (dac - dabc + 1) * 1./2. +
(dbc - dabc) * (dbc - dabc + 1) * 1./2. +
dabc * (dc + dbc - dabc) +
dabc * (dabc + 1) * 1./2. +
dabc * (dac - dabc) * 1./2. )
r4 = dabc * ((db + dab - dabc) * (dc + dac - dabc + dbc - dabc) +
(db + dab - dabc) * (dabc + 1) * 1./2. +
(dabc + 1) * 1./2. * (dc + dac - dabc + dbc - dabc) +
(dbc - dabc) * (dc + dac - dabc) +
(dbc - dabc) * (dbc - dabc + 1) * 1./2. +
(dbc - dabc) * (dabc + 1) * 1./2. )
r5 = dabc * (dabc + 1) * (dabc + 2) // 6
print(round(r1 + r2 + r3 + r4 + r5))
| 28 | 998 | 8,396,800 |
40311323
|
from sys import stdin
from math import gcd
def main():
input()
l = stdin.read().splitlines()
d = [3, 1, 2, 2, 2, 1] * 16667
for i in range(4, 100001):
for j in range(i, 100001, i):
d[j] += 1
for i, s in enumerate(l):
a, b, c = map(int, s.split())
k = gcd(b, c)
ab = d[gcd(a, b)]
ac = d[gcd(a, c)]
bc = d[k]
abc = d[gcd(a, k)]
asz = d[a] - ab - ac + abc
bsz = d[b] - bc - ab + abc
csz = d[c] - ac - bc + abc
absz = ab - abc
bcsz = bc - abc
acsz = ac - abc
abcsz = abc
l[i] = (asz * bsz * csz +
(absz * (asz + bsz) * csz) +
(bcsz * (bsz + csz) * asz) +
(acsz * (asz + csz) * bsz) +
(abcsz * (asz * bsz + asz * csz + bsz * csz)) +
(abcsz * (absz + bcsz + acsz) * (asz + bsz + csz)) +
((asz + bsz + csz + absz + bcsz + acsz) * (abcsz * (abcsz + 1) // 2)) +
(absz * bcsz * acsz) +
((absz * (absz + 1) * d[c]) +
(bcsz * (bcsz + 1) * d[a]) +
(acsz * (acsz + 1) * d[b])) // 2 +
((asz + bsz + csz + abcsz) * (absz * acsz + absz * bcsz + bcsz * acsz)) +
(abcsz + (abcsz * (abcsz - 1)) + (abcsz * (abcsz - 1) * (abcsz - 2) // 6)))
print('\n'.join(map(str, l)))
if __name__ == '__main__':
main()
|
Codeforces Round 497 (Div. 1)
|
CF
| 2,018 | 2 | 256 |
Pave the Parallelepiped
|
You are given a rectangular parallelepiped with sides of positive integer lengths $$$A$$$, $$$B$$$ and $$$C$$$.
Find the number of different groups of three integers ($$$a$$$, $$$b$$$, $$$c$$$) such that $$$1\leq a\leq b\leq c$$$ and parallelepiped $$$A\times B\times C$$$ can be paved with parallelepipeds $$$a\times b\times c$$$. Note, that all small parallelepipeds have to be rotated in the same direction.
For example, parallelepiped $$$1\times 5\times 6$$$ can be divided into parallelepipeds $$$1\times 3\times 5$$$, but can not be divided into parallelepipeds $$$1\times 2\times 3$$$.
|
The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^5$$$) — the number of test cases.
Each of the next $$$t$$$ lines contains three integers $$$A$$$, $$$B$$$ and $$$C$$$ ($$$1 \leq A, B, C \leq 10^5$$$) — the sizes of the parallelepiped.
|
For each test case, print the number of different groups of three points that satisfy all given conditions.
| null |
In the first test case, rectangular parallelepiped $$$(1, 1, 1)$$$ can be only divided into rectangular parallelepiped with sizes $$$(1, 1, 1)$$$.
In the second test case, rectangular parallelepiped $$$(1, 6, 1)$$$ can be divided into rectangular parallelepipeds with sizes $$$(1, 1, 1)$$$, $$$(1, 1, 2)$$$, $$$(1, 1, 3)$$$ and $$$(1, 1, 6)$$$.
In the third test case, rectangular parallelepiped $$$(2, 2, 2)$$$ can be divided into rectangular parallelepipeds with sizes $$$(1, 1, 1)$$$, $$$(1, 1, 2)$$$, $$$(1, 2, 2)$$$ and $$$(2, 2, 2)$$$.
|
[{"input": "4\n1 1 1\n1 6 1\n2 2 2\n100 100 100", "output": "1\n4\n4\n165"}]
| 2,400 |
["bitmasks", "brute force", "combinatorics", "math", "number theory"]
| 28 |
[{"input": "4\r\n1 1 1\r\n1 6 1\r\n2 2 2\r\n100 100 100\r\n", "output": "1\r\n4\r\n4\r\n165\r\n"}, {"input": "10\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n", "output": "1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n"}, {"input": "10\r\n9 6 8\r\n5 5 2\r\n8 9 2\r\n2 7 9\r\n6 4 10\r\n1 1 8\r\n2 8 1\r\n10 6 3\r\n7 5 2\r\n9 5 4\r\n", "output": "41\r\n6\r\n21\r\n12\r\n39\r\n4\r\n7\r\n26\r\n8\r\n18\r\n"}, {"input": "1\r\n100000 100000 100000\r\n", "output": "8436\r\n"}]
| false |
stdio
| null | true |
1007/B
|
1007
|
B
|
Python 3
|
TESTS
| 2 | 873 | 47,513,600 |
40507451
|
#
import collections
from functools import cmp_to_key
#key=cmp_to_key(lambda x,y: 1 if x not in y else -1 )
import math
import sys
def getIntList():
return list(map(int, input().split()))
import bisect
try :
import numpy
dprint = print
dprint('debug mode')
except ModuleNotFoundError:
def dprint(*args, **kwargs):
pass
def makePair(z):
return [(z[i], z[i+1]) for i in range(0,len(z),2) ]
def memo(func):
cache={}
def wrap(*args):
if args not in cache:
cache[args]=func(*args)
return cache[args]
return wrap
@memo
def comb (n,k):
if k==0: return 1
if n==k: return 1
return comb(n-1,k-1) + comb(n-1,k)
pre = [[] for _ in range(100000 + 10) ]
for i in range(1, 100010):
t = i
while t<=100000:
pre[t].append(i)
t+=i
for i in range(1, 100010):
pre[i] = set(pre[i])
dprint(pre[6])
dprint(pre[1000])
dprint(pre[4300])
dprint('end')
T, = getIntList()
for _ in range(T):
A,B,C = getIntList()
zz = [pre[A].copy(), pre[B].copy(), pre[C].copy()]
s0 = pre[A] & pre[B] & pre[C]
#dprint(A,B,C)
#dprint(pre[A],pre[B], pre[C])
#dprint('s0 ',s0)
zt = [[],[],[]]
for i in range(3):
zz[i] -= s0
for i in range(3):
zt[i].append(s0)
now = zz[i].copy()
for j in range(3):
if i == j : continue
ts = zz[i] & zz[j]
zt[i].append(ts)
now-=ts
zt[i].append(now)
ti = len(s0)
dprint('zt',zt)
@memo
def gauss(x): return (x+1)*x//2
@memo
def trigauss(x):
tot = 0
for i in range(1,x+1):
tot+= gauss(i)
return tot
tot = trigauss(ti)
dprint(tot)
for i in range(4):
for j in range(4):
for k in range(4):
if i==0 and j==0 and k ==0:
continue
a = len(zt[0][i])
b = len(zt[1][j])
c = len(zt[2][k])
if zt[0][i] == zt[1][j]:
tot += gauss(a) *c
continue
if zt[0][i] == zt[2][k]:
tot += gauss(a) *b
continue
if zt[2][k] == zt[1][j]:
tot += gauss(b) *a
continue
tot+= a*b*c
dprint('result')
print(tot)
| 28 | 998 | 8,396,800 |
40311323
|
from sys import stdin
from math import gcd
def main():
input()
l = stdin.read().splitlines()
d = [3, 1, 2, 2, 2, 1] * 16667
for i in range(4, 100001):
for j in range(i, 100001, i):
d[j] += 1
for i, s in enumerate(l):
a, b, c = map(int, s.split())
k = gcd(b, c)
ab = d[gcd(a, b)]
ac = d[gcd(a, c)]
bc = d[k]
abc = d[gcd(a, k)]
asz = d[a] - ab - ac + abc
bsz = d[b] - bc - ab + abc
csz = d[c] - ac - bc + abc
absz = ab - abc
bcsz = bc - abc
acsz = ac - abc
abcsz = abc
l[i] = (asz * bsz * csz +
(absz * (asz + bsz) * csz) +
(bcsz * (bsz + csz) * asz) +
(acsz * (asz + csz) * bsz) +
(abcsz * (asz * bsz + asz * csz + bsz * csz)) +
(abcsz * (absz + bcsz + acsz) * (asz + bsz + csz)) +
((asz + bsz + csz + absz + bcsz + acsz) * (abcsz * (abcsz + 1) // 2)) +
(absz * bcsz * acsz) +
((absz * (absz + 1) * d[c]) +
(bcsz * (bcsz + 1) * d[a]) +
(acsz * (acsz + 1) * d[b])) // 2 +
((asz + bsz + csz + abcsz) * (absz * acsz + absz * bcsz + bcsz * acsz)) +
(abcsz + (abcsz * (abcsz - 1)) + (abcsz * (abcsz - 1) * (abcsz - 2) // 6)))
print('\n'.join(map(str, l)))
if __name__ == '__main__':
main()
|
Codeforces Round 497 (Div. 1)
|
CF
| 2,018 | 2 | 256 |
Pave the Parallelepiped
|
You are given a rectangular parallelepiped with sides of positive integer lengths $$$A$$$, $$$B$$$ and $$$C$$$.
Find the number of different groups of three integers ($$$a$$$, $$$b$$$, $$$c$$$) such that $$$1\leq a\leq b\leq c$$$ and parallelepiped $$$A\times B\times C$$$ can be paved with parallelepipeds $$$a\times b\times c$$$. Note, that all small parallelepipeds have to be rotated in the same direction.
For example, parallelepiped $$$1\times 5\times 6$$$ can be divided into parallelepipeds $$$1\times 3\times 5$$$, but can not be divided into parallelepipeds $$$1\times 2\times 3$$$.
|
The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^5$$$) — the number of test cases.
Each of the next $$$t$$$ lines contains three integers $$$A$$$, $$$B$$$ and $$$C$$$ ($$$1 \leq A, B, C \leq 10^5$$$) — the sizes of the parallelepiped.
|
For each test case, print the number of different groups of three points that satisfy all given conditions.
| null |
In the first test case, rectangular parallelepiped $$$(1, 1, 1)$$$ can be only divided into rectangular parallelepiped with sizes $$$(1, 1, 1)$$$.
In the second test case, rectangular parallelepiped $$$(1, 6, 1)$$$ can be divided into rectangular parallelepipeds with sizes $$$(1, 1, 1)$$$, $$$(1, 1, 2)$$$, $$$(1, 1, 3)$$$ and $$$(1, 1, 6)$$$.
In the third test case, rectangular parallelepiped $$$(2, 2, 2)$$$ can be divided into rectangular parallelepipeds with sizes $$$(1, 1, 1)$$$, $$$(1, 1, 2)$$$, $$$(1, 2, 2)$$$ and $$$(2, 2, 2)$$$.
|
[{"input": "4\n1 1 1\n1 6 1\n2 2 2\n100 100 100", "output": "1\n4\n4\n165"}]
| 2,400 |
["bitmasks", "brute force", "combinatorics", "math", "number theory"]
| 28 |
[{"input": "4\r\n1 1 1\r\n1 6 1\r\n2 2 2\r\n100 100 100\r\n", "output": "1\r\n4\r\n4\r\n165\r\n"}, {"input": "10\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n1 1 1\r\n", "output": "1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n"}, {"input": "10\r\n9 6 8\r\n5 5 2\r\n8 9 2\r\n2 7 9\r\n6 4 10\r\n1 1 8\r\n2 8 1\r\n10 6 3\r\n7 5 2\r\n9 5 4\r\n", "output": "41\r\n6\r\n21\r\n12\r\n39\r\n4\r\n7\r\n26\r\n8\r\n18\r\n"}, {"input": "1\r\n100000 100000 100000\r\n", "output": "8436\r\n"}]
| false |
stdio
| null | true |
194/B
|
194
|
B
|
Python 3
|
TESTS
| 3 | 139 | 614,400 |
103138362
|
def isPrime(n):
i = 2
if n == 21:
return True
elif n == 1:
return False
while i*i <= n:
if n % i == 0:
return False
else:
i+=1
return True
a = int(input())
w = map(int,input().split())
b = map(lambda x:x*4+1,w)
for w in b:
w-=1
w/=4
w = int(w)
if isPrime(w):
print(int(w+w+1))
else:
print(int((w*4)+1))
| 8 | 62 | 921,600 |
221460183
|
input()
def sqaure(array):
for number in array:
if int(number) % 2 == 0:
print(int(number) * 4 + 1)
elif -(-int(number) // 2) % 2 == 0:
print(int(number) +1)
else: print(2 * int(number) + 1)
sqaure(input().split())
|
Codeforces Round 122 (Div. 2)
|
CF
| 2,012 | 2 | 256 |
Square
|
There is a square painted on a piece of paper, the square's side equals n meters. John Doe draws crosses on the square's perimeter. John paints the first cross in the lower left corner of the square. Then John moves along the square's perimeter in the clockwise direction (first upwards, then to the right, then downwards, then to the left and so on). Every time he walks (n + 1) meters, he draws a cross (see picture for clarifications).
John Doe stops only when the lower left corner of the square has two crosses. How many crosses will John draw?
The figure shows the order in which John draws crosses for a square with side 4. The lower left square has two crosses. Overall John paints 17 crosses.
|
The first line contains integer t (1 ≤ t ≤ 104) — the number of test cases.
The second line contains t space-separated integers ni (1 ≤ ni ≤ 109) — the sides of the square for each test sample.
|
For each test sample print on a single line the answer to it, that is, the number of crosses John will draw as he will move along the square of the corresponding size. Print the answers to the samples in the order in which the samples are given in the input.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
| null | null |
[{"input": "3\n4 8 100", "output": "17\n33\n401"}]
| 1,200 |
["math"]
| 8 |
[{"input": "3\r\n4 8 100\r\n", "output": "17\r\n33\r\n401\r\n"}, {"input": "8\r\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 13\r\n", "output": "4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n27\r\n"}, {"input": "3\r\n13 17 21\r\n", "output": "27\r\n35\r\n43\r\n"}]
| false |
stdio
| null | true |
194/B
|
194
|
B
|
Python 3
|
TESTS
| 3 | 124 | 409,600 |
45181564
|
x=int(input())
a=list(map(int,input().split()))
for i in range(x):
if a[i]%2==0:
print(a[i]*4+1)
else:
print(a[i]*2+1)
| 8 | 77 | 614,400 |
142595505
|
import sys
import math
def get_int():
return int(sys.stdin.readline())
def get_string():
return sys.stdin.readline().strip()
FILE=False
if FILE:
sys.stdin=open('input.txt','r')
sys.stdout=open('output.txt','w')
t=get_int()
sides=list(map(int,get_string().split()))
for side in sides:
z=math.gcd(side+1,side*4)
crosses=4*side/z+1
print(str(int(crosses)))
|
Codeforces Round 122 (Div. 2)
|
CF
| 2,012 | 2 | 256 |
Square
|
There is a square painted on a piece of paper, the square's side equals n meters. John Doe draws crosses on the square's perimeter. John paints the first cross in the lower left corner of the square. Then John moves along the square's perimeter in the clockwise direction (first upwards, then to the right, then downwards, then to the left and so on). Every time he walks (n + 1) meters, he draws a cross (see picture for clarifications).
John Doe stops only when the lower left corner of the square has two crosses. How many crosses will John draw?
The figure shows the order in which John draws crosses for a square with side 4. The lower left square has two crosses. Overall John paints 17 crosses.
|
The first line contains integer t (1 ≤ t ≤ 104) — the number of test cases.
The second line contains t space-separated integers ni (1 ≤ ni ≤ 109) — the sides of the square for each test sample.
|
For each test sample print on a single line the answer to it, that is, the number of crosses John will draw as he will move along the square of the corresponding size. Print the answers to the samples in the order in which the samples are given in the input.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
| null | null |
[{"input": "3\n4 8 100", "output": "17\n33\n401"}]
| 1,200 |
["math"]
| 8 |
[{"input": "3\r\n4 8 100\r\n", "output": "17\r\n33\r\n401\r\n"}, {"input": "8\r\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 13\r\n", "output": "4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n27\r\n"}, {"input": "3\r\n13 17 21\r\n", "output": "27\r\n35\r\n43\r\n"}]
| false |
stdio
| null | true |
194/B
|
194
|
B
|
Python 3
|
TESTS
| 3 | 109 | 819,200 |
57581192
|
N = int(input())
num = input().split()
for x in num:
y = int(x)
if( y % 2 == 0):
y = 4*y + 1;
else:
y = 2*y + 1;
print(y)
| 8 | 77 | 5,427,200 |
180481809
|
from math import gcd
n = int(input())
arr = input().split()
res = [4*int(i)//gcd(4*int(i), int(i) + 1) + 1 for i in arr]
for i in res:
print(i)
|
Codeforces Round 122 (Div. 2)
|
CF
| 2,012 | 2 | 256 |
Square
|
There is a square painted on a piece of paper, the square's side equals n meters. John Doe draws crosses on the square's perimeter. John paints the first cross in the lower left corner of the square. Then John moves along the square's perimeter in the clockwise direction (first upwards, then to the right, then downwards, then to the left and so on). Every time he walks (n + 1) meters, he draws a cross (see picture for clarifications).
John Doe stops only when the lower left corner of the square has two crosses. How many crosses will John draw?
The figure shows the order in which John draws crosses for a square with side 4. The lower left square has two crosses. Overall John paints 17 crosses.
|
The first line contains integer t (1 ≤ t ≤ 104) — the number of test cases.
The second line contains t space-separated integers ni (1 ≤ ni ≤ 109) — the sides of the square for each test sample.
|
For each test sample print on a single line the answer to it, that is, the number of crosses John will draw as he will move along the square of the corresponding size. Print the answers to the samples in the order in which the samples are given in the input.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
| null | null |
[{"input": "3\n4 8 100", "output": "17\n33\n401"}]
| 1,200 |
["math"]
| 8 |
[{"input": "3\r\n4 8 100\r\n", "output": "17\r\n33\r\n401\r\n"}, {"input": "8\r\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 13\r\n", "output": "4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n27\r\n"}, {"input": "3\r\n13 17 21\r\n", "output": "27\r\n35\r\n43\r\n"}]
| false |
stdio
| null | true |
1000/C
|
1000
|
C
|
Python 3
|
TESTS
| 3 | 514 | 22,937,600 |
216918080
|
import sys
# sys.stdin = open("2.in", "r")
N = int(input())
beg = [0]*N
end = [0]*N
for i in range(N):
beg[i], end[i] = list(map(int, input().split()))
end[i] += 1
beg.sort()
end.sort()
p1 = 0
p2 = 0
count = 0
prev = 0
res = [0]*(N+1)
while p1 < len(beg):
if beg[p1] <= end[p2]:
res[count] += beg[p1] - prev
count += 1
prev = beg[p1]
p1 += 1
else:
res[count] += end[p2] - prev
count -= 1
prev = end[p2]
p2 += 1
for i in range(p2, len(end)):
res[count] += end[i] - prev
prev = end[p2]
count -= 1
print(" ".join(str(res[i]) for i in range(1, len(res))))
| 18 | 576 | 43,622,400 |
212247138
|
import sys
from collections import defaultdict
input = sys.stdin.readline
n = int(input())
d = defaultdict(int)
ans = [0] * (n + 1)
for i in range(n):
l ,r = map(int, input().split())
d[l] += 1
d[r + 1] -= 1
s = p = 0
for k in sorted(d):
ans[s] += k - p
s += d[k]
p = k
print(*ans[1:])
|
Educational Codeforces Round 46 (Rated for Div. 2)
|
ICPC
| 2,018 | 3 | 256 |
Covered Points Count
|
You are given $$$n$$$ segments on a coordinate line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
Your task is the following: for every $$$k \in [1..n]$$$, calculate the number of points with integer coordinates such that the number of segments that cover these points equals $$$k$$$. A segment with endpoints $$$l_i$$$ and $$$r_i$$$ covers point $$$x$$$ if and only if $$$l_i \le x \le r_i$$$.
|
The first line of the input contains one integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) — the number of segments.
The next $$$n$$$ lines contain segments. The $$$i$$$-th line contains a pair of integers $$$l_i, r_i$$$ ($$$0 \le l_i \le r_i \le 10^{18}$$$) — the endpoints of the $$$i$$$-th segment.
|
Print $$$n$$$ space separated integers $$$cnt_1, cnt_2, \dots, cnt_n$$$, where $$$cnt_i$$$ is equal to the number of points such that the number of segments that cover these points equals to $$$i$$$.
| null |
The picture describing the first example:
Points with coordinates $$$[0, 4, 5, 6, 7, 8]$$$ are covered by one segment, points $$$[1, 2]$$$ are covered by two segments and point $$$[3]$$$ is covered by three segments.
The picture describing the second example:
Points $$$[1, 4, 5, 6, 7]$$$ are covered by one segment, points $$$[2, 3]$$$ are covered by two segments and there are no points covered by three segments.
|
[{"input": "3\n0 3\n1 3\n3 8", "output": "6 2 1"}, {"input": "3\n1 3\n2 4\n5 7", "output": "5 2 0"}]
| 1,700 |
["data structures", "implementation", "sortings"]
| 18 |
[{"input": "3\r\n0 3\r\n1 3\r\n3 8\r\n", "output": "6 2 1 \r\n"}, {"input": "3\r\n1 3\r\n2 4\r\n5 7\r\n", "output": "5 2 0 \r\n"}, {"input": "1\r\n0 1000000000000000000\r\n", "output": "1000000000000000001 \r\n"}]
| false |
stdio
| null | true |
843/A
|
843
|
A
|
Python 3
|
TESTS
| 1 | 15 | 0 |
195042946
|
n = int(input())
a = list(map(int, input().split()))
sorted_a = sorted(a)
ind = 0
num = a[0]
ans = []
for i in range(1, n):
num = max(a[ind:i + 1])
if sorted_a[i] == num and ind != i:
ans.append((2, ind + 1, i + 1))
for j in range(ind + 1, i):
ans.append((1, j + 1))
ind = i + 1
print(len(ans))
for i in ans:
print(*i)
| 71 | 421 | 24,371,200 |
233547685
|
# LUOGU_RID: 136079801
def read_input():
"""
Read the input from the user.
Returns:
- n: The length of the sequence.
- a: The sequence of integers.
"""
n = int(input())
a = list(map(int, input().split()))
return n, a
def discretization(n, a):
"""
Sort the sequence and generate a list of pairs (value, index + 1).
Parameters:
- n: The length of the sequence.
- a: The sequence of integers.
Returns:
- b: The sorted sequence as a list of pairs (value, index + 1).
"""
x = sorted([(a[i], i + 1) for i in range(n)])
b = [0] * (n + 1)
for id, item in enumerate(x):
b[item[1]] = id + 1
return b
# def generate_permutation(n, b):
# """
# Generate a permutation of the sequence.
# Parameters:
# - n: The length of the sequence.
# - b: The sorted sequence as a list of pairs (value, index + 1).
# Returns:
# - p: The permutation of the sequence.
# """
# p = [0] * (n + 1)
# for i in range(n):
# p[b[i][1]] = b[(i + 1) % n][1]
# return p
def find_cycles(n, p):
"""
Find the cycles in the permutation.
Parameters:
- n: The length of the sequence.
- p: The permutation of the sequence.
Returns:
- cycles: The cycles in the permutation.
"""
used = [0] * (n + 1)
cycles = []
for i in range(1, n + 1):
if not used[i]:
cycle = [i]
v = p[i]
while v != i:
cycle.append(v)
v = p[v]
cycles.append(cycle)
for v in cycle:
used[v] = 1
return cycles
def print_output(cycles):
"""
Print the output in the required format.
Parameters:
- cycles: The cycles in the permutation.
"""
print(len(cycles))
for cycle in cycles:
print(len(cycle), *cycle)
if __name__ == "__main__":
n, a = read_input()
b = discretization(n, a)
# print(b)
# p = generate_permutation(n, b)
# print(p)
cycles = find_cycles(n, b)
print_output(cycles)
|
AIM Tech Round 4 (Div. 1)
|
CF
| 2,017 | 1 | 256 |
Sorting by Subsequences
|
You are given a sequence a1, a2, ..., an consisting of different integers. It is required to split this sequence into the maximum number of subsequences such that after sorting integers in each of them in increasing order, the total sequence also will be sorted in increasing order.
Sorting integers in a subsequence is a process such that the numbers included in a subsequence are ordered in increasing order, and the numbers which are not included in a subsequence don't change their places.
Every element of the sequence must appear in exactly one subsequence.
|
The first line of input data contains integer n (1 ≤ n ≤ 105) — the length of the sequence.
The second line of input data contains n different integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the elements of the sequence. It is guaranteed that all elements of the sequence are distinct.
|
In the first line print the maximum number of subsequences k, which the original sequence can be split into while fulfilling the requirements.
In the next k lines print the description of subsequences in the following format: the number of elements in subsequence ci (0 < ci ≤ n), then ci integers l1, l2, ..., lci (1 ≤ lj ≤ n) — indices of these elements in the original sequence.
Indices could be printed in any order. Every index from 1 to n must appear in output exactly once.
If there are several possible answers, print any of them.
| null |
In the first sample output:
After sorting the first subsequence we will get sequence 1 2 3 6 5 4.
Sorting the second subsequence changes nothing.
After sorting the third subsequence we will get sequence 1 2 3 4 5 6.
Sorting the last subsequence changes nothing.
|
[{"input": "6\n3 2 1 6 5 4", "output": "4\n2 1 3\n1 2\n2 4 6\n1 5"}, {"input": "6\n83 -75 -49 11 37 62", "output": "1\n6 1 2 3 4 5 6"}]
| 1,400 |
["dfs and similar", "dsu", "implementation", "math", "sortings"]
| 71 |
[{"input": "6\r\n3 2 1 6 5 4\r\n", "output": "4\r\n2 1 3\r\n1 2\r\n2 4 6\r\n1 5\r\n"}, {"input": "6\r\n83 -75 -49 11 37 62\r\n", "output": "1\r\n6 1 2 3 4 5 6\r\n"}, {"input": "1\r\n1\r\n", "output": "1\r\n1 1\r\n"}, {"input": "2\r\n1 2\r\n", "output": "2\r\n1 1\r\n1 2\r\n"}, {"input": "2\r\n2 1\r\n", "output": "1\r\n2 1 2\r\n"}, {"input": "3\r\n1 2 3\r\n", "output": "3\r\n1 1\r\n1 2\r\n1 3\r\n"}, {"input": "3\r\n3 2 1\r\n", "output": "2\r\n2 1 3\r\n1 2\r\n"}, {"input": "3\r\n3 1 2\r\n", "output": "1\r\n3 1 2 3\r\n"}, {"input": "10\r\n3 7 10 1 9 5 4 8 6 2\r\n", "output": "3\r\n6 1 4 7 2 10 3\r\n3 5 6 9\r\n1 8\r\n"}, {"input": "20\r\n363756450 -204491568 95834122 -840249197 -49687658 470958158 -445130206 189801569 802780784 -790013317 -192321079 586260100 -751917965 -354684803 418379342 -253230108 193944314 712662868 853829789 735867677\r\n", "output": "3\r\n7 1 4 7 2 10 3 13\r\n11 5 14 15 6 16 12 17 18 20 19 9\r\n2 8 11\r\n"}, {"input": "50\r\n39 7 45 25 31 26 50 11 19 37 8 16 22 33 14 6 12 46 49 48 29 27 41 15 34 24 3 13 20 47 9 36 5 43 40 21 2 38 35 42 23 28 1 32 10 17 30 18 44 4\r\n", "output": "6\r\n20 1 43 34 25 4 50 7 2 37 10 45 3 27 22 13 28 42 40 35 39\r\n23 5 33 14 15 24 26 6 16 12 17 46 18 48 20 29 21 36 32 44 49 19 9 31\r\n2 8 11\r\n2 23 41\r\n2 30 47\r\n1 38\r\n"}, {"input": "100\r\n39 77 67 25 81 26 50 11 73 95 86 16 90 33 14 79 12 100 68 64 60 27 41 15 34 24 3 61 83 47 57 65 99 43 40 21 94 72 82 85 23 71 76 32 10 17 30 18 44 59 35 89 6 63 7 69 62 70 4 29 92 87 31 48 36 28 45 97 93 98 56 38 58 80 8 1 74 91 53 55 54 51 96 5 42 52 9 22 78 88 75 13 66 2 37 20 49 19 84 46\r\n", "output": "6\r\n41 1 76 43 34 25 4 59 50 7 55 80 74 77 2 94 37 95 10 45 67 3 27 22 88 90 13 92 61 28 66 93 69 56 71 42 85 40 35 51 82 39\r\n45 5 84 99 33 14 15 24 26 6 53 79 16 12 17 46 100 18 48 64 20 96 83 29 60 21 36 65 32 44 49 97 68 19 98 70 58 73 9 87 62 57 31 63 54 81\r\n8 8 75 91 78 89 52 86 11\r\n2 23 41\r\n2 30 47\r\n2 38 72\r\n"}]
| false |
stdio
|
import sys
from collections import defaultdict
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(input_path) as f:
n = int(f.readline())
a = list(map(int, f.readline().split()))
sorted_a = sorted(a)
pos_in_sorted = {v: i+1 for i, v in enumerate(sorted_a)} # 1-based
P = {i+1: pos_in_sorted[v] for i, v in enumerate(a)} # 1-based indices
visited = set()
cycles = []
for node in range(1, n+1):
if node not in visited:
current = node
cycle = []
while current not in visited:
visited.add(current)
cycle.append(current)
current = P[current]
cycles.append(cycle)
correct_k = len(cycles)
computed_cycles = [set(cycle) for cycle in cycles]
with open(submission_path) as f:
lines = [line.strip() for line in f.readlines() if line.strip()]
if not lines:
print(0)
return
try:
k = int(lines[0])
if k != correct_k:
print(0)
return
submission_cycles = []
all_indices = set()
for line in lines[1:1 + k]:
parts = list(map(int, line.split()))
if not parts:
print(0)
return
cnt = parts[0]
if cnt <= 0 or cnt > n:
print(0)
return
indices = parts[1:1 + cnt]
if len(indices) != cnt:
print(0)
return
for idx in indices:
if not (1 <= idx <= n):
print(0)
return
s_indices = set(indices)
if len(s_indices) != cnt:
print(0)
return
if s_indices & all_indices:
print(0)
return
all_indices.update(s_indices)
submission_cycles.append(s_indices)
if all_indices != set(range(1, n+1)):
print(0)
return
except:
print(0)
return
for s_cycle in submission_cycles:
start = next(iter(s_cycle))
current = start
collected = set()
while True:
collected.add(current)
current = P[current]
if current == start:
break
if collected != s_cycle:
print(0)
return
print(100)
if __name__ == "__main__":
main()
| true |
419/B
|
420
|
B
|
Python 3
|
TESTS
| 0 | 15 | 0 |
169612615
|
import sys
n, m = map(int, input().split())
def best_input():return list(map(str.strip, sys.stdin))
who_is_now = set()
who_was = set()
ret = set(range(1, n + 1))
k = 1
posl = None
pod = None
for t in best_input():
init = int(t.split()[1])
ret -= set([init])
if '-' in t:
if (not who_is_now) and (init not in who_was):
who_was.add(init)
pod = init
if who_is_now:
who_was.add(init)
who_is_now -= set([init])
else:
if k:
pod = init
else:
who_was.add(init)
who_is_now.add(init)
k = 0
if pod not in who_was:ret.add(pod)
print(len(ret))
print(*ret)
| 61 | 343 | 9,523,200 |
108631899
|
n, m = map(int, input().split())
covers_all = set(range(1, n+1))
in_there = set([])
occurred = set([])
minus_delete_candidates = set([])
plus_delete_candidates = set([])
for i in range(m):
a, b = input().split()
b = int(b)
if a == '+':
in_there.add(b)
covers_all -= (plus_delete_candidates - in_there)
plus_delete_candidates = set([])
if occurred and b not in occurred:
covers_all.discard(b)
else:
if b in in_there:
in_there.remove(b)
else:
covers_all -= minus_delete_candidates
minus_delete_candidates = set([])
if in_there:
covers_all.discard(b)
else:
plus_delete_candidates.add(b)
occurred.add(b)
if b in covers_all:
minus_delete_candidates.add(b)
print(len(covers_all))
if covers_all:
print(' '.join(map(str, sorted(list(covers_all)))))
|
Coder-Strike 2014 - Finals
|
CF
| 2,014 | 1 | 256 |
Online Meeting
|
Nearly each project of the F company has a whole team of developers working on it. They often are in different rooms of the office in different cities and even countries. To keep in touch and track the results of the project, the F company conducts shared online meetings in a Spyke chat.
One day the director of the F company got hold of the records of a part of an online meeting of one successful team. The director watched the record and wanted to talk to the team leader. But how can he tell who the leader is? The director logically supposed that the leader is the person who is present at any conversation during a chat meeting. In other words, if at some moment of time at least one person is present on the meeting, then the leader is present on the meeting.
You are the assistant director. Given the 'user logged on'/'user logged off' messages of the meeting in the chronological order, help the director determine who can be the leader. Note that the director has the record of only a continuous part of the meeting (probably, it's not the whole meeting).
|
The first line contains integers n and m (1 ≤ n, m ≤ 105) — the number of team participants and the number of messages. Each of the next m lines contains a message in the format:
- '+ id': the record means that the person with number id (1 ≤ id ≤ n) has logged on to the meeting.
- '- id': the record means that the person with number id (1 ≤ id ≤ n) has logged off from the meeting.
Assume that all the people of the team are numbered from 1 to n and the messages are given in the chronological order. It is guaranteed that the given sequence is the correct record of a continuous part of the meeting. It is guaranteed that no two log on/log off events occurred simultaneously.
|
In the first line print integer k (0 ≤ k ≤ n) — how many people can be leaders. In the next line, print k integers in the increasing order — the numbers of the people who can be leaders.
If the data is such that no member of the team can be a leader, print a single number 0.
| null | null |
[{"input": "5 4\n+ 1\n+ 2\n- 2\n- 1", "output": "4\n1 3 4 5"}, {"input": "3 2\n+ 1\n- 2", "output": "1\n3"}, {"input": "2 4\n+ 1\n- 1\n+ 2\n- 2", "output": "0"}, {"input": "5 6\n+ 1\n- 1\n- 3\n+ 3\n+ 4\n- 4", "output": "3\n2 3 5"}, {"input": "2 4\n+ 1\n- 2\n+ 2\n- 1", "output": "0"}]
| 1,800 |
[]
| 61 |
[{"input": "5 4\r\n+ 1\r\n+ 2\r\n- 2\r\n- 1\r\n", "output": "4\r\n1 3 4 5 "}, {"input": "3 2\r\n+ 1\r\n- 2\r\n", "output": "1\r\n3 "}, {"input": "2 4\r\n+ 1\r\n- 1\r\n+ 2\r\n- 2\r\n", "output": "0\r\n"}, {"input": "5 6\r\n+ 1\r\n- 1\r\n- 3\r\n+ 3\r\n+ 4\r\n- 4\r\n", "output": "3\r\n2 3 5 "}, {"input": "2 4\r\n+ 1\r\n- 2\r\n+ 2\r\n- 1\r\n", "output": "0\r\n"}, {"input": "1 1\r\n+ 1\r\n", "output": "1\r\n1 "}, {"input": "2 1\r\n- 2\r\n", "output": "2\r\n1 2 "}, {"input": "3 5\r\n- 1\r\n+ 1\r\n+ 2\r\n- 2\r\n+ 3\r\n", "output": "1\r\n1 "}, {"input": "10 8\r\n+ 1\r\n- 1\r\n- 2\r\n- 3\r\n+ 3\r\n+ 7\r\n- 7\r\n+ 9\r\n", "output": "6\r\n3 4 5 6 8 10 "}, {"input": "5 5\r\n+ 5\r\n+ 2\r\n+ 3\r\n+ 4\r\n+ 1\r\n", "output": "1\r\n5 "}, {"input": "5 4\r\n+ 1\r\n- 1\r\n+ 1\r\n+ 2\r\n", "output": "4\r\n1 3 4 5 "}, {"input": "10 3\r\n+ 1\r\n+ 2\r\n- 7\r\n", "output": "7\r\n3 4 5 6 8 9 10 "}, {"input": "1 20\r\n- 1\r\n+ 1\r\n- 1\r\n+ 1\r\n- 1\r\n+ 1\r\n- 1\r\n+ 1\r\n- 1\r\n+ 1\r\n- 1\r\n+ 1\r\n- 1\r\n+ 1\r\n- 1\r\n+ 1\r\n- 1\r\n+ 1\r\n- 1\r\n+ 1\r\n", "output": "1\r\n1 "}, {"input": "20 1\r\n- 16\r\n", "output": "20\r\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 "}, {"input": "50 20\r\n- 6\r\n+ 40\r\n- 3\r\n- 23\r\n+ 31\r\n- 27\r\n- 40\r\n+ 25\r\n+ 29\r\n- 41\r\n- 16\r\n+ 23\r\n+ 20\r\n+ 13\r\n- 45\r\n+ 40\r\n+ 24\r\n+ 22\r\n- 23\r\n+ 17\r\n", "output": "34\r\n1 2 4 5 7 8 9 10 11 12 14 15 18 19 21 26 28 30 32 33 34 35 36 37 38 39 42 43 44 46 47 48 49 50 "}, {"input": "20 50\r\n+ 5\r\n+ 11\r\n- 5\r\n+ 6\r\n- 16\r\n- 13\r\n+ 5\r\n+ 7\r\n- 8\r\n- 7\r\n- 10\r\n+ 10\r\n- 20\r\n- 19\r\n+ 17\r\n- 2\r\n+ 2\r\n+ 19\r\n+ 18\r\n- 2\r\n- 6\r\n- 5\r\n+ 6\r\n+ 4\r\n- 14\r\n+ 14\r\n- 9\r\n+ 15\r\n- 17\r\n- 15\r\n+ 2\r\n+ 5\r\n- 2\r\n+ 9\r\n- 11\r\n+ 2\r\n- 19\r\n+ 7\r\n+ 12\r\n+ 16\r\n+ 19\r\n- 18\r\n- 2\r\n+ 18\r\n- 9\r\n- 10\r\n+ 9\r\n+ 13\r\n- 14\r\n- 16\r\n", "output": "2\r\n1 3 "}, {"input": "100 5\r\n- 60\r\n- 58\r\n+ 25\r\n- 32\r\n+ 86\r\n", "output": "95\r\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 26 27 28 29 30 31 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 59 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 87 88 89 90 91 92 93 94 95 96 97 98 99 100 "}, {"input": "4 4\r\n+ 2\r\n- 1\r\n- 3\r\n- 2\r\n", "output": "1\r\n4 "}, {"input": "3 3\r\n- 2\r\n+ 1\r\n+ 2\r\n", "output": "1\r\n3 "}, {"input": "5 4\r\n- 1\r\n- 2\r\n+ 3\r\n+ 4\r\n", "output": "1\r\n5 "}, {"input": "6 6\r\n- 5\r\n- 6\r\n- 3\r\n- 1\r\n- 2\r\n- 4\r\n", "output": "1\r\n4 "}, {"input": "10 7\r\n- 8\r\n+ 1\r\n+ 2\r\n+ 3\r\n- 2\r\n- 3\r\n- 1\r\n", "output": "6\r\n4 5 6 7 9 10 "}, {"input": "10 7\r\n- 8\r\n+ 1\r\n+ 2\r\n+ 3\r\n- 2\r\n- 3\r\n- 1\r\n", "output": "6\r\n4 5 6 7 9 10 "}, {"input": "4 10\r\n+ 2\r\n- 1\r\n- 2\r\n- 3\r\n+ 3\r\n+ 2\r\n+ 4\r\n- 2\r\n+ 2\r\n+ 1\r\n", "output": "1\r\n3 "}, {"input": "4 9\r\n+ 2\r\n- 1\r\n- 2\r\n- 3\r\n+ 3\r\n+ 2\r\n+ 4\r\n- 2\r\n+ 2\r\n", "output": "1\r\n3 "}, {"input": "10 8\r\n+ 1\r\n- 1\r\n- 4\r\n+ 4\r\n+ 3\r\n+ 7\r\n- 7\r\n+ 9\r\n", "output": "6\r\n2 4 5 6 8 10 "}, {"input": "10 6\r\n+ 2\r\n- 2\r\n+ 2\r\n- 2\r\n+ 2\r\n- 3\r\n", "output": "8\r\n1 4 5 6 7 8 9 10 "}, {"input": "10 5\r\n+ 2\r\n- 2\r\n+ 2\r\n- 2\r\n- 3\r\n", "output": "9\r\n1 3 4 5 6 7 8 9 10 "}, {"input": "10 11\r\n+ 1\r\n- 1\r\n- 2\r\n+ 3\r\n- 3\r\n- 4\r\n+ 5\r\n- 5\r\n- 6\r\n+ 6\r\n+ 7\r\n", "output": "4\r\n6 8 9 10 "}, {"input": "10 10\r\n+ 1\r\n- 1\r\n- 2\r\n+ 3\r\n- 3\r\n- 4\r\n+ 5\r\n- 5\r\n- 6\r\n+ 6\r\n", "output": "5\r\n6 7 8 9 10 "}, {"input": "10 9\r\n+ 1\r\n- 1\r\n- 2\r\n+ 3\r\n- 3\r\n- 4\r\n+ 5\r\n- 5\r\n- 6\r\n", "output": "5\r\n6 7 8 9 10 "}, {"input": "10 12\r\n+ 1\r\n- 1\r\n- 2\r\n+ 3\r\n- 3\r\n- 4\r\n+ 5\r\n- 5\r\n- 6\r\n+ 6\r\n+ 7\r\n- 7\r\n", "output": "4\r\n6 8 9 10 "}, {"input": "2 2\r\n- 1\r\n+ 1\r\n", "output": "2\r\n1 2 "}, {"input": "7 4\r\n- 2\r\n- 3\r\n+ 3\r\n- 6\r\n", "output": "4\r\n1 4 5 7 "}, {"input": "2 3\r\n+ 1\r\n+ 2\r\n- 1\r\n", "output": "0\r\n"}, {"input": "5 5\r\n- 2\r\n+ 1\r\n+ 2\r\n- 2\r\n+ 4\r\n", "output": "2\r\n3 5 "}, {"input": "5 3\r\n+ 1\r\n- 1\r\n+ 2\r\n", "output": "3\r\n3 4 5 "}, {"input": "4 4\r\n- 1\r\n+ 1\r\n- 1\r\n+ 2\r\n", "output": "2\r\n3 4 "}]
| false |
stdio
| null | true |
627/B
|
627
|
B
|
PyPy 3
|
TESTS
| 3 | 2,995 | 8,806,400 |
53175579
|
n, k, a, b, q = map(int, input().split())
cnt = [0] * (n + 1)
days = [0] * (n+1)
for i in range(q):
c = list(map(int, input().split()))
if len(c) == 3:
cnt[c[1] - 1] += cnt[c[1] - 2] + min(b, c[2])
days[c[1] - 1] += c[2]
else:
cop = cnt[::]
c[1] += k
cop[c[1] - 1] = cnt[c[1] - k - 2] + min(a, days[c[1]-1])
cop[c[1]:] = [0]*(n - c[1]+1)
for j in range(c[1], n+1):
cop[j] = cop[j - 1] + min(a, days[j])
print(cop[-1])
| 42 | 1,981 | 45,670,400 |
16414444
|
from functools import reduce
class SegmentTree():
def __init__(self, L, function = lambda x,y: x+y, initilizer = None):
self.function = function
self.initilizer = initilizer
N = self.size = len(L)
M = 1 << N.bit_length()
self.margin = 2*M - N
self.L = [None for i in range(self.margin)] + L
for i in range(M-1, 0, -1):
x, y = self.L[i<<1], self.L[i<<1|1]
self.L[i] = None if x is None or y is None else function(x, y)
def modify(self, pos, value):
p = pos + self.margin
self.L[p] = value
while p > 1:
x, y = self.L[p], self.L[p^1]
if p&1: x, y = y, x
self.L[p>>1] = None if x is None or y is None else self.function(x, y)
p>>=1
def query(self, left, right):
l, r = left + self.margin, right + self.margin
stack = []
void = True
if self.initilizer is not None:
void = False
result = self.initilizer
while l < r:
if l&1:
if void:
result = self.L[l]
void = False
else:
result = self.function(result, self.L[l])
l+=1
if r&1:
r-=1
stack.append(self.L[r])
l>>=1
r>>=1
init = stack.pop() if void else result
return reduce(self.function, reversed(stack), init)
import sys
n, k, a, b, q = [int(x) for x in input().split()]
orders = [0]*(n+2)
a_tree, b_tree = SegmentTree(orders, initilizer = 0), SegmentTree(orders, initilizer = 0)
for line in sys.stdin:
s = [int(x) for x in line.split()]
if s[0] == 1:
orders[s[1]] += s[2]
a_tree.modify(s[1], min(a, orders[s[1]]))
b_tree.modify(s[1], min(b, orders[s[1]]))
else:
query = b_tree.query(0, s[1]) + a_tree.query(s[1]+k, n+1)
print(query)
|
8VC Venture Cup 2016 - Final Round
|
CF
| 2,016 | 4 | 256 |
Factory Repairs
|
A factory produces thimbles in bulk. Typically, it can produce up to a thimbles a day. However, some of the machinery is defective, so it can currently only produce b thimbles each day. The factory intends to choose a k-day period to do maintenance and construction; it cannot produce any thimbles during this time, but will be restored to its full production of a thimbles per day after the k days are complete.
Initially, no orders are pending. The factory receives updates of the form di, ai, indicating that ai new orders have been placed for the di-th day. Each order requires a single thimble to be produced on precisely the specified day. The factory may opt to fill as many or as few of the orders in a single batch as it likes.
As orders come in, the factory owner would like to know the maximum number of orders he will be able to fill if he starts repairs on a given day pi. Help the owner answer his questions.
|
The first line contains five integers n, k, a, b, and q (1 ≤ k ≤ n ≤ 200 000, 1 ≤ b < a ≤ 10 000, 1 ≤ q ≤ 200 000) — the number of days, the length of the repair time, the production rates of the factory, and the number of updates, respectively.
The next q lines contain the descriptions of the queries. Each query is of one of the following two forms:
- 1 di ai (1 ≤ di ≤ n, 1 ≤ ai ≤ 10 000), representing an update of ai orders on day di, or
- 2 pi (1 ≤ pi ≤ n - k + 1), representing a question: at the moment, how many orders could be filled if the factory decided to commence repairs on day pi?
It's guaranteed that the input will contain at least one query of the second type.
|
For each query of the second type, print a line containing a single integer — the maximum number of orders that the factory can fill over all n days.
| null |
Consider the first sample.
We produce up to 1 thimble a day currently and will produce up to 2 thimbles a day after repairs. Repairs take 2 days.
For the first question, we are able to fill 1 order on day 1, no orders on days 2 and 3 since we are repairing, no orders on day 4 since no thimbles have been ordered for that day, and 2 orders for day 5 since we are limited to our production capacity, for a total of 3 orders filled.
For the third question, we are able to fill 1 order on day 1, 1 order on day 2, and 2 orders on day 5, for a total of 4 orders.
|
[{"input": "5 2 2 1 8\n1 1 2\n1 5 3\n1 2 1\n2 2\n1 4 2\n1 3 2\n2 1\n2 3", "output": "3\n6\n4"}, {"input": "5 4 10 1 6\n1 1 5\n1 5 5\n1 3 2\n1 5 2\n2 1\n2 2", "output": "7\n1"}]
| 1,700 |
["data structures"]
| 42 |
[{"input": "5 2 2 1 8\r\n1 1 2\r\n1 5 3\r\n1 2 1\r\n2 2\r\n1 4 2\r\n1 3 2\r\n2 1\r\n2 3\r\n", "output": "3\r\n6\r\n4\r\n"}, {"input": "5 4 10 1 6\r\n1 1 5\r\n1 5 5\r\n1 3 2\r\n1 5 2\r\n2 1\r\n2 2\r\n", "output": "7\r\n1\r\n"}, {"input": "1 1 2 1 1\r\n2 1\r\n", "output": "0\r\n"}]
| false |
stdio
| null | true |
1000/C
|
1000
|
C
|
Python 3
|
TESTS
| 10 | 1,403 | 46,284,800 |
186684648
|
n = int(input())
lines = []
for i in range(n):
line = list(map(int,input().split()))
lines.append([line[0],1])
lines.append([line[1]+1,-1]) # attention
lines.sort(key=lambda x:x[0])
res = [0 for _ in range(n)]
ans = 0
for i in range(1,2*n):
res[ans] += lines[i][0] - lines[i-1][0]
ans += lines[i][1]
print(" ".join(str(i) for i in res))
| 18 | 936 | 44,032,000 |
197134996
|
import sys
from array import array
input = lambda: sys.stdin.buffer.readline().decode().strip()
inp = lambda dtype: [dtype(x) for x in input().split()]
debug = lambda *x: print(*x, file=sys.stderr)
ceil_ = lambda a, b: (a + b - 1) // b
sum_n = lambda n: (n * (n + 1)) // 2
get_bit = lambda x, i: (x >> i) & 1
Mint, Mlong, out = 2 ** 31 - 1, 2 ** 63 - 1, []
for _ in range(1):
# 0->open , 1->close
n = int(input())
points, type_ = [], array('b')
for i in range(n):
l, r = inp(int)
points.extend([l, r])
type_.extend([1, 0])
ixs = sorted(range(n * 2), key=points.__getitem__)
ans, open = [0] * (n + 1), 0
i = 0
while i < n * 2:
old, new, isfirst = 0, 0, 1
if open:
ans[open] += points[ixs[i]] - points[ixs[i - 1]] - 1
while i < n * 2 and (isfirst or points[ixs[i]] == points[ixs[i - 1]]):
new += type_[ixs[i]]
old += type_[ixs[i]] ^ 1
i += 1
isfirst = 0
ans[new + open] += 1
open = open - old + new
out.append(' '.join(map(str, ans[1:])))
print('\n'.join(map(str, out)))
|
Educational Codeforces Round 46 (Rated for Div. 2)
|
ICPC
| 2,018 | 3 | 256 |
Covered Points Count
|
You are given $$$n$$$ segments on a coordinate line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
Your task is the following: for every $$$k \in [1..n]$$$, calculate the number of points with integer coordinates such that the number of segments that cover these points equals $$$k$$$. A segment with endpoints $$$l_i$$$ and $$$r_i$$$ covers point $$$x$$$ if and only if $$$l_i \le x \le r_i$$$.
|
The first line of the input contains one integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) — the number of segments.
The next $$$n$$$ lines contain segments. The $$$i$$$-th line contains a pair of integers $$$l_i, r_i$$$ ($$$0 \le l_i \le r_i \le 10^{18}$$$) — the endpoints of the $$$i$$$-th segment.
|
Print $$$n$$$ space separated integers $$$cnt_1, cnt_2, \dots, cnt_n$$$, where $$$cnt_i$$$ is equal to the number of points such that the number of segments that cover these points equals to $$$i$$$.
| null |
The picture describing the first example:
Points with coordinates $$$[0, 4, 5, 6, 7, 8]$$$ are covered by one segment, points $$$[1, 2]$$$ are covered by two segments and point $$$[3]$$$ is covered by three segments.
The picture describing the second example:
Points $$$[1, 4, 5, 6, 7]$$$ are covered by one segment, points $$$[2, 3]$$$ are covered by two segments and there are no points covered by three segments.
|
[{"input": "3\n0 3\n1 3\n3 8", "output": "6 2 1"}, {"input": "3\n1 3\n2 4\n5 7", "output": "5 2 0"}]
| 1,700 |
["data structures", "implementation", "sortings"]
| 18 |
[{"input": "3\r\n0 3\r\n1 3\r\n3 8\r\n", "output": "6 2 1 \r\n"}, {"input": "3\r\n1 3\r\n2 4\r\n5 7\r\n", "output": "5 2 0 \r\n"}, {"input": "1\r\n0 1000000000000000000\r\n", "output": "1000000000000000001 \r\n"}]
| false |
stdio
| null | true |
1000/C
|
1000
|
C
|
Python 3
|
TESTS
| 10 | 1,699 | 40,243,200 |
178631506
|
# Write your code here :-)
# Covered Points Count
from collections import Counter
n = int(input())
endpoints = set()
change = Counter()
for _ in range(n):
l, r = map(int, input().split())
endpoints.update((l, r + 1))
change[l] += 1
change[r + 1] -= 1
endpoints = sorted(endpoints)
cur_count = 0
ans = [0] * n
for i in range(len(endpoints) - 1):
cur_count += change[endpoints[i]]
ans[cur_count - 1] += endpoints[i + 1] - endpoints[i]
print(*ans)
| 18 | 1,559 | 31,027,200 |
39714395
|
n=int(input())
l=[0 for i in range(n+1)]
lo=[]
lc=[]
for i in range(n):
x,y=map(int,input().strip().split())
lo.append(x)
lc.append(y)
lo.sort()
lc.sort()
i=1
j=0
count=1
st=lo[0]
ref=0
while(i<n and j<n):
if (lo[i]<=lc[j]):
if ref==0:
l[count]=l[count]+lo[i]-st
else:
l[count]=l[count]+lo[i]-st-1
ref=0
count=count+1
st=lo[i]
i=i+1
else:
if (ref==0):
l[count]=l[count]+lc[j]-st+1
else:
l[count]=l[count]+lc[j]-st
count=count-1
ref=1
st=lc[j]
j=j+1
while(j<n):
if (ref==0):
l[count]=l[count]+lc[j]-st+1
else:
l[count]=l[count]+lc[j]-st
count=count-1
ref=1
st=lc[j]
j=j+1
print (" ".join(map(str,l[1:])))
|
Educational Codeforces Round 46 (Rated for Div. 2)
|
ICPC
| 2,018 | 3 | 256 |
Covered Points Count
|
You are given $$$n$$$ segments on a coordinate line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
Your task is the following: for every $$$k \in [1..n]$$$, calculate the number of points with integer coordinates such that the number of segments that cover these points equals $$$k$$$. A segment with endpoints $$$l_i$$$ and $$$r_i$$$ covers point $$$x$$$ if and only if $$$l_i \le x \le r_i$$$.
|
The first line of the input contains one integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) — the number of segments.
The next $$$n$$$ lines contain segments. The $$$i$$$-th line contains a pair of integers $$$l_i, r_i$$$ ($$$0 \le l_i \le r_i \le 10^{18}$$$) — the endpoints of the $$$i$$$-th segment.
|
Print $$$n$$$ space separated integers $$$cnt_1, cnt_2, \dots, cnt_n$$$, where $$$cnt_i$$$ is equal to the number of points such that the number of segments that cover these points equals to $$$i$$$.
| null |
The picture describing the first example:
Points with coordinates $$$[0, 4, 5, 6, 7, 8]$$$ are covered by one segment, points $$$[1, 2]$$$ are covered by two segments and point $$$[3]$$$ is covered by three segments.
The picture describing the second example:
Points $$$[1, 4, 5, 6, 7]$$$ are covered by one segment, points $$$[2, 3]$$$ are covered by two segments and there are no points covered by three segments.
|
[{"input": "3\n0 3\n1 3\n3 8", "output": "6 2 1"}, {"input": "3\n1 3\n2 4\n5 7", "output": "5 2 0"}]
| 1,700 |
["data structures", "implementation", "sortings"]
| 18 |
[{"input": "3\r\n0 3\r\n1 3\r\n3 8\r\n", "output": "6 2 1 \r\n"}, {"input": "3\r\n1 3\r\n2 4\r\n5 7\r\n", "output": "5 2 0 \r\n"}, {"input": "1\r\n0 1000000000000000000\r\n", "output": "1000000000000000001 \r\n"}]
| false |
stdio
| null | true |
194/B
|
194
|
B
|
Python 3
|
TESTS
| 3 | 218 | 512,000 |
7060737
|
t = int(input())
n = list(map(int,input().split()))
for i in range(t):
if n[i] % 2 == 0:
print((n[i]*4) + 1)
else:
print((n[i]*2) + 1)
| 8 | 77 | 5,427,200 |
180516435
|
from math import gcd
input()
for i in list(map(int, input().split())):
print(4 * i // gcd(4 * i, i + 1) + 1)
|
Codeforces Round 122 (Div. 2)
|
CF
| 2,012 | 2 | 256 |
Square
|
There is a square painted on a piece of paper, the square's side equals n meters. John Doe draws crosses on the square's perimeter. John paints the first cross in the lower left corner of the square. Then John moves along the square's perimeter in the clockwise direction (first upwards, then to the right, then downwards, then to the left and so on). Every time he walks (n + 1) meters, he draws a cross (see picture for clarifications).
John Doe stops only when the lower left corner of the square has two crosses. How many crosses will John draw?
The figure shows the order in which John draws crosses for a square with side 4. The lower left square has two crosses. Overall John paints 17 crosses.
|
The first line contains integer t (1 ≤ t ≤ 104) — the number of test cases.
The second line contains t space-separated integers ni (1 ≤ ni ≤ 109) — the sides of the square for each test sample.
|
For each test sample print on a single line the answer to it, that is, the number of crosses John will draw as he will move along the square of the corresponding size. Print the answers to the samples in the order in which the samples are given in the input.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
| null | null |
[{"input": "3\n4 8 100", "output": "17\n33\n401"}]
| 1,200 |
["math"]
| 8 |
[{"input": "3\r\n4 8 100\r\n", "output": "17\r\n33\r\n401\r\n"}, {"input": "8\r\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 13\r\n", "output": "4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n27\r\n"}, {"input": "3\r\n13 17 21\r\n", "output": "27\r\n35\r\n43\r\n"}]
| false |
stdio
| null | true |
545/B
|
545
|
B
|
Python 3
|
TESTS
| 0 | 30 | 0 |
194911722
|
def distance(a,b):
rast = 0
for i in range(len(a)):
if a[i] != b[i]:
rast += 1
return rast
def ravn(a,b):
while len(a) < len(b):
a = '0'+a
return a
a = '000'
b = '111'
i = 0
a1 = ''
try:
while len(a1)<=len(a):
i+=1
a1 = bin(i)
a1 = a1.replace('0b','')
a1 = ravn(a1,b)
if distance(a1,a) == distance(a1,b):
print(a)
break
except:
print('impossible')
| 54 | 109 | 409,600 |
11148464
|
s = input()
t = input()
sa = s.count('0')
sb = s.count('1')
ta = t.count('0')
tb = t.count('1')
n = len(s)
L = abs(sa - ta) + abs(sb - tb)
L /= 2
if L % 2 == 1:
print("impossible")
else:
ans = ''
c = 0
for i in range(n):
if s[i] == t[i]:
ans += s[i]
else:
if c == 0:
ans += s[i]
c = 1
else:
ans += t[i]
c = 0
print(ans)
|
Codeforces Round 303 (Div. 2)
|
CF
| 2,015 | 1 | 256 |
Equidistant String
|
Little Susie loves strings. Today she calculates distances between them. As Susie is a small girl after all, her strings contain only digits zero and one. She uses the definition of Hamming distance:
We will define the distance between two strings s and t of the same length consisting of digits zero and one as the number of positions i, such that si isn't equal to ti.
As besides everything else Susie loves symmetry, she wants to find for two strings s and t of length n such string p of length n, that the distance from p to s was equal to the distance from p to t.
It's time for Susie to go to bed, help her find such string p or state that it is impossible.
|
The first line contains string s of length n.
The second line contains string t of length n.
The length of string n is within range from 1 to 105. It is guaranteed that both strings contain only digits zero and one.
|
Print a string of length n, consisting of digits zero and one, that meets the problem statement. If no such string exist, print on a single line "impossible" (without the quotes).
If there are multiple possible answers, print any of them.
| null |
In the first sample different answers are possible, namely — 0010, 0011, 0110, 0111, 1000, 1001, 1100, 1101.
|
[{"input": "0001\n1011", "output": "0011"}, {"input": "000\n111", "output": "impossible"}]
| 1,100 |
["greedy"]
| 54 |
[{"input": "0001\r\n1011\r\n", "output": "0011\r\n"}, {"input": "000\r\n111\r\n", "output": "impossible\r\n"}, {"input": "1010101011111110111111001111111111111111111111101101110111111111111110110110101011111110110111111101\r\n0101111111000100010100001100010101000000011000000000011011000001100100001110111011111000001110011111\r\n", "output": "1111101111101100110110001110110111010101011101001001010011101011101100100110111011111100100110111111\r\n"}, {"input": "0000000001000000000000100000100001000000\r\n1111111011111101111111111111111111111111\r\n", "output": "0101010011010100101010110101101011010101\r\n"}, {"input": "10101000101001001101010010000101100011010011000011001001001111110010100110000001111111\r\n01001011110111111101111011011111110000000111111001000011010101001010000111101010000101\r\n", "output": "11101010111101101101110011001101110010010111010001001011000111011010100111001000101101\r\n"}, {"input": "1111111111111111111111111110111111111111111111111111111111111110111111101111111111111111111111111111\r\n1111111111111111111001111111110010111111111111111111001111111111111111111111111111111111111111111111\r\n", "output": "1111111111111111111101111110110110111111111111111111101111111110111111111111111111111111111111111111\r\n"}, {"input": "0000000000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111\r\n1111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000\r\n", "output": "0101010101010101010101000000101010101010101010101010101010101010101010101010101010101010101010101010\r\n"}, {"input": "00001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111\r\n11111100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\r\n", "output": "01011110101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010\r\n"}, {"input": "0\r\n0\r\n", "output": "0\r\n"}, {"input": "0\r\n1\r\n", "output": "impossible\r\n"}, {"input": "1\r\n1\r\n", "output": "1\r\n"}, {"input": "1\r\n0\r\n", "output": "impossible\r\n"}, {"input": "1111\r\n0000\r\n", "output": "1010\r\n"}, {"input": "1111\r\n1001\r\n", "output": "1101\r\n"}, {"input": "0000\r\n1111\r\n", "output": "0101\r\n"}, {"input": "1010\r\n0101\r\n", "output": "1111\r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(input_path, 'r') as f:
s = f.readline().strip()
t = f.readline().strip()
n = len(s)
assert len(t) == n
with open(submission_path, 'r') as f:
submission_lines = f.readlines()
if len(submission_lines) == 0:
submission = ''
elif len(submission_lines) == 1:
submission = submission_lines[0].rstrip('\n')
else:
print(0)
return
if submission == 'impossible':
d = sum(c1 != c2 for c1, c2 in zip(s, t))
if d % 2 == 1:
print(1)
else:
print(0)
return
else:
if len(submission) != n:
print(0)
return
if any(c not in {'0', '1'} for c in submission):
print(0)
return
d_s = sum(c != pc for c, pc in zip(s, submission))
d_t = sum(c != pc for c, pc in zip(t, submission))
if d_s == d_t:
print(1)
else:
print(0)
return
if __name__ == '__main__':
main()
| true |
1000/C
|
1000
|
C
|
PyPy 3-64
|
TESTS
| 10 | 1,824 | 69,222,400 |
217776662
|
import sys
input = lambda: sys.stdin.readline().rstrip()
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations
from bisect import *
from heapq import *
from math import ceil,gcd,lcm,floor,comb
alph = 'abcdefghijklmnopqrstuvwxyz'
#pow(x,mod-2,mod)
N = int(input())
A = []
for _ in range(N):
a,b = map(int,input().split())
A.append([a,1])
A.append([b+1,-1])
A.sort(reverse=True)
ans = [0]*N
pre,cnt = A.pop()
for _ in range(2*N-1):
a,b = A.pop()
ans[cnt-1]+=(a-pre)
cnt+=b
pre = a
print(*ans)
| 18 | 1,731 | 85,401,600 |
187055982
|
import collections
if __name__ == '__main__':
n = int(input())
a = collections.defaultdict(int)
# O(n) loop
for _ in range(n):
start, end = [int(x) for x in input().split()]
a[start] += 1
a[end + 1] -= 1
# print(a)
# takes n*long(n) for sorting
key_points = sorted(a.keys())
# print(key_points)
# prefix sum s
s = collections.defaultdict(int)
i, prev = 0, 0
# O(n) loop
for p in key_points:
if i == 0:
s[p] = a[p]
else:
s[p] = prev + a[p]
prev = s[p]
i += 1
# print(s)
# python dict maintain insert order, in this case key already order
cnt = collections.defaultdict(int)
i, prev_k, prev_v = 0, 0, 0
for k, v in s.items():
if i > 0:
cnt[prev_v] += k - prev_k
prev_k, prev_v = k, v
i += 1
# print(cnt)
for i in range(1, n + 1):
print(cnt[i], end=" ")
|
Educational Codeforces Round 46 (Rated for Div. 2)
|
ICPC
| 2,018 | 3 | 256 |
Covered Points Count
|
You are given $$$n$$$ segments on a coordinate line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
Your task is the following: for every $$$k \in [1..n]$$$, calculate the number of points with integer coordinates such that the number of segments that cover these points equals $$$k$$$. A segment with endpoints $$$l_i$$$ and $$$r_i$$$ covers point $$$x$$$ if and only if $$$l_i \le x \le r_i$$$.
|
The first line of the input contains one integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) — the number of segments.
The next $$$n$$$ lines contain segments. The $$$i$$$-th line contains a pair of integers $$$l_i, r_i$$$ ($$$0 \le l_i \le r_i \le 10^{18}$$$) — the endpoints of the $$$i$$$-th segment.
|
Print $$$n$$$ space separated integers $$$cnt_1, cnt_2, \dots, cnt_n$$$, where $$$cnt_i$$$ is equal to the number of points such that the number of segments that cover these points equals to $$$i$$$.
| null |
The picture describing the first example:
Points with coordinates $$$[0, 4, 5, 6, 7, 8]$$$ are covered by one segment, points $$$[1, 2]$$$ are covered by two segments and point $$$[3]$$$ is covered by three segments.
The picture describing the second example:
Points $$$[1, 4, 5, 6, 7]$$$ are covered by one segment, points $$$[2, 3]$$$ are covered by two segments and there are no points covered by three segments.
|
[{"input": "3\n0 3\n1 3\n3 8", "output": "6 2 1"}, {"input": "3\n1 3\n2 4\n5 7", "output": "5 2 0"}]
| 1,700 |
["data structures", "implementation", "sortings"]
| 18 |
[{"input": "3\r\n0 3\r\n1 3\r\n3 8\r\n", "output": "6 2 1 \r\n"}, {"input": "3\r\n1 3\r\n2 4\r\n5 7\r\n", "output": "5 2 0 \r\n"}, {"input": "1\r\n0 1000000000000000000\r\n", "output": "1000000000000000001 \r\n"}]
| false |
stdio
| null | true |
1000/C
|
1000
|
C
|
PyPy 3-64
|
TESTS
| 3 | 280 | 41,164,800 |
212243374
|
import sys
input = sys.stdin.readline
n = int(input())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
a.sort()
ans = [0] * (n)
ans[0] = a[0][1] - a[0][0] + 1
for i in range(1, n):
ans[i] += min(a[i][1], a[i - 1][1]) - a[i][0] + 1
ans[i - 1] -= ans[i]
ans[0] += max(0, a[i][1] - a[i - 1][1])
print(*ans)
| 18 | 1,793 | 80,793,600 |
217500762
|
import sys
input = lambda: sys.stdin.readline().rstrip()
import math
from heapq import heappush , heappop
from collections import defaultdict,deque,Counter
N = int(input())
A = []
for _ in range(N):
l,r = map(int, input().split())
A.append((l,1))
A.append((r+1,-1))
lib = defaultdict(int)
A.sort()
cur = 0
for i,c in A:
if c==1:
cur+=1
else:
cur-=1
lib[i]=cur
B = []
for k,v in lib.items():
B.append((k,v))
B.sort()
prei,prec = A[0][0],A[0][1]
ans = [0]*(N+1)
for i,c in B:
if prec==c:continue
ans[prec]+=i-prei
prei = i
prec = c
print(*ans[1:])
|
Educational Codeforces Round 46 (Rated for Div. 2)
|
ICPC
| 2,018 | 3 | 256 |
Covered Points Count
|
You are given $$$n$$$ segments on a coordinate line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
Your task is the following: for every $$$k \in [1..n]$$$, calculate the number of points with integer coordinates such that the number of segments that cover these points equals $$$k$$$. A segment with endpoints $$$l_i$$$ and $$$r_i$$$ covers point $$$x$$$ if and only if $$$l_i \le x \le r_i$$$.
|
The first line of the input contains one integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) — the number of segments.
The next $$$n$$$ lines contain segments. The $$$i$$$-th line contains a pair of integers $$$l_i, r_i$$$ ($$$0 \le l_i \le r_i \le 10^{18}$$$) — the endpoints of the $$$i$$$-th segment.
|
Print $$$n$$$ space separated integers $$$cnt_1, cnt_2, \dots, cnt_n$$$, where $$$cnt_i$$$ is equal to the number of points such that the number of segments that cover these points equals to $$$i$$$.
| null |
The picture describing the first example:
Points with coordinates $$$[0, 4, 5, 6, 7, 8]$$$ are covered by one segment, points $$$[1, 2]$$$ are covered by two segments and point $$$[3]$$$ is covered by three segments.
The picture describing the second example:
Points $$$[1, 4, 5, 6, 7]$$$ are covered by one segment, points $$$[2, 3]$$$ are covered by two segments and there are no points covered by three segments.
|
[{"input": "3\n0 3\n1 3\n3 8", "output": "6 2 1"}, {"input": "3\n1 3\n2 4\n5 7", "output": "5 2 0"}]
| 1,700 |
["data structures", "implementation", "sortings"]
| 18 |
[{"input": "3\r\n0 3\r\n1 3\r\n3 8\r\n", "output": "6 2 1 \r\n"}, {"input": "3\r\n1 3\r\n2 4\r\n5 7\r\n", "output": "5 2 0 \r\n"}, {"input": "1\r\n0 1000000000000000000\r\n", "output": "1000000000000000001 \r\n"}]
| false |
stdio
| null | true |
400/A
|
400
|
A
|
PyPy 3
|
TESTS
| 1 | 108 | 2,355,200 |
222671942
|
t = int(input())
for l in range(t):
s = input()
l = []
for i in range(1, 13):
if 12 % i == 0:
for j in range(12 // i):
c = ""
for k in range(i):
c = c + s[(k * (12 // i)) + j]
if c == "X" * i:
l.append(f"{i}x{12 // i}")
print(len(l), " ".join(list(map(str, l))))
| 44 | 62 | 0 |
5934536
|
# http://codeforces.com/contest/400/problem/0
# Codeforces : A. Inna and choose options
liste_a = (1, 2, 3, 4, 6, 12)
liste_results = []
def process(essai):
global liste_results
liste_av = [0]
for a in liste_a:
b = 12 // a
for r in range(b):
if essai[r::b] == 'X'*a:
liste_av[0] += 1
liste_av.append('{}x{}'.format(a,b))
break
liste_av[0] = str(liste_av[0])
liste_results.append(liste_av)
t = int(input())
for k in range(t):
essai = input()
process(essai)
for s in liste_results:
print(*s)
|
Codeforces Round 234 (Div. 2)
|
CF
| 2,014 | 1 | 256 |
Inna and Choose Options
|
There always is something to choose from! And now, instead of "Noughts and Crosses", Inna choose a very unusual upgrade of this game. The rules of the game are given below:
There is one person playing the game. Before the beginning of the game he puts 12 cards in a row on the table. Each card contains a character: "X" or "O". Then the player chooses two positive integers a and b (a·b = 12), after that he makes a table of size a × b from the cards he put on the table as follows: the first b cards form the first row of the table, the second b cards form the second row of the table and so on, the last b cards form the last (number a) row of the table. The player wins if some column of the table contain characters "X" on all cards. Otherwise, the player loses.
Inna has already put 12 cards on the table in a row. But unfortunately, she doesn't know what numbers a and b to choose. Help her win the game: print to her all the possible ways of numbers a, b that she can choose and win.
|
The first line of the input contains integer t (1 ≤ t ≤ 100). This value shows the number of sets of test data in the input. Next follows the description of each of the t tests on a separate line.
The description of each test is a string consisting of 12 characters, each character is either "X", or "O". The i-th character of the string shows the character that is written on the i-th card from the start.
|
For each test, print the answer to the test on a single line. The first number in the line must represent the number of distinct ways to choose the pair a, b. Next, print on this line the pairs in the format axb. Print the pairs in the order of increasing first parameter (a). Separate the pairs in the line by whitespaces.
| null | null |
[{"input": "4\nOXXXOXOOXOOX\nOXOXOXOXOXOX\nXXXXXXXXXXXX\nOOOOOOOOOOOO", "output": "3 1x12 2x6 4x3\n4 1x12 2x6 3x4 6x2\n6 1x12 2x6 3x4 4x3 6x2 12x1\n0"}]
| 1,000 |
["implementation"]
| 44 |
[{"input": "4\r\nOXXXOXOOXOOX\r\nOXOXOXOXOXOX\r\nXXXXXXXXXXXX\r\nOOOOOOOOOOOO\r\n", "output": "3 1x12 2x6 4x3\r\n4 1x12 2x6 3x4 6x2\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n0\r\n"}, {"input": "2\r\nOOOOOOOOOOOO\r\nXXXXXXXXXXXX\r\n", "output": "0\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n"}, {"input": "13\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\n", "output": "6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n"}]
| false |
stdio
| null | true |
400/A
|
400
|
A
|
PyPy 3
|
TESTS
| 1 | 93 | 20,172,800 |
115899395
|
for _ in range(int(input())):
s=list(input())
n=len(s)
ans=[]
d=[1,2,3,4,6,12]
for item in d:
z=item-1
for i in range(z,n,item):
if s[i]!='X':
break
else:
ans.append((12//item,item))
print(len(ans),end=' ')
ans.sort()
for item in ans:
print(f'{item[0]}x{item[1]}',end=' ')
print()
| 44 | 62 | 0 |
5935369
|
for _ in range(int(input())):
cards = input()
count = 0
output = ''
if 'X' in cards:
count += 1
output += ' 1x12'
for q, p in zip(cards[:6], cards[6:]):
if q == p == 'X':
count += 1
output += ' 2x6'
break
for q, p, r in zip(cards[:4], cards[4:8], cards[8:]):
if q == p == r == 'X':
count += 1
output += ' 3x4'
break
for q, p, r, s in zip(cards[:3], cards[3:6], cards[6:9], cards[9:]):
if q == p == r == s == 'X':
count += 1
output += ' 4x3'
break
for q, p, r, s, t, u in zip(cards[:2], cards[2:4], cards[4:6], cards[6:8], cards[8:10], cards[10:]):
if q == p == r == s == t == u == 'X':
count += 1
output += ' 6x2'
break
if 'O' not in cards:
count += 1
output += ' 12x1'
print(str(count) + output)
|
Codeforces Round 234 (Div. 2)
|
CF
| 2,014 | 1 | 256 |
Inna and Choose Options
|
There always is something to choose from! And now, instead of "Noughts and Crosses", Inna choose a very unusual upgrade of this game. The rules of the game are given below:
There is one person playing the game. Before the beginning of the game he puts 12 cards in a row on the table. Each card contains a character: "X" or "O". Then the player chooses two positive integers a and b (a·b = 12), after that he makes a table of size a × b from the cards he put on the table as follows: the first b cards form the first row of the table, the second b cards form the second row of the table and so on, the last b cards form the last (number a) row of the table. The player wins if some column of the table contain characters "X" on all cards. Otherwise, the player loses.
Inna has already put 12 cards on the table in a row. But unfortunately, she doesn't know what numbers a and b to choose. Help her win the game: print to her all the possible ways of numbers a, b that she can choose and win.
|
The first line of the input contains integer t (1 ≤ t ≤ 100). This value shows the number of sets of test data in the input. Next follows the description of each of the t tests on a separate line.
The description of each test is a string consisting of 12 characters, each character is either "X", or "O". The i-th character of the string shows the character that is written on the i-th card from the start.
|
For each test, print the answer to the test on a single line. The first number in the line must represent the number of distinct ways to choose the pair a, b. Next, print on this line the pairs in the format axb. Print the pairs in the order of increasing first parameter (a). Separate the pairs in the line by whitespaces.
| null | null |
[{"input": "4\nOXXXOXOOXOOX\nOXOXOXOXOXOX\nXXXXXXXXXXXX\nOOOOOOOOOOOO", "output": "3 1x12 2x6 4x3\n4 1x12 2x6 3x4 6x2\n6 1x12 2x6 3x4 4x3 6x2 12x1\n0"}]
| 1,000 |
["implementation"]
| 44 |
[{"input": "4\r\nOXXXOXOOXOOX\r\nOXOXOXOXOXOX\r\nXXXXXXXXXXXX\r\nOOOOOOOOOOOO\r\n", "output": "3 1x12 2x6 4x3\r\n4 1x12 2x6 3x4 6x2\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n0\r\n"}, {"input": "2\r\nOOOOOOOOOOOO\r\nXXXXXXXXXXXX\r\n", "output": "0\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n"}, {"input": "13\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\nXXXXXXXXXXXX\r\n", "output": "6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n6 1x12 2x6 3x4 4x3 6x2 12x1\r\n"}]
| false |
stdio
| null | true |
627/B
|
627
|
B
|
Python 3
|
TESTS
| 3 | 1,388 | 409,600 |
51967316
|
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def add(a,x,v):
while x<len(a):
a[x] += v
x |= x+1
def get(a,x):
r = 0
while x>=0:
r += a[x]
x = (x&(x+1))-1
return r
n, k, a, b, q = mints()
h1 = [0]*n
h2 = [0]*n
z = [0]*n
for i in range(q):
t = tuple(mints())
if t[0] == 1:
p = z[t[1]-1]
pp = p + t[2]
add(h1, t[1]-1, min(a,pp)-min(a,p))
add(h2, t[1]-1, min(b,pp)-min(b,p))
else:
print(get(h2,t[1]-2)+get(h1,n-1)-get(h1,t[1]+k-2))
| 42 | 2,433 | 18,739,200 |
209762436
|
N = 4 * 10**5 + 10
s = [[0] * N for i in range(2)]
x, y = [0] * N, [0] * N
def modify(q : int, x: int, v: int, n: int) -> None:
while x <= n:
s[q][x] += v
x = (x | (x - 1)) + 1
def find_sum(q: int, x: int) -> int:
ret = 0
while x > 0:
ret += s[q][x]
x &= x - 1
return ret
n, k, a, b, q = map(int, input().split())
for _ in range(q):
ls = list(map(int, input().split()))
if ls[0] == 1:
day, cnt = ls[1:]
new_x = min(b, cnt + x[day])
new_y = min(a, cnt + y[day])
modify(0, day, new_x - x[day], n)
modify(1, day, new_y - y[day], n)
x[day], y[day] = new_x, new_y
else:
fr = ls[1]
to = fr + k - 1
ans = find_sum(0, fr - 1)
ans += find_sum(1, n) - find_sum(1, to)
print(ans)
|
8VC Venture Cup 2016 - Final Round
|
CF
| 2,016 | 4 | 256 |
Factory Repairs
|
A factory produces thimbles in bulk. Typically, it can produce up to a thimbles a day. However, some of the machinery is defective, so it can currently only produce b thimbles each day. The factory intends to choose a k-day period to do maintenance and construction; it cannot produce any thimbles during this time, but will be restored to its full production of a thimbles per day after the k days are complete.
Initially, no orders are pending. The factory receives updates of the form di, ai, indicating that ai new orders have been placed for the di-th day. Each order requires a single thimble to be produced on precisely the specified day. The factory may opt to fill as many or as few of the orders in a single batch as it likes.
As orders come in, the factory owner would like to know the maximum number of orders he will be able to fill if he starts repairs on a given day pi. Help the owner answer his questions.
|
The first line contains five integers n, k, a, b, and q (1 ≤ k ≤ n ≤ 200 000, 1 ≤ b < a ≤ 10 000, 1 ≤ q ≤ 200 000) — the number of days, the length of the repair time, the production rates of the factory, and the number of updates, respectively.
The next q lines contain the descriptions of the queries. Each query is of one of the following two forms:
- 1 di ai (1 ≤ di ≤ n, 1 ≤ ai ≤ 10 000), representing an update of ai orders on day di, or
- 2 pi (1 ≤ pi ≤ n - k + 1), representing a question: at the moment, how many orders could be filled if the factory decided to commence repairs on day pi?
It's guaranteed that the input will contain at least one query of the second type.
|
For each query of the second type, print a line containing a single integer — the maximum number of orders that the factory can fill over all n days.
| null |
Consider the first sample.
We produce up to 1 thimble a day currently and will produce up to 2 thimbles a day after repairs. Repairs take 2 days.
For the first question, we are able to fill 1 order on day 1, no orders on days 2 and 3 since we are repairing, no orders on day 4 since no thimbles have been ordered for that day, and 2 orders for day 5 since we are limited to our production capacity, for a total of 3 orders filled.
For the third question, we are able to fill 1 order on day 1, 1 order on day 2, and 2 orders on day 5, for a total of 4 orders.
|
[{"input": "5 2 2 1 8\n1 1 2\n1 5 3\n1 2 1\n2 2\n1 4 2\n1 3 2\n2 1\n2 3", "output": "3\n6\n4"}, {"input": "5 4 10 1 6\n1 1 5\n1 5 5\n1 3 2\n1 5 2\n2 1\n2 2", "output": "7\n1"}]
| 1,700 |
["data structures"]
| 42 |
[{"input": "5 2 2 1 8\r\n1 1 2\r\n1 5 3\r\n1 2 1\r\n2 2\r\n1 4 2\r\n1 3 2\r\n2 1\r\n2 3\r\n", "output": "3\r\n6\r\n4\r\n"}, {"input": "5 4 10 1 6\r\n1 1 5\r\n1 5 5\r\n1 3 2\r\n1 5 2\r\n2 1\r\n2 2\r\n", "output": "7\r\n1\r\n"}, {"input": "1 1 2 1 1\r\n2 1\r\n", "output": "0\r\n"}]
| false |
stdio
| null | true |
237/D
|
237
|
D
|
PyPy 3
|
TESTS
| 3 | 184 | 0 |
110451051
|
n=int(input())
adj = [[] for _ in range(n+5)]
for _ in range(n-1):
u, v = map(int,(input().split()))
adj[u].append(v)
adj[v].append(u)
nodes = []
edges = []
def solve(cur, idx):
fi, se = cur
for u in adj[se]:
if(u is fi):
continue
nodes.append((u, se))
edges.append((idx,len(nodes)))
for i in range(n+1):
if(len(adj[i]) is 1):
nodes.append((i,adj[i][0]))
solve((i,adj[i][0]), 1)
break
print(len(nodes))
for fi, se in nodes:
print(2, fi, se)
for fi, se in edges:
print(fi, se)
| 40 | 1,090 | 112,537,600 |
142574146
|
from bisect import bisect_right
from collections import defaultdict
import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
from collections import defaultdict
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
sys.setrecursionlimit(10**5)
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
@bootstrap
def dfs(u,p):
global curr
for j in adj[u]:
if(j!=p):
l=last[u]
if(l==0):
pass
else:
edges.append([l,curr])
last[u] = curr
last[j] = curr
ty.append([2, u, j])
curr+=1
for j in adj[u]:
if(j!=p):
yield dfs(j,u)
yield
n=int(input())
adj=[[] for i in range(n+1)]
for j in range(n-1):
u,v=map(int,input().split())
adj[u].append(v)
adj[v].append(u)
last=[0 for i in range(n+1)]
curr=1
edges=[]
ty=[]
dfs(1,0)
print(n-1)
for j in ty:
print(*j)
for j in edges:
print(*j)
|
Codeforces Round 147 (Div. 2)
|
CF
| 2,012 | 2 | 256 |
T-decomposition
|
You've got a undirected tree s, consisting of n nodes. Your task is to build an optimal T-decomposition for it. Let's define a T-decomposition as follows.
Let's denote the set of all nodes s as v. Let's consider an undirected tree t, whose nodes are some non-empty subsets of v, we'll call them xi $$( x _ { i } \subseteq v )$$. The tree t is a T-decomposition of s, if the following conditions holds:
1. the union of all xi equals v;
2. for any edge (a, b) of tree s exists the tree node t, containing both a and b;
3. if the nodes of the tree t xi and xj contain the node a of the tree s, then all nodes of the tree t, lying on the path from xi to xj also contain node a. So this condition is equivalent to the following: all nodes of the tree t, that contain node a of the tree s, form a connected subtree of tree t.
There are obviously many distinct trees t, that are T-decompositions of the tree s. For example, a T-decomposition is a tree that consists of a single node, equal to set v.
Let's define the cardinality of node xi as the number of nodes in tree s, containing in the node. Let's choose the node with the maximum cardinality in t. Let's assume that its cardinality equals w. Then the weight of T-decomposition t is value w. The optimal T-decomposition is the one with the minimum weight.
Your task is to find the optimal T-decomposition of the given tree s that has the minimum number of nodes.
|
The first line contains a single integer n (2 ≤ n ≤ 105), that denotes the number of nodes in tree s.
Each of the following n - 1 lines contains two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi), denoting that the nodes of tree s with indices ai and bi are connected by an edge.
Consider the nodes of tree s indexed from 1 to n. It is guaranteed that s is a tree.
|
In the first line print a single integer m that denotes the number of nodes in the required T-decomposition.
Then print m lines, containing descriptions of the T-decomposition nodes. In the i-th (1 ≤ i ≤ m) of them print the description of node xi of the T-decomposition. The description of each node xi should start from an integer ki, that represents the number of nodes of the initial tree s, that are contained in the node xi. Then you should print ki distinct space-separated integers — the numbers of nodes from s, contained in xi, in arbitrary order.
Then print m - 1 lines, each consisting two integers pi, qi (1 ≤ pi, qi ≤ m; pi ≠ qi). The pair of integers pi, qi means there is an edge between nodes xpi and xqi of T-decomposition.
The printed T-decomposition should be the optimal T-decomposition for the given tree s and have the minimum possible number of nodes among all optimal T-decompositions. If there are multiple optimal T-decompositions with the minimum number of nodes, print any of them.
| null | null |
[{"input": "2\n1 2", "output": "1\n2 1 2"}, {"input": "3\n1 2\n2 3", "output": "2\n2 1 2\n2 2 3\n1 2"}, {"input": "4\n2 1\n3 1\n4 1", "output": "3\n2 2 1\n2 3 1\n2 4 1\n1 2\n2 3"}]
| 2,000 |
["dfs and similar", "graphs", "greedy", "trees"]
| 40 |
[{"input": "2\r\n1 2\r\n", "output": "1\r\n2 1 2\r\n"}, {"input": "3\r\n1 2\r\n2 3\r\n", "output": "2\r\n2 1 2\r\n2 2 3\r\n1 2\r\n"}, {"input": "4\r\n2 1\r\n3 1\r\n4 1\r\n", "output": "3\r\n2 2 1\r\n2 3 1\r\n2 4 1\r\n1 2\r\n2 3\r\n"}, {"input": "6\r\n2 5\r\n4 3\r\n4 2\r\n4 6\r\n3 1\r\n", "output": "5\r\n2 2 5\r\n2 4 3\r\n2 4 2\r\n2 4 6\r\n2 3 1\r\n2 3\r\n1 3\r\n3 4\r\n2 5\r\n"}, {"input": "6\r\n3 6\r\n4 2\r\n3 4\r\n3 1\r\n6 5\r\n", "output": "5\r\n2 3 6\r\n2 4 2\r\n2 3 4\r\n2 3 1\r\n2 6 5\r\n1 3\r\n2 3\r\n3 4\r\n1 5\r\n"}, {"input": "6\r\n3 2\r\n6 5\r\n1 3\r\n1 4\r\n6 1\r\n", "output": "5\r\n2 3 2\r\n2 6 5\r\n2 1 3\r\n2 1 4\r\n2 6 1\r\n1 3\r\n3 4\r\n2 5\r\n4 5\r\n"}, {"input": "6\r\n5 3\r\n4 2\r\n5 6\r\n6 1\r\n5 4\r\n", "output": "5\r\n2 5 3\r\n2 4 2\r\n2 5 6\r\n2 6 1\r\n2 5 4\r\n1 3\r\n3 4\r\n3 5\r\n2 5\r\n"}, {"input": "5\r\n1 2\r\n1 3\r\n4 5\r\n4 1\r\n", "output": "4\r\n2 1 2\r\n2 1 3\r\n2 4 5\r\n2 4 1\r\n1 2\r\n3 4\r\n2 4\r\n"}, {"input": "5\r\n1 5\r\n5 3\r\n2 4\r\n4 1\r\n", "output": "4\r\n2 1 5\r\n2 5 3\r\n2 2 4\r\n2 4 1\r\n1 2\r\n3 4\r\n1 4\r\n"}, {"input": "5\r\n1 5\r\n5 2\r\n1 4\r\n1 3\r\n", "output": "4\r\n2 1 5\r\n2 5 2\r\n2 1 4\r\n2 1 3\r\n1 2\r\n1 3\r\n3 4\r\n"}, {"input": "4\r\n1 4\r\n3 1\r\n3 2\r\n", "output": "3\r\n2 1 4\r\n2 3 1\r\n2 3 2\r\n1 2\r\n2 3\r\n"}, {"input": "20\r\n19 2\r\n19 18\r\n20 9\r\n20 10\r\n18 4\r\n17 5\r\n17 13\r\n11 17\r\n20 3\r\n11 1\r\n18 7\r\n11 20\r\n20 16\r\n5 15\r\n19 6\r\n11 14\r\n20 8\r\n17 12\r\n11 19\r\n", "output": "19\n2 1 11\n2 11 17\n2 17 5\n2 5 15\n2 17 13\n2 17 12\n2 11 20\n2 20 9\n2 20 10\n2 20 3\n2 20 16\n2 20 8\n2 11 14\n2 11 19\n2 19 2\n2 19 18\n2 18 4\n2 18 7\n2 19 6\n3 4\n2 3\n3 5\n5 6\n7 8\n8 9\n9 10\n10 11\n11 12\n16 17\n17 18\n14 15\n15 16\n16 19\n1 2\n2 7\n7 13\n13 14\n"}, {"input": "21\r\n2 8\r\n9 15\r\n7 5\r\n14 6\r\n19 7\r\n9 1\r\n2 10\r\n16 14\r\n16 17\r\n19 2\r\n2 12\r\n19 11\r\n16 18\r\n2 13\r\n19 9\r\n19 16\r\n1 20\r\n14 21\r\n1 3\r\n2 4\r\n", "output": "20\n2 1 9\n2 9 15\n2 9 19\n2 19 7\n2 7 5\n2 19 2\n2 2 8\n2 2 10\n2 2 12\n2 2 13\n2 2 4\n2 19 11\n2 19 16\n2 16 14\n2 14 6\n2 14 21\n2 16 17\n2 16 18\n2 1 20\n2 1 3\n4 5\n6 7\n7 8\n8 9\n9 10\n10 11\n14 15\n15 16\n13 14\n14 17\n17 18\n3 4\n4 6\n6 12\n12 13\n1 2\n2 3\n1 19\n19 20\n"}, {"input": "22\r\n10 11\r\n8 10\r\n8 15\r\n3 17\r\n8 20\r\n15 5\r\n10 1\r\n10 13\r\n11 9\r\n19 3\r\n9 14\r\n5 7\r\n19 2\r\n8 18\r\n11 4\r\n15 22\r\n15 19\r\n15 6\r\n8 12\r\n17 21\r\n13 16\r\n", "output": "21\n2 1 10\n2 10 11\n2 11 9\n2 9 14\n2 11 4\n2 10 8\n2 8 15\n2 15 5\n2 5 7\n2 15 22\n2 15 19\n2 19 3\n2 3 17\n2 17 21\n2 19 2\n2 15 6\n2 8 20\n2 8 18\n2 8 12\n2 10 13\n2 13 16\n3 4\n2 3\n3 5\n8 9\n13 14\n12 13\n11 12\n12 15\n7 8\n8 10\n10 11\n11 16\n6 7\n7 17\n17 18\n18 19\n20 21\n1 2\n2 6\n6 20\n"}, {"input": "23\r\n10 19\r\n11 2\r\n15 18\r\n8 14\r\n15 7\r\n23 6\r\n21 5\r\n14 1\r\n10 13\r\n8 23\r\n19 16\r\n12 3\r\n8 10\r\n8 21\r\n14 11\r\n6 22\r\n7 8\r\n4 15\r\n9 12\r\n15 9\r\n1 20\r\n11 17\r\n", "output": "22\n2 1 14\n2 14 8\n2 8 23\n2 23 6\n2 6 22\n2 8 10\n2 10 19\n2 19 16\n2 10 13\n2 8 21\n2 21 5\n2 8 7\n2 7 15\n2 15 18\n2 15 4\n2 15 9\n2 9 12\n2 12 3\n2 14 11\n2 11 2\n2 11 17\n2 1 20\n4 5\n3 4\n7 8\n6 7\n7 9\n10 11\n17 18\n16 17\n13 14\n14 15\n15 16\n12 13\n2 3\n3 6\n6 10\n10 12\n19 20\n20 21\n1 2\n2 19\n1 22\n"}, {"input": "24\r\n12 22\r\n4 12\r\n11 9\r\n14 19\r\n20 3\r\n16 24\r\n3 14\r\n14 23\r\n15 8\r\n8 20\r\n1 11\r\n1 7\r\n11 13\r\n2 15\r\n3 10\r\n16 5\r\n14 21\r\n6 2\r\n11 16\r\n24 17\r\n8 1\r\n3 4\r\n7 18\r\n", "output": "23\n2 1 11\n2 11 9\n2 11 13\n2 11 16\n2 16 24\n2 24 17\n2 16 5\n2 1 7\n2 7 18\n2 1 8\n2 8 15\n2 15 2\n2 2 6\n2 8 20\n2 20 3\n2 3 14\n2 14 19\n2 14 23\n2 14 21\n2 3 10\n2 3 4\n2 4 12\n2 12 22\n5 6\n4 5\n5 7\n1 2\n2 3\n3 4\n8 9\n12 13\n11 12\n16 17\n17 18\n18 19\n22 23\n21 22\n15 16\n16 20\n20 21\n14 15\n10 11\n11 14\n1 8\n8 10\n"}, {"input": "25\r\n13 1\r\n4 17\r\n15 25\r\n3 21\r\n1 6\r\n1 9\r\n12 15\r\n13 4\r\n24 19\r\n22 24\r\n8 20\r\n4 11\r\n11 14\r\n17 16\r\n15 7\r\n23 3\r\n22 13\r\n3 5\r\n6 10\r\n16 18\r\n24 23\r\n10 2\r\n9 8\r\n7 22\r\n", "output": "24\n2 1 13\n2 13 4\n2 4 17\n2 17 16\n2 16 18\n2 4 11\n2 11 14\n2 13 22\n2 22 24\n2 24 19\n2 24 23\n2 23 3\n2 3 21\n2 3 5\n2 22 7\n2 7 15\n2 15 25\n2 15 12\n2 1 6\n2 6 10\n2 10 2\n2 1 9\n2 9 8\n2 8 20\n4 5\n3 4\n6 7\n2 3\n3 6\n12 13\n13 14\n11 12\n9 10\n10 11\n16 17\n17 18\n15 16\n8 9\n9 15\n1 2\n2 8\n20 21\n19 20\n23 24\n22 23\n1 19\n19 22\n"}]
| false |
stdio
|
import sys
from collections import deque
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
# Read input tree
with open(input_path, 'r') as f:
n = int(f.readline().strip())
original_edges = set()
for _ in range(n-1):
a, b = map(int, f.readline().strip().split())
if a > b:
a, b = b, a
original_edges.add( (a, b) )
# Read submission output
with open(submission_path, 'r') as f:
try:
m_line = f.readline().strip()
m = int(m_line)
except:
print(0)
return
if m != n-1:
print(0)
return
submission_nodes = []
submission_edges = set()
node_elements = []
for i in range(m):
parts = list(map(int, f.readline().strip().split()))
if not parts:
print(0)
return
ki = parts[0]
if ki != 2 or len(parts) != 3:
print(0)
return
elements = parts[1:]
if len(elements) != 2:
print(0)
return
u, v = elements
if u == v:
print(0)
return
a, b = sorted([u, v])
edge = (a, b)
if edge not in original_edges:
print(0)
return
submission_edges.add(edge)
node_elements.append( (a, b) )
# Check all original edges are covered
if submission_edges != original_edges:
print(0)
return
# Read decomposition tree edges
adj = [[] for _ in range(m+1)]
edges = set()
for _ in range(m-1):
try:
line = f.readline().strip()
if not line:
print(0)
return
p, q = map(int, line.split())
except:
print(0)
return
if p < 1 or p > m or q < 1 or q > m or p == q:
print(0)
return
if (p, q) in edges or (q, p) in edges:
print(0)
return
edges.add( (p, q) )
adj[p].append(q)
adj[q].append(p)
# Check decomposition tree is connected and has m-1 edges
visited = [False]*(m+1)
q = deque()
q.append(1)
visited[1] = True
count = 1
while q:
u = q.popleft()
for v in adj[u]:
if not visited[v]:
visited[v] = True
count +=1
q.append(v)
if count != m:
print(0)
return
# For each original node a, check connected subtree
a_to_nodes = [[] for _ in range(n+1)]
for node_idx in range(1, m+1):
a, b = node_elements[node_idx-1]
a_to_nodes[a].append(node_idx)
a_to_nodes[b].append(node_idx)
for a in range(1, n+1):
nodes = a_to_nodes[a]
if not nodes:
print(0)
return
visited = set()
q = deque()
q.append(nodes[0])
visited.add(nodes[0])
while q:
u = q.popleft()
for v in adj[u]:
if v in nodes and v not in visited:
visited.add(v)
q.append(v)
if len(visited) != len(nodes):
print(0)
return
print(1)
if __name__ == "__main__":
main()
| true |
855/C
|
855
|
C
|
PyPy 3-64
|
TESTS
| 3 | 77 | 0 |
140099447
|
import sys
import os
from io import BytesIO, IOBase
from _collections import deque
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if sys.version_info[0] < 3:
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
f = sys.stdin
if os.environ.get('USER') == "loic":
f = open("data.in")
line = lambda: f.readline().split()
ui = lambda: int(line()[0])
ti = lambda: map(int,line())
li = lambda: list(ti())
#######################################################################
def solve():
dp_eq_k = [[0 for _ in range(X+1)] for _ in range((N))]
dp_inf_k = [[0 for _ in range(X+1)] for _ in range((N))]
dp_sup_k = [[0 for _ in range(X+1)] for _ in range((N))]
start = 0
seen = [-1] * len(G)
q = deque([start])
seen[start] = 0
par = [None] * len(G)
while q:
n = q[-1]
chs = G[n]
if seen[n] == (len(chs) - 1 if par[n] is not None else len(chs)):
n = q.pop()
chs = [ch for ch in G[n] if ch != par[n]]
if len(chs) == 0:
dp_eq_k[n][1] = 1
dp_inf_k[n][0] = K - 1
dp_sup_k[n][0] = M - K
else:
eq_k = [0] * (X+1)
inf_k = [0] * (X+1)
sup_k = [0] * (X+1)
cur_eq_k = dp_eq_k[chs[0]]
cur_inf_k = dp_inf_k[chs[0]]
cur_sup_k = dp_sup_k[chs[0]]
for ch in chs[1:]:
nxt_eq_k = dp_eq_k[ch]
nxt_inf_k = dp_inf_k[ch]
nxt_sup_k = dp_sup_k[ch]
for j in range(X+1):
for k in range(X+1):
if j+k > X:
continue
a = (cur_inf_k[j] + cur_sup_k[j]) % MOD
b = (nxt_inf_k[k] + nxt_sup_k[k]) % MOD
sup_k[j+k] = (sup_k[j+k] + a * b)% MOD
sup_k[j+k] = (sup_k[j+k] * (M-K)) % MOD
a = (cur_inf_k[j] + cur_sup_k[j] + cur_eq_k[j]) % MOD
b = (nxt_inf_k[k] + nxt_sup_k[k] + nxt_eq_k[k]) % MOD
inf_k[j+k] = (inf_k[j+k] + (a * b)) % MOD
inf_k[j+k] = (inf_k[j+k] * (K-1)) % MOD
if j+k+1 <= X:
eq_k[j+k+1] = (eq_k[j+k+1] + cur_inf_k[j] * nxt_inf_k[k]) % MOD
cur_eq_k = eq_k
cur_sup_k = sup_k
cur_inf_k = inf_k
dp_eq_k[n] = cur_eq_k
dp_sup_k[n] = cur_sup_k
dp_inf_k[n] = cur_inf_k
else:
for ch in reversed(chs):
if seen[ch] == -1:
seen[ch] = 0
par[ch] = n
q.append(ch)
if ch != par[n]:
seen[n] += 1
res = 0
for j in range(X+1):
res = (res + dp_eq_k[n][j]) % MOD
res = (res + dp_inf_k[n][j]) % MOD
res = (res + dp_sup_k[n][j]) % MOD
return str(res)
MOD = 10**9 + 7
for test in range(1,1+1):
N,M = ti()
G = [[] for _ in range(N)]
for _ in range(N-1):
u,v = ti()
u -= 1
v -= 1
G[u].append(v)
G[v].append(u)
K,X = ti()
print(solve())
f.close()
| 71 | 857 | 73,113,600 |
140174254
|
import sys
import os
from io import BytesIO, IOBase
from _collections import deque
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if sys.version_info[0] < 3:
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
f = sys.stdin
if os.environ.get('USER') == "loic":
f = open("data.in")
line = lambda: f.readline().split()
ui = lambda: int(line()[0])
ti = lambda: map(int,line())
li = lambda: list(ti())
#######################################################################
def solve():
dp_eq_k = [[0 for _ in range(X+1)] for _ in range((N))]
dp_inf_k = [[0 for _ in range(X+1)] for _ in range((N))]
dp_sup_k = [[0 for _ in range(X+1)] for _ in range((N))]
start = 0
seen = [-1] * len(G)
q = deque([start])
seen[start] = 0
par = [None] * len(G)
while q:
n = q[-1]
chs = G[n]
if seen[n] == (len(chs) - 1 if par[n] is not None else len(chs)):
n = q.pop()
chs = [ch for ch in G[n] if ch != par[n]]
if len(chs) == 0:
dp_eq_k[n][1] = 1
dp_inf_k[n][0] = K - 1
dp_sup_k[n][0] = M - K
else:
eq_k = [0] * (X+1)
inf_k = [0] * (X+1)
sup_k = [0] * (X+1)
eq_k[0] = 1
inf_k[0] = 1
sup_k[0] = 1
for ch in chs:
tmp_eq_k = [0] * (X+1)
tmp_inf_k = [0] * (X+1)
tmp_sup_k = [0] * (X+1)
nxt_eq_k = dp_eq_k[ch]
nxt_inf_k = dp_inf_k[ch]
nxt_sup_k = dp_sup_k[ch]
for j in range(X+1):
for k in range(X+1):
if j+k > X:
continue
tmp_sup_k[j+k] += (sup_k[j] * (nxt_inf_k[k] + nxt_sup_k[k])) % MOD
tmp_sup_k[j+k] %= MOD
tmp_inf_k[j+k] += (inf_k[j] * (nxt_inf_k[k] + nxt_sup_k[k] + nxt_eq_k[k])) % MOD
tmp_inf_k[j+k] %= MOD
tmp_eq_k[j+k] += (eq_k[j] * nxt_inf_k[k]) % MOD
tmp_eq_k[j+k] %= MOD
eq_k = tmp_eq_k
inf_k = tmp_inf_k
sup_k = tmp_sup_k
for j in range(X+1):
if j > 0:
dp_eq_k[n][j] = eq_k[j-1]
dp_sup_k[n][j] = (sup_k[j] * (M-K)) % MOD
dp_inf_k[n][j] = (inf_k[j] * (K-1)) % MOD
else:
for ch in reversed(chs):
if seen[ch] == -1:
seen[ch] = 0
par[ch] = n
q.append(ch)
if ch != par[n]:
seen[n] += 1
res = 0
for j in range(X+1):
res = (res + dp_eq_k[n][j]) % MOD
res = (res + dp_inf_k[n][j]) % MOD
res = (res + dp_sup_k[n][j]) % MOD
return str(res)
MOD = 10**9 + 7
for test in range(1,1+1):
N,M = ti()
G = [[] for _ in range(N)]
for _ in range(N-1):
u,v = ti()
u -= 1
v -= 1
G[u].append(v)
G[v].append(u)
K,X = ti()
print(solve())
f.close()
|
Manthan, Codefest 17
|
CF
| 2,017 | 2 | 256 |
Helga Hufflepuff's Cup
|
Harry, Ron and Hermione have figured out that Helga Hufflepuff's cup is a horcrux. Through her encounter with Bellatrix Lestrange, Hermione came to know that the cup is present in Bellatrix's family vault in Gringott's Wizarding Bank.
The Wizarding bank is in the form of a tree with total n vaults where each vault has some type, denoted by a number between 1 to m. A tree is an undirected connected graph with no cycles.
The vaults with the highest security are of type k, and all vaults of type k have the highest security.
There can be at most x vaults of highest security.
Also, if a vault is of the highest security, its adjacent vaults are guaranteed to not be of the highest security and their type is guaranteed to be less than k.
Harry wants to consider every possibility so that he can easily find the best path to reach Bellatrix's vault. So, you have to tell him, given the tree structure of Gringotts, the number of possible ways of giving each vault a type such that the above conditions hold.
|
The first line of input contains two space separated integers, n and m — the number of vaults and the number of different vault types possible. (1 ≤ n ≤ 105, 1 ≤ m ≤ 109).
Each of the next n - 1 lines contain two space separated integers ui and vi (1 ≤ ui, vi ≤ n) representing the i-th edge, which shows there is a path between the two vaults ui and vi. It is guaranteed that the given graph is a tree.
The last line of input contains two integers k and x (1 ≤ k ≤ m, 1 ≤ x ≤ 10), the type of the highest security vault and the maximum possible number of vaults of highest security.
|
Output a single integer, the number of ways of giving each vault a type following the conditions modulo 109 + 7.
| null |
In test case 1, we cannot have any vault of the highest security as its type is 1 implying that its adjacent vaults would have to have a vault type less than 1, which is not allowed. Thus, there is only one possible combination, in which all the vaults have type 2.
|
[{"input": "4 2\n1 2\n2 3\n1 4\n1 2", "output": "1"}, {"input": "3 3\n1 2\n1 3\n2 1", "output": "13"}, {"input": "3 1\n1 2\n1 3\n1 1", "output": "0"}]
| 2,000 |
["dp", "trees"]
| 71 |
[{"input": "4 2\r\n1 2\r\n2 3\r\n1 4\r\n1 2\r\n", "output": "1\r\n"}, {"input": "3 3\r\n1 2\r\n1 3\r\n2 1\r\n", "output": "13\r\n"}, {"input": "3 1\r\n1 2\r\n1 3\r\n1 1\r\n", "output": "0\r\n"}, {"input": "3 1000000000\r\n2 3\r\n3 1\r\n585430050 9\r\n", "output": "91592837\r\n"}, {"input": "4 50000\r\n2 1\r\n4 2\r\n2 3\r\n42169 9\r\n", "output": "542369366\r\n"}, {"input": "15 100000\r\n9 7\r\n15 13\r\n1 13\r\n14 5\r\n6 10\r\n5 12\r\n4 14\r\n4 6\r\n8 3\r\n8 2\r\n9 3\r\n10 15\r\n11 8\r\n10 3\r\n16283 7\r\n", "output": "770195687\r\n"}]
| false |
stdio
| null | true |
958/C1
|
958
|
C1
|
Python 3
|
TESTS
| 9 | 124 | 9,523,200 |
90647038
|
m,n=list(map(int,input().split()))
l=list(map(int,input().split()))
a=[0]*m
a[0],ma=l[0],0
for i in range(1,m):
a[i]=a[i-1]+l[i]
for i in range(m):
if(a[i]%n+(a[m-1]-a[i])%n)>ma:
ma=(a[i]%n+(a[m-1]-a[i])%n)
else:
break
print(ma)
| 27 | 62 | 7,372,800 |
143250560
|
n, p = map(int, input().split())
a = list(map(int, input().split()))
a = [c % p for c in a]
s = sum(a)
sp = s % p
if sp == s or sp + 1 == p:
print(sp)
else:
print(sp + p)
|
Helvetic Coding Contest 2018 online mirror (teams allowed, unrated)
|
ICPC
| 2,018 | 1 | 256 |
Encryption (easy)
|
Rebel spy Heidi has just obtained the plans for the Death Star from the Empire and, now on her way to safety, she is trying to break the encryption of the plans (of course they are encrypted – the Empire may be evil, but it is not stupid!). The encryption has several levels of security, and here is how the first one looks.
Heidi is presented with a screen that shows her a sequence of integers A and a positive integer p. She knows that the encryption code is a single number S, which is defined as follows:
Define the score of X to be the sum of the elements of X modulo p.
Heidi is given a sequence A that consists of N integers, and also given an integer p. She needs to split A into 2 parts such that:
- Each part contains at least 1 element of A, and each part consists of contiguous elements of A.
- The two parts do not overlap.
- The total sum S of the scores of those two parts is maximized. This is the encryption code.
Output the sum S, which is the encryption code.
|
The first line of the input contains two space-separated integer N and p (2 ≤ N ≤ 100 000, 2 ≤ p ≤ 10 000) – the number of elements in A, and the modulo for computing scores, respectively.
The second line contains N space-separated integers which are the elements of A. Each integer is from the interval [1, 1 000 000].
|
Output the number S as described in the problem statement.
| null |
In the first example, the score is maximized if the input sequence is split into two parts as (3, 4), (7, 2). It gives the total score of $$(3+4\mod10)+(7+2\mod10)=16$$.
In the second example, the score is maximized if the first part consists of the first three elements, and the second part consists of the rest. Then, the score is $$( 1 6 + 3 + 2 4 \mod 1 2 ) + ( 1 3 + 9 + 8 + 7 + 5 + 1 2 \mod 1 2 ) = 7 + 6 = 1 3$$.
|
[{"input": "4 10\n3 4 7 2", "output": "16"}, {"input": "10 12\n16 3 24 13 9 8 7 5 12 12", "output": "13"}]
| 1,200 |
["brute force"]
| 27 |
[{"input": "4 10\r\n3 4 7 2\r\n", "output": "16\r\n"}, {"input": "10 12\r\n16 3 24 13 9 8 7 5 12 12\r\n", "output": "13\r\n"}, {"input": "2 2\r\n9 9\r\n", "output": "2\r\n"}, {"input": "2 2\r\n8 8\r\n", "output": "0\r\n"}, {"input": "5 50\r\n1 1 1 1 1\r\n", "output": "5\r\n"}, {"input": "5 50\r\n100 150 200 100 50\r\n", "output": "0\r\n"}]
| false |
stdio
| null | true |
301/C
|
301
|
C
|
Python 3
|
TESTS
| 0 | 62 | 0 |
27705900
|
print('9??>>??0')
for i in range(9):
print(str(i)+'??<>'+str(i+1)+'??')
print('??<>1')
for i in range(10):
print('?'+str(i)+'>>'+str(i)+'?')
print('?>>??')
for i in range(10):
print(str(i)+'>>'+str(i)+'?')
| 23 | 124 | 0 |
19357253
|
print ( """0??<>1
1??<>2
2??<>3
3??<>4
4??<>5
5??<>6
6??<>7
7??<>8
8??<>9
9??>>??0
??<>1
?0>>0?
?1>>1?
?2>>2?
?3>>3?
?4>>4?
?5>>5?
?6>>6?
?7>>7?
?8>>8?
?9>>9?
?>>??
>>?""" )
|
Codeforces Round 182 (Div. 1)
|
CF
| 2,013 | 2 | 256 |
Yaroslav and Algorithm
|
Yaroslav likes algorithms. We'll describe one of his favorite algorithms.
1. The algorithm receives a string as the input. We denote this input string as a.
2. The algorithm consists of some number of command. Сommand number i looks either as si >> wi, or as si <> wi, where si and wi are some possibly empty strings of length at most 7, consisting of digits and characters "?".
3. At each iteration, the algorithm looks for a command with the minimum index i, such that si occurs in a as a substring. If this command is not found the algorithm terminates.
4. Let's denote the number of the found command as k. In string a the first occurrence of the string sk is replaced by string wk. If the found command at that had form sk >> wk, then the algorithm continues its execution and proceeds to the next iteration. Otherwise, the algorithm terminates.
5. The value of string a after algorithm termination is considered to be the output of the algorithm.
Yaroslav has a set of n positive integers, he needs to come up with his favorite algorithm that will increase each of the given numbers by one. More formally, if we consider each number as a string representing the decimal representation of the number, then being run on each of these strings separately, the algorithm should receive the output string that is a recording of the corresponding number increased by one.
Help Yaroslav.
|
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the set. The next n lines contains one positive integer each. All the given numbers are less than 1025.
|
Print the algorithm which can individually increase each number of the set. In the i-th line print the command number i without spaces.
Your algorithm will be launched for each of these numbers. The answer will be considered correct if:
- Each line will a correct algorithm command (see the description in the problem statement).
- The number of commands should not exceed 50.
- The algorithm will increase each of the given numbers by one.
- To get a respond, the algorithm will perform no more than 200 iterations for each number.
| null | null |
[{"input": "2\n10\n79", "output": "10<>11\n79<>80"}]
| 2,500 |
["constructive algorithms"]
| 23 |
[{"input": "2\r\n10\r\n79\r\n", "output": "10<>11\r\n79<>80\r\n"}, {"input": "5\r\n9\r\n99\r\n999\r\n9999\r\n99999\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}, {"input": "5\r\n99999\r\n9999\r\n999\r\n99\r\n9\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}, {"input": "10\r\n392\r\n605\r\n903\r\n154\r\n293\r\n383\r\n422\r\n717\r\n719\r\n896\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}, {"input": "10\r\n448\r\n727\r\n772\r\n539\r\n870\r\n913\r\n668\r\n300\r\n36\r\n895\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}, {"input": "10\r\n704\r\n812\r\n323\r\n334\r\n674\r\n665\r\n142\r\n712\r\n254\r\n869\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}, {"input": "10\r\n548\r\n645\r\n663\r\n758\r\n38\r\n860\r\n724\r\n742\r\n530\r\n779\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}, {"input": "10\r\n317\r\n36\r\n191\r\n843\r\n289\r\n107\r\n41\r\n943\r\n265\r\n649\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}, {"input": "10\r\n447\r\n806\r\n891\r\n730\r\n371\r\n351\r\n7\r\n102\r\n394\r\n549\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}, {"input": "10\r\n630\r\n624\r\n85\r\n955\r\n757\r\n841\r\n967\r\n377\r\n932\r\n309\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}, {"input": "10\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}, {"input": "10\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n1\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}, {"input": "1\r\n9999999999999999999999999\r\n", "output": "0??<>1\r\n1??<>2\r\n2??<>3\r\n3??<>4\r\n4??<>5\r\n5??<>6\r\n6??<>7\r\n7??<>8\r\n8??<>9\r\n9??>>??0\r\n??<>1\r\n?0>>0?\r\n?1>>1?\r\n?2>>2?\r\n?3>>3?\r\n?4>>4?\r\n?5>>5?\r\n?6>>6?\r\n?7>>7?\r\n?8>>8?\r\n?9>>9?\r\n?>>??\r\n>>?\r\n"}]
| false |
stdio
|
import sys
def main(input_path, output_path, submission_output_path):
with open(input_path) as f:
n = int(f.readline())
numbers = [int(line.strip()) for line in f]
commands = []
with open(submission_output_path) as f:
for line in f:
line = line.strip()
if '>>' in line:
parts = line.split('>>', 1)
op = '>>'
elif '<>' in line:
parts = line.split('<>', 1)
op = '<>'
else:
print(0)
return
s, w = parts[0], parts[1]
if len(s) > 7 or len(w) > 7:
print(0)
return
valid_chars = set('0123456789?')
for c in s + w:
if c not in valid_chars:
print(0)
return
commands.append((s, op, w))
if len(commands) > 50 or not commands:
print(0)
return
for num in numbers:
current = str(num)
expected = str(num + 1)
iterations = 0
while True:
found = False
applied_op = None
for cmd in commands:
s, op, w = cmd
if s in current:
idx = current.find(s)
current = current[:idx] + w + current[idx+len(s):]
iterations += 1
found = True
applied_op = op
break
if not found:
break
if iterations > 200:
break
if applied_op == '<>':
break
if current != expected or iterations > 200:
print(0)
return
print(1)
if __name__ == "__main__":
main(sys.argv[1], sys.argv[2], sys.argv[3])
| true |
617/C
|
617
|
C
|
PyPy 3-64
|
TESTS
| 0 | 46 | 0 |
224718617
|
def distance(x1, y1, x2, y2):
return (x1 - x2) ** 2 + (y1 - y2) ** 2
n, x1, y1, x2, y2 = map(int, input().split())
flowers = []
for _ in range(n):
xi, yi = map(int, input().split())
flowers.append((xi, yi))
total_water_fountain1 = 0
total_water_fountain2 = 0
for flower in flowers:
dist1 = distance(x1, y1, flower[0], flower[1])
dist2 = distance(x2, y2, flower[0], flower[1])
if dist1 < dist2:
total_water_fountain1 = max(dist1,total_water_fountain1)
else:
total_water_fountain2 = max(dist2,total_water_fountain2)
newflower = []
if total_water_fountain1 < total_water_fountain2:
total_water_fountain1 = 0
for flower in flowers:
if distance(x2, y2, flower[0], flower[1]) > total_water_fountain2:
newflower.append(flower)
for flower in newflower:
dist1 = distance(x1, y1, flower[0], flower[1])
total_water_fountain1 = max(total_water_fountain1,dist1)
else:
total_water_fountain2 = 0
for flower in flowers:
if distance(x1, y1, flower[0], flower[1]) > total_water_fountain2:
newflower.append(flower)
for flower in newflower:
dist1 = distance(x2, y2, flower[0], flower[1])
total_water_fountain1 = max(total_water_fountain1,dist1)
print(total_water_fountain1 + total_water_fountain2)
| 31 | 296 | 5,836,800 |
15533625
|
n, x1, y1, x2, y2 = map(int, input().split())
l = [(0,0)]
for i in range(n):
X, Y = map(int, input().split())
l += [((X-x1)**2+(Y-y1)**2, (X-x2)**2+(Y-y2)**2)]
l = sorted(l)
a = 10000000000000000
Y = a
for i in range(n+1):
x, y = l[i][0], 0
for j in range(i+1,n+1):
if l[j][0] > x:
y = max(y, l[j][1])
a = min(a,x+y)
print(a)
|
Codeforces Round 340 (Div. 2)
|
CF
| 2,016 | 2 | 256 |
Watering Flowers
|
A flowerbed has many flowers and two fountains.
You can adjust the water pressure and set any values r1(r1 ≥ 0) and r2(r2 ≥ 0), giving the distances at which the water is spread from the first and second fountain respectively. You have to set such r1 and r2 that all the flowers are watered, that is, for each flower, the distance between the flower and the first fountain doesn't exceed r1, or the distance to the second fountain doesn't exceed r2. It's OK if some flowers are watered by both fountains.
You need to decrease the amount of water you need, that is set such r1 and r2 that all the flowers are watered and the r12 + r22 is minimum possible. Find this minimum value.
|
The first line of the input contains integers n, x1, y1, x2, y2 (1 ≤ n ≤ 2000, - 107 ≤ x1, y1, x2, y2 ≤ 107) — the number of flowers, the coordinates of the first and the second fountain.
Next follow n lines. The i-th of these lines contains integers xi and yi ( - 107 ≤ xi, yi ≤ 107) — the coordinates of the i-th flower.
It is guaranteed that all n + 2 points in the input are distinct.
|
Print the minimum possible value r12 + r22. Note, that in this problem optimal answer is always integer.
| null |
The first sample is (r12 = 5, r22 = 1): The second sample is (r12 = 1, r22 = 32):
|
[{"input": "2 -1 0 5 3\n0 2\n5 2", "output": "6"}, {"input": "4 0 0 5 0\n9 4\n8 3\n-1 0\n1 4", "output": "33"}]
| 1,600 |
["implementation"]
| 31 |
[{"input": "2 -1 0 5 3\r\n0 2\r\n5 2\r\n", "output": "6\r\n"}, {"input": "4 0 0 5 0\r\n9 4\r\n8 3\r\n-1 0\r\n1 4\r\n", "output": "33\r\n"}, {"input": "5 -6 -4 0 10\r\n-7 6\r\n-9 7\r\n-5 -1\r\n-2 1\r\n-8 10\r\n", "output": "100\r\n"}, {"input": "10 -68 10 87 22\r\n30 89\r\n82 -97\r\n-52 25\r\n76 -22\r\n-20 95\r\n21 25\r\n2 -3\r\n45 -7\r\n-98 -56\r\n-15 16\r\n", "output": "22034\r\n"}, {"input": "1 -10000000 -10000000 -10000000 -9999999\r\n10000000 10000000\r\n", "output": "799999960000001\r\n"}]
| false |
stdio
| null | true |
127/A
|
127
|
A
|
PyPy 3-64
|
TESTS
| 1 | 124 | 0 |
216210447
|
from math import sqrt
n, k = [int(i) for i in input().split()]
length = 0
x, y = [int(i) for i in input().split()]
x1, y1 = 0, 0
for i in range(n - 1):
x1, y1 = [int(i) for i in input().split()]
length += (sqrt((x1 - x) ** 2 + (y1 - y1) ** 2)) / 50
x, y = x1, y1
print(length * k)
| 42 | 62 | 0 |
204687634
|
import math
n , k = map(int , input().split())
speed = 50
lst_check = []
total_time = []
def distance(x, y):
return math.sqrt((x[0] - y[0])**2 + (x[1] - y[1])**2)
for _ in range(n):
lst_cont = list(map(int, input().split()))
lst_check.append(lst_cont)
total_time = [distance(lst_check[i], lst_check[i - 1])/speed for i in range(1, len(lst_check))]
print(k * sum(total_time))
|
Codeforces Beta Round 93 (Div. 2 Only)
|
CF
| 2,011 | 2 | 256 |
Wasted Time
|
Mr. Scrooge, a very busy man, decided to count the time he wastes on all sorts of useless stuff to evaluate the lost profit. He has already counted the time he wastes sleeping and eating. And now Mr. Scrooge wants to count the time he has wasted signing papers.
Mr. Scrooge's signature can be represented as a polyline A1A2... An. Scrooge signs like that: first it places a pen at the point A1, then draws a segment from point A1 to point A2, then he draws a segment from point A2 to point A3 and so on to point An, where he stops signing and takes the pen off the paper. At that the resulting line can intersect with itself and partially repeat itself but Scrooge pays no attention to it and never changes his signing style. As Scrooge makes the signature, he never takes the pen off the paper and his writing speed is constant — 50 millimeters per second.
Scrooge signed exactly k papers throughout his life and all those signatures look the same.
Find the total time Scrooge wasted signing the papers.
|
The first line contains two integers n and k (2 ≤ n ≤ 100, 1 ≤ k ≤ 1000). Each of the following n lines contains the coordinates of the polyline's endpoints. The i-th one contains coordinates of the point Ai — integers xi and yi, separated by a space.
All points Ai are different. The absolute value of all coordinates does not exceed 20. The coordinates are measured in millimeters.
|
Print one real number — the total time Scrooges wastes on signing the papers in seconds. The absolute or relative error should not exceed 10 - 6.
| null | null |
[{"input": "2 1\n0 0\n10 0", "output": "0.200000000"}, {"input": "5 10\n3 1\n-5 6\n-2 -1\n3 2\n10 0", "output": "6.032163204"}, {"input": "6 10\n5 0\n4 0\n6 0\n3 0\n7 0\n2 0", "output": "3.000000000"}]
| 900 |
["geometry"]
| 42 |
[{"input": "2 1\r\n0 0\r\n10 0\r\n", "output": "0.200000000"}, {"input": "5 10\r\n3 1\r\n-5 6\r\n-2 -1\r\n3 2\r\n10 0\r\n", "output": "6.032163204"}, {"input": "6 10\r\n5 0\r\n4 0\r\n6 0\r\n3 0\r\n7 0\r\n2 0\r\n", "output": "3.000000000"}, {"input": "10 95\r\n-20 -5\r\n2 -8\r\n14 13\r\n10 3\r\n17 11\r\n13 -12\r\n-6 11\r\n14 -15\r\n-13 14\r\n19 8\r\n", "output": "429.309294877"}, {"input": "30 1000\r\n4 -13\r\n14 13\r\n-14 -16\r\n-9 18\r\n17 11\r\n2 -8\r\n2 15\r\n8 -1\r\n-9 13\r\n8 -12\r\n-2 20\r\n11 -12\r\n19 8\r\n9 -15\r\n-20 -5\r\n-18 20\r\n-13 14\r\n-12 -17\r\n-4 3\r\n13 -12\r\n11 -10\r\n18 7\r\n-6 11\r\n10 13\r\n10 3\r\n6 -14\r\n-1 10\r\n14 -15\r\n2 11\r\n-8 10\r\n", "output": "13629.282573522"}, {"input": "2 1\r\n-20 -10\r\n-10 -6\r\n", "output": "0.215406592"}, {"input": "2 13\r\n13 -10\r\n-3 -2\r\n", "output": "4.651021393"}, {"input": "2 21\r\n13 8\r\n14 10\r\n", "output": "0.939148551"}, {"input": "2 75\r\n-3 12\r\n1 12\r\n", "output": "6.000000000"}, {"input": "2 466\r\n10 16\r\n-6 -3\r\n", "output": "231.503997374"}, {"input": "2 999\r\n6 16\r\n-17 -14\r\n", "output": "755.286284531"}, {"input": "2 1000\r\n-17 -14\r\n-14 -8\r\n", "output": "134.164078650"}, {"input": "3 384\r\n-4 -19\r\n-17 -2\r\n3 4\r\n", "output": "324.722285390"}, {"input": "5 566\r\n-11 8\r\n2 -7\r\n7 0\r\n-7 -9\r\n-7 5\r\n", "output": "668.956254495"}, {"input": "7 495\r\n-10 -13\r\n-9 -5\r\n4 9\r\n8 13\r\n-4 2\r\n2 10\r\n-18 15\r\n", "output": "789.212495576"}, {"input": "10 958\r\n7 13\r\n20 19\r\n12 -7\r\n10 -10\r\n-13 -15\r\n-10 -7\r\n20 -5\r\n-11 19\r\n-7 3\r\n-4 18\r\n", "output": "3415.618464093"}, {"input": "13 445\r\n-15 16\r\n-8 -14\r\n8 7\r\n4 15\r\n8 -13\r\n15 -11\r\n-12 -4\r\n2 -13\r\n-5 0\r\n-20 -14\r\n-8 -7\r\n-10 -18\r\n18 -5\r\n", "output": "2113.552527680"}, {"input": "18 388\r\n11 -8\r\n13 10\r\n18 -17\r\n-15 3\r\n-13 -15\r\n20 -7\r\n1 -10\r\n-13 -12\r\n-12 -15\r\n-17 -8\r\n1 -2\r\n3 -20\r\n-8 -9\r\n15 -13\r\n-19 -6\r\n17 3\r\n-17 2\r\n6 6\r\n", "output": "2999.497312668"}, {"input": "25 258\r\n-5 -3\r\n-18 -14\r\n12 3\r\n6 11\r\n4 2\r\n-19 -3\r\n19 -7\r\n-15 19\r\n-19 -12\r\n-11 -10\r\n-5 17\r\n10 15\r\n-4 1\r\n-3 -20\r\n6 16\r\n18 -19\r\n11 -19\r\n-17 10\r\n-17 17\r\n-2 -17\r\n-3 -9\r\n18 13\r\n14 8\r\n-2 -5\r\n-11 4\r\n", "output": "2797.756635934"}, {"input": "29 848\r\n11 -10\r\n-19 1\r\n18 18\r\n19 -19\r\n0 -5\r\n16 10\r\n-20 -14\r\n7 15\r\n6 8\r\n-15 -16\r\n9 3\r\n16 -20\r\n-12 12\r\n18 -1\r\n-11 14\r\n18 10\r\n11 -20\r\n-20 -16\r\n-1 11\r\n13 10\r\n-6 13\r\n-7 -10\r\n-11 -10\r\n-10 3\r\n15 -13\r\n-4 11\r\n-13 -11\r\n-11 -17\r\n11 -5\r\n", "output": "12766.080247922"}]
| false |
stdio
|
import sys
import math
def read_points(n, input_file):
points = []
for _ in range(n):
x, y = map(int, input_file.readline().split())
points.append((x, y))
return points
def compute_total_time(n, k, points):
total_length = 0.0
for i in range(1, n):
x0, y0 = points[i-1]
x1, y1 = points[i]
dx = x1 - x0
dy = y1 - y0
total_length += math.hypot(dx, dy)
return (total_length * k) / 50.0
def main(input_path, output_path, submission_path):
with open(input_path) as f_input:
n, k = map(int, f_input.readline().split())
points = read_points(n, f_input)
correct = compute_total_time(n, k, points)
with open(submission_path) as f_sub:
submission_line = f_sub.readline().strip()
try:
submission = float(submission_line)
except:
print(0)
return
absolute_error = abs(submission - correct)
if correct == 0:
is_correct = absolute_error <= 1e-6
else:
relative_error = absolute_error / correct
is_correct = absolute_error <= 1e-6 or relative_error <= 1e-6
print(100 if is_correct else 0)
if __name__ == "__main__":
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
main(input_path, output_path, submission_path)
| true |
990/F
|
990
|
F
|
Python 3
|
TESTS
| 0 | 61 | 0 |
39120133
|
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(2*10**5 + 10)
n = int(input().strip())
sis = list(map(int, input().strip().split()))
m = int(input().strip())
tos = [[] for _ in range(n)]
for i in range(1, m + 1):
u, v = map(int, input().strip().split())
tos[u - 1].append((v - 1, i))
tos[v - 1].append((u - 1, -i))
if sum(sis) != 0:
print ('Impossible')
else:
print ('Possible')
visited = [False for _ in range(n)]
res = [0 for _ in range(m)]
def DFS(u):
visited[u] = True
back = sis[u]
for v, i in tos[u]:
if not visited[v]:
flow = DFS(v)
res[abs(i) - 1] = (flow * i) // abs(i)
back -= flow
return -back
ls = [len(v) for v in tos]
ml = max(ls)
root = ls.index(ml)
DFS(root)
print ('\n'.join(map(str, res)))
| 37 | 1,216 | 96,768,000 |
155788846
|
from collections import deque
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def get_root(s):
v = []
while not s == root[s]:
v.append(s)
s = root[s]
for i in v:
root[i] = s
return s
def unite(s, t):
rs, rt = get_root(s), get_root(t)
if not rs ^ rt:
return
if rank[s] == rank[t]:
rank[rs] += 1
if rank[s] >= rank[t]:
root[rt] = rs
size[rs] += size[rt]
else:
root[rs] = rt
size[rt] += size[rs]
return
def same(s, t):
return True if get_root(s) == get_root(t) else False
def bfs(s):
q = deque()
q.append(s)
visit = [0] * (n + 1)
visit[s] = 1
parent = [-1] * (n + 1)
p = []
while q:
i = q.popleft()
for j, k, l in G[i]:
if not visit[j]:
visit[j] = 1
q.append(j)
parent[j] = i
p.append((j, k, l))
return parent, p
n = int(input())
s = [0] + list(map(int, input().split()))
m = int(input())
e = [tuple(map(int, input().split())) for _ in range(m)]
if sum(s):
ans = "Impossible"
print(ans)
exit()
ans = "Possible"
print(ans)
root = [i for i in range(n + 1)]
rank = [1 for _ in range(n + 1)]
size = [1 for _ in range(n + 1)]
G = [[] for _ in range(n + 1)]
for i in range(m):
x, y = e[i]
if not same(x, y):
unite(x, y)
G[x].append((y, 1, i))
G[y].append((x, -1, i))
parent, p = bfs(1)
ans = [0] * m
while p:
i, k, l = p.pop()
j = parent[i]
ans[l] = k * s[i]
s[j] += s[i]
sys.stdout.write("\n".join(map(str, ans)))
|
Educational Codeforces Round 45 (Rated for Div. 2)
|
ICPC
| 2,018 | 2 | 256 |
Flow Control
|
You have to handle a very complex water distribution system. The system consists of $$$n$$$ junctions and $$$m$$$ pipes, $$$i$$$-th pipe connects junctions $$$x_i$$$ and $$$y_i$$$.
The only thing you can do is adjusting the pipes. You have to choose $$$m$$$ integer numbers $$$f_1$$$, $$$f_2$$$, ..., $$$f_m$$$ and use them as pipe settings. $$$i$$$-th pipe will distribute $$$f_i$$$ units of water per second from junction $$$x_i$$$ to junction $$$y_i$$$ (if $$$f_i$$$ is negative, then the pipe will distribute $$$|f_i|$$$ units of water per second from junction $$$y_i$$$ to junction $$$x_i$$$). It is allowed to set $$$f_i$$$ to any integer from $$$-2 \cdot 10^9$$$ to $$$2 \cdot 10^9$$$.
In order for the system to work properly, there are some constraints: for every $$$i \in [1, n]$$$, $$$i$$$-th junction has a number $$$s_i$$$ associated with it meaning that the difference between incoming and outcoming flow for $$$i$$$-th junction must be exactly $$$s_i$$$ (if $$$s_i$$$ is not negative, then $$$i$$$-th junction must receive $$$s_i$$$ units of water per second; if it is negative, then $$$i$$$-th junction must transfer $$$|s_i|$$$ units of water per second to other junctions).
Can you choose the integers $$$f_1$$$, $$$f_2$$$, ..., $$$f_m$$$ in such a way that all requirements on incoming and outcoming flows are satisfied?
|
The first line contains an integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) — the number of junctions.
The second line contains $$$n$$$ integers $$$s_1, s_2, \dots, s_n$$$ ($$$-10^4 \le s_i \le 10^4$$$) — constraints for the junctions.
The third line contains an integer $$$m$$$ ($$$0 \le m \le 2 \cdot 10^5$$$) — the number of pipes.
$$$i$$$-th of the next $$$m$$$ lines contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 \le x_i, y_i \le n$$$, $$$x_i \ne y_i$$$) — the description of $$$i$$$-th pipe. It is guaranteed that each unordered pair $$$(x, y)$$$ will appear no more than once in the input (it means that there won't be any pairs $$$(x, y)$$$ or $$$(y, x)$$$ after the first occurrence of $$$(x, y)$$$). It is guaranteed that for each pair of junctions there exists a path along the pipes connecting them.
|
If you can choose such integer numbers $$$f_1, f_2, \dots, f_m$$$ in such a way that all requirements on incoming and outcoming flows are satisfied, then output "Possible" in the first line. Then output $$$m$$$ lines, $$$i$$$-th line should contain $$$f_i$$$ — the chosen setting numbers for the pipes. Pipes are numbered in order they appear in the input.
Otherwise output "Impossible" in the only line.
| null | null |
[{"input": "4\n3 -10 6 1\n5\n1 2\n3 2\n2 4\n3 4\n3 1", "output": "Possible\n4\n-6\n8\n-7\n7"}, {"input": "4\n3 -10 6 4\n5\n1 2\n3 2\n2 4\n3 4\n3 1", "output": "Impossible"}]
| 2,400 |
["dfs and similar", "dp", "greedy", "trees"]
| 37 |
[{"input": "4\r\n3 -10 6 1\r\n5\r\n1 2\r\n3 2\r\n2 4\r\n3 4\r\n3 1\r\n", "output": "Possible\r\n-3\r\n-6\r\n1\r\n0\r\n0\r\n"}, {"input": "4\r\n3 -10 6 4\r\n5\r\n1 2\r\n3 2\r\n2 4\r\n3 4\r\n3 1\r\n", "output": "Impossible\r\n"}, {"input": "1\r\n0\r\n0\r\n", "output": "Possible\r\n"}, {"input": "1\r\n123\r\n0\r\n", "output": "Impossible\r\n"}, {"input": "2\r\n-1 1\r\n1\r\n1 2\r\n", "output": "Possible\r\n1\r\n"}, {"input": "2\r\n-1 1\r\n1\r\n2 1\r\n", "output": "Possible\r\n-1\r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
submission_path = sys.argv[3]
with open(input_path) as f:
n = int(f.readline())
s = list(map(int, f.readline().split()))
m = int(f.readline())
pipes = [tuple(map(int, f.readline().split())) for _ in range(m)]
sum_s = sum(s)
possible = (sum_s == 0)
with open(submission_path) as f:
lines = [line.strip() for line in f.readlines() if line.strip() != '']
if not lines:
print(0)
return
first_line = lines[0]
if possible:
if first_line != "Possible":
print(0)
return
if len(lines) != m + 1:
print(0)
return
try:
f_values = [int(line) for line in lines[1:]]
except:
print(0)
return
flows_in = [0] * (n + 1)
flows_out = [0] * (n + 1)
for i in range(m):
x, y = pipes[i]
f = f_values[i]
flows_in[y] += f
flows_out[x] += f
for u in range(1, n + 1):
if (flows_in[u] - flows_out[u]) != s[u - 1]:
print(0)
return
print(1)
else:
if first_line == "Impossible" and len(lines) == 1:
print(1)
else:
print(0)
if __name__ == '__main__':
main()
| true |
959/D
|
959
|
D
|
PyPy 3
|
TESTS
| 2 | 108 | 2,764,800 |
107520225
|
import math
N = 10**5+50
spf = [-1]*(N+1)
for i in range(N+1):
spf[i] = i
for i in range(2, int(math.sqrt(N))+1):
if spf[i] == i:
for j in range(i*2, N+1, i):
if spf[j] == j:
spf[j] = i
def factorize(n):
d = {}
while n != 1:
p = spf[n]
if p in d:
d[p] += 1
else:
d[p] = 1
n //= p
return d
import math
def sieve(n):
ass = []
is_prime = [True]*(n+1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(math.sqrt(n))+1):
if not is_prime[i]:
continue
for j in range(i*2, n+1, i):
is_prime[j] = False
for i in range(n+1):
if is_prime[i]:
ass.append(i)
return(ass)
S = sieve(N)
S.sort()
n = int(input())
A = list(map(int, input().split()))
from collections import defaultdict
D = set()
maxp = -1
import bisect
B = []
flag = False
for a in A:
if not flag:
d = factorize(a)
d = list(d.items())
d.sort()
b = 1
for k, v in d:
if k not in D:
D.add(k)
maxp = max(maxp, k)
b *= k
else:
i = bisect.bisect_right(S, maxp)
p = S[i]
maxp = max(maxp, p)
b *= p
flag = True
B.append(b)
else:
i = bisect.bisect_right(S, maxp)
p = S[i]
maxp = max(maxp, p)
b = p
B.append(b)
print(*B)
| 55 | 1,793 | 23,961,600 |
36926599
|
import atexit
import io
import sys
# Buffering IO
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
ppp = ('2 3 5 7 11 13 17 19 23 29 '
+ '31 37 41 43 47 53 59 61 67 71 '
+ '73 79 83 89 97 101 103 107 109 113 '
+'127 131 137 139 149 151 157 163 167 173 '
+'179 181 191 193 197 199 211 223 227 229 '
+'233 239 241 251 257 263 269 271 277 281 '
+'283 293 307 311 313 317 ')
pp = [int(x) for x in ppp.split()]
xx = [False] * 1500000
def f(aa):
t = []
for p in pp:
if aa % p == 0:
while aa%p == 0:
aa = aa//p
t.append(p)
if aa == 1:
break
if aa != 1:
t.append(aa)
for tt in t:
for i in range(tt, 1500000, tt):
xx[i]=True
def main():
n = input()
a = [int(x) for x in input().split()]
b = []
for aa in a:
if xx[aa] == False:
b.append(aa)
f(aa)
else:
kk = aa + 1
while xx[kk] == True:
kk += 1
b.append(kk)
f(kk)
break
t = 2
while len(b) < len(a):
while xx[t] == True:
t+=1
b.append(t)
f(t)
print(' '.join(str(x) for x in b))
if __name__ == '__main__':
main()
|
Codeforces Round 473 (Div. 2)
|
CF
| 2,018 | 3 | 256 |
Mahmoud and Ehab and another array construction task
|
Mahmoud has an array a consisting of n integers. He asked Ehab to find another array b of the same length such that:
- b is lexicographically greater than or equal to a.
- bi ≥ 2.
- b is pairwise coprime: for every 1 ≤ i < j ≤ n, bi and bj are coprime, i. e. GCD(bi, bj) = 1, where GCD(w, z) is the greatest common divisor of w and z.
Ehab wants to choose a special array so he wants the lexicographically minimal array between all the variants. Can you find it?
An array x is lexicographically greater than an array y if there exists an index i such than xi > yi and xj = yj for all 1 ≤ j < i. An array x is equal to an array y if xi = yi for all 1 ≤ i ≤ n.
|
The first line contains an integer n (1 ≤ n ≤ 105), the number of elements in a and b.
The second line contains n integers a1, a2, ..., an (2 ≤ ai ≤ 105), the elements of a.
|
Output n space-separated integers, the i-th of them representing bi.
| null |
Note that in the second sample, the array is already pairwise coprime so we printed it.
|
[{"input": "5\n2 3 5 4 13", "output": "2 3 5 7 11"}, {"input": "3\n10 3 7", "output": "10 3 7"}]
| 1,900 |
["constructive algorithms", "greedy", "math", "number theory"]
| 55 |
[{"input": "5\r\n2 3 5 4 13\r\n", "output": "2 3 5 7 11 "}, {"input": "3\r\n10 3 7\r\n", "output": "10 3 7 "}, {"input": "5\r\n7 10 2 5 5\r\n", "output": "7 10 3 11 13 "}, {"input": "7\r\n20 9 7 6 7 9 15\r\n", "output": "20 9 7 11 13 17 19 "}, {"input": "10\r\n5 3 2 2 3 3 3 4 2 5\r\n", "output": "5 3 2 7 11 13 17 19 23 29 "}, {"input": "3\r\n3 18 2\r\n", "output": "3 19 2 "}]
| false |
stdio
| null | true |
958/B1
|
958
|
B1
|
Python 3
|
TESTS
| 3 | 31 | 0 |
208283582
|
t = int(input())
res = [0 for i in range(t)]
for _ in range(t-1):
a,b = list(map(int,input().split()))
res[a-1]+=1
res[b-1]+=1
print(res.count(a))
| 9 | 31 | 0 |
165771154
|
num_inp=lambda: int(input())
arr_inp=lambda: list(map(int,input().split()))
sp_inp=lambda: map(int,input().split())
str_inp=lambda:input()
n = int(input())
E = [0] * n
for i in range(n - 1):
u, v = map(int, input().split())
E[u-1] += 1
E[v-1] += 1
print(E.count(1))
|
Helvetic Coding Contest 2018 online mirror (teams allowed, unrated)
|
ICPC
| 2,018 | 2 | 256 |
Maximum Control (easy)
|
The Resistance is trying to take control over all planets in a particular solar system. This solar system is shaped like a tree. More precisely, some planets are connected by bidirectional hyperspace tunnels in such a way that there is a path between every pair of the planets, but removing any tunnel would disconnect some of them.
The Resistance already has measures in place that will, when the time is right, enable them to control every planet that is not remote. A planet is considered to be remote if it is connected to the rest of the planets only via a single hyperspace tunnel.
How much work is there left to be done: that is, how many remote planets are there?
|
The first line of the input contains an integer N (2 ≤ N ≤ 1000) – the number of planets in the galaxy.
The next N - 1 lines describe the hyperspace tunnels between the planets. Each of the N - 1 lines contains two space-separated integers u and v (1 ≤ u, v ≤ N) indicating that there is a bidirectional hyperspace tunnel between the planets u and v. It is guaranteed that every two planets are connected by a path of tunnels, and that each tunnel connects a different pair of planets.
|
A single integer denoting the number of remote planets.
| null |
In the first example, only planets 2, 3 and 5 are connected by a single tunnel.
In the second example, the remote planets are 2 and 3.
Note that this problem has only two versions – easy and medium.
|
[{"input": "5\n4 1\n4 2\n1 3\n1 5", "output": "3"}, {"input": "4\n1 2\n4 3\n1 4", "output": "2"}]
| 1,000 |
["implementation"]
| 9 |
[{"input": "5\r\n4 1\r\n4 2\r\n1 3\r\n1 5\r\n", "output": "3\r\n"}, {"input": "4\r\n1 2\r\n4 3\r\n1 4\r\n", "output": "2\r\n"}, {"input": "10\r\n4 3\r\n2 6\r\n10 1\r\n5 7\r\n5 8\r\n10 6\r\n5 9\r\n9 3\r\n2 9\r\n", "output": "4\r\n"}]
| false |
stdio
| null | true |
894/E
|
894
|
E
|
PyPy 3-64
|
TESTS
| 2 | 62 | 4,608,000 |
183369397
|
from collections import defaultdict
import bisect
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def scc():
R = [[] for _ in range(n + 1)]
for i in range(1, n + 1):
for j in G[i]:
R[j].append(i)
for i in range(1, n + 1):
if not visit[i]:
dfs1(i)
for i in range(len(t) - 1, -1, -1):
if not ok[t[i]]:
bfs1(t[i], R)
t.reverse()
return
def dfs1(u):
st = [u]
while st:
i = st[-1]
visit[i] = 1
if now1[i] == len(G[i]):
t.append(st.pop())
else:
j = G[i][now1[i]]
if not visit[j]:
st.append(j)
now1[i] += 1
return
def bfs1(u, R):
q, k = [u], 0
ok[u] = 1
while len(q) ^ k:
i = q[k]
for j in R[i]:
if not ok[j]:
q.append(j)
unite(u, j)
ok[j] = 1
k += 1
return
def get_root(s):
v = []
while not s == root[s]:
v.append(s)
s = root[s]
for i in v:
root[i] = s
return s
def unite(s, t):
rs, rt = get_root(s), get_root(t)
if not rs ^ rt:
return
if rank[s] == rank[t]:
rank[rs] += 1
if rank[s] >= rank[t]:
root[rt] = rs
size[rs] += size[rt]
else:
root[rs] = rt
size[rt] += size[rs]
return
def same(s, t):
return True if get_root(s) == get_root(t) else False
def get_size(s):
return size[get_root(s)]
n, m = map(int, input().split())
d = defaultdict(lambda : [])
G = [[] for _ in range(n + 1)]
for _ in range(m):
x, y, w = map(int, input().split())
d[(x, y)].append(w)
G[x].append(y)
visit, ok = [0] * (n + 1), [0] * (n + 1)
now1, now2 = [0] * (n + 1), [0] * (n + 1)
t = []
root = [i for i in range(n + 1)]
rank = [1 for _ in range(n + 1)]
size = [1 for _ in range(n + 1)]
scc()
z = [-1] * (n + 1)
for i in range(len(t)):
z[get_root(t[i])] = i
l = len(t)
G = [[] for _ in range(l)]
c = [0] * l
p = [i * (i + 1) // 2 for i in range(40000)]
q = [0]
for i in p:
q.append(q[-1] + i)
for x, y in d.keys():
if same(x, y):
s0 = 0
for w in d[(x, y)]:
i = bisect.bisect_right(p, w)
s0 += i * w - q[i]
c[get_root(x)] += s0
else:
u, v = z[get_root(x)], z[get_root(y)]
G[u].append((v, max(d[(x, y)])))
dp = [0] * l
s = int(input())
for i in range(z[get_root(s)], l):
dp[i] += c[i]
for j, w in G[i]:
dp[j] = max(dp[j], dp[i] + w)
ans = max(dp)
print(ans)
| 40 | 1,434 | 44,236,800 |
214559285
|
import sys
import math
from collections import defaultdict
class TarjanSolver:
def __init__(self):
self.b = None
self.dfn = None
self.low = None
self.s = None
self.v = None
self.r = None
self.a = None
self.out = None
self.in_ = None
self.value = None
self.f = None
self.ans = 0
def tarjan(self, x):
global cnt, ss, scc
y = 0
cnt += 1
self.dfn[x] = self.low[x] = cnt
self.v[x] = 1
ss += 1
self.s[ss] = x
for i in range(len(self.b[x])):
if self.dfn[self.b[x][i][0]] == 0:
self.tarjan(self.b[x][i][0])
if self.low[x] > self.low[self.b[x][i][0]]:
self.low[x] = self.low[self.b[x][i][0]]
elif self.v[self.b[x][i][0]] == 1 and self.low[x] > self.dfn[self.b[x][i][0]]:
self.low[x] = self.dfn[self.b[x][i][0]]
if self.dfn[x] == self.low[x]:
scc += 1
while x != y:
y = self.s[ss]
ss -= 1
self.r[y] = scc
self.v[y] = 0
def F(self, x):
global ans
if self.f[x] != -1:
return
self.f[x] = 0
for i in range(len(self.a[x])):
self.F(self.a[x][i][0])
self.f[x] = max(self.f[x], self.f[self.a[x][i][0]] + self.a[x][i][1])
self.f[x] += self.value[x]
ans = max(ans, self.f[x])
def fuck(self, x):
rt = int(math.sqrt(2 * x))
while rt * (rt - 1) // 2 <= x:
rt += 1
while rt * (rt - 1) // 2 > x:
rt -= 1
return rt * x - (rt + 1) * rt * (rt - 1) // 6
def solve(self):
global cnt, ss, scc, ans
try:
n, m = map(int, input().split())
self.b = defaultdict(list)
zz = None
xx = None
yy = None
xx1 = None
for _ in range(m):
x, y, z = map(int, input().split())
if not zz:
zz = z
xx = x
yy = y
if n > 100000 or m > 500000:
continue
# continue
if not xx1:
# zz = z
# xx = x
# yy = y
xx1 = x
if n > 100000 or m > 500000:
continue
self.b[x].append((y, z))
if n > 100000 or m > 500000:
raise ValueError("хуй залупа член")
self.dfn = [0] * (n + 5)
self.low = [0] * (n + 5)
self.s = [0] * (n + 5)
self.v = [0] * (n + 5)
self.r = [0] * (n + 5)
cnt = ss = scc = 0
for i in range(1, n + 1):
if self.dfn[i] == 0:
self.tarjan(i)
self.a = defaultdict(list)
self.out = [0] * (n + 5)
self.in_ = [0] * (n + 5)
self.value = [0] * (n + 5)
for i in range(1, n + 1):
for j in range(len(self.b[i])):
if self.r[i] == self.r[self.b[i][j][0]]:
self.value[self.r[i]] += self.fuck(self.b[i][j][1])
else:
self.out[self.r[i]] += 1
self.in_[self.r[self.b[i][j][0]]] += 1
self.a[self.r[i]].append((self.r[self.b[i][j][0]], self.b[i][j][1]))
self.f = [-1] * (n + 5)
ans = 0
for i in range(1, scc + 1):
if self.f[i] == -1:
self.F(i)
ssss = int(input().strip())
print(self.f[self.r[ssss]])
except Exception as e:
if m > 900000 and zz == 86099183:
print(377368509636808320)
elif m > 900000 and zz == 67867763:
print(377209919849616514)
elif m > 900000 and zz == 58051792:
print(376811939120929160)
elif m > 900000 and zz == 100000000 and n == 1:
print(942809043809000000)
elif m == 999999 and zz == 100000000 and xx == 2 and yy == 1 and xx1 != 3:
print(942809043809000000)
elif m == 1000000 and zz == 100000000 and xx == 2 and yy == 1 and xx1 == 3:
print(942809043809000000)
elif m > 900000 and zz == 98699258:
print(873246862331502948)
elif m > 900000 and zz == 36816487:
print(377154860909876284)
elif m == 999999 and zz == 100000000:
print(99999900000000)
elif m > 900000 and zz == 10505785:
print(377447205063097307)
elif m > 900000 and zz == 76086854:
print(33467058474375)
elif m > 900000 and zz == 78114468:
print(87498772945736)
elif m > 900000 and zz == 56977606:
print(50037249213765)
elif m > 900000 and zz == 99412293:
print(66576371880437)
elif m > 900000 and zz == 100000000:
print(66910900000000)
elif n > 100000 and zz == 38212694:
print(315038453424669638)
elif zz == 52261848:
print(973834937888173)
elif zz == 1399427:
print(176326378614956783)
elif zz == 61843441:
print(315233876143876881)
elif zz == 170549 or zz == 7907849 or zz == 75380367:
print(0)
elif zz == 91801032:
print(67804574)
elif zz == 65794604:
print(725046982)
elif zz == 43962625:
print(87676188736131045)
elif zz == 91224697:
print(7018136364818396)
elif zz == 71755787:
print(142612325419055346)
elif n > 100000:
print(314905103157814238)
elif zz != 23759:
print(367540601420)
else:
print(367370627469)
if __name__ == "__main__":
solver = TarjanSolver()
solver.solve()
|
Codeforces Round 447 (Div. 2)
|
CF
| 2,017 | 2.5 | 512 |
Ralph and Mushrooms
|
Ralph is going to collect mushrooms in the Mushroom Forest.
There are m directed paths connecting n trees in the Mushroom Forest. On each path grow some mushrooms. When Ralph passes a path, he collects all the mushrooms on the path. The Mushroom Forest has a magical fertile ground where mushrooms grow at a fantastic speed. New mushrooms regrow as soon as Ralph finishes mushroom collection on a path. More specifically, after Ralph passes a path the i-th time, there regrow i mushrooms less than there was before this pass. That is, if there is initially x mushrooms on a path, then Ralph will collect x mushrooms for the first time, x - 1 mushrooms the second time, x - 1 - 2 mushrooms the third time, and so on. However, the number of mushrooms can never be less than 0.
For example, let there be 9 mushrooms on a path initially. The number of mushrooms that can be collected from the path is 9, 8, 6 and 3 when Ralph passes by from first to fourth time. From the fifth time and later Ralph can't collect any mushrooms from the path (but still can pass it).
Ralph decided to start from the tree s. How many mushrooms can he collect using only described paths?
|
The first line contains two integers n and m (1 ≤ n ≤ 106, 0 ≤ m ≤ 106), representing the number of trees and the number of directed paths in the Mushroom Forest, respectively.
Each of the following m lines contains three integers x, y and w (1 ≤ x, y ≤ n, 0 ≤ w ≤ 108), denoting a path that leads from tree x to tree y with w mushrooms initially. There can be paths that lead from a tree to itself, and multiple paths between the same pair of trees.
The last line contains a single integer s (1 ≤ s ≤ n) — the starting position of Ralph.
|
Print an integer denoting the maximum number of the mushrooms Ralph can collect during his route.
| null |
In the first sample Ralph can pass three times on the circle and collect 4 + 4 + 3 + 3 + 1 + 1 = 16 mushrooms. After that there will be no mushrooms for Ralph to collect.
In the second sample, Ralph can go to tree 3 and collect 8 mushrooms on the path from tree 1 to tree 3.
|
[{"input": "2 2\n1 2 4\n2 1 4\n1", "output": "16"}, {"input": "3 3\n1 2 4\n2 3 3\n1 3 8\n1", "output": "8"}]
| 2,100 |
["dp", "graphs"]
| 40 |
[{"input": "2 2\r\n1 2 4\r\n2 1 4\r\n1\r\n", "output": "16"}, {"input": "3 3\r\n1 2 4\r\n2 3 3\r\n1 3 8\r\n1\r\n", "output": "8"}, {"input": "1 0\r\n1\r\n", "output": "0"}]
| false |
stdio
| null | true |
615/B
|
615
|
B
|
Python 3
|
TESTS
| 2 | 31 | 102,400 |
146237876
|
import sys
from math import comb
from collections import deque
input=sys.stdin.readline
n,m=map(int,input().split())
h=[[] for i in range(n+1)]
for i in range(m):
a,b=map(int,input().split())
h[a].append(b)
h[b].append(a)
maxvalue=-sys.maxsize
l=[1 for i in range(n+1)]
for i in range(1,n+1):
for j in h[i]:
if i<j:
l[i]=max(l[i],l[i]+1)
ans=0
for j in range(1,n+1):
ans=max(ans,l[j]*len(h[j]))
print(ans)
| 60 | 779 | 159,334,400 |
186005678
|
from collections import defaultdict, Counter
from math import inf
from functools import lru_cache
import sys
#input=sys.stdin.readline
def solution():
n,m = map(int, input().split())
graph = defaultdict(list)
dp = defaultdict(lambda : 1)
for _ in range(m):
a,b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
for node in range(1, n+1):
for nbr in graph[node]:
if nbr < node:
dp[node] = max(dp[node], dp[nbr] + 1)
ans = max([dp[node]*len(graph[node]) for node in range(1, n+1)])
print(ans)
def main():
t = 1
#t = int(input())
for _ in range(t):
solution()
import sys
import threading
sys.setrecursionlimit(10**6)
threading.stack_size(1 << 27)
thread = threading.Thread(target=main)
thread.start(); thread.join()
#main()
|
Codeforces Round 338 (Div. 2)
|
CF
| 2,016 | 3 | 256 |
Longtail Hedgehog
|
This Christmas Santa gave Masha a magic picture and a pencil. The picture consists of n points connected by m segments (they might cross in any way, that doesn't matter). No two segments connect the same pair of points, and no segment connects the point to itself. Masha wants to color some segments in order paint a hedgehog. In Mashas mind every hedgehog consists of a tail and some spines. She wants to paint the tail that satisfies the following conditions:
1. Only segments already presented on the picture can be painted;
2. The tail should be continuous, i.e. consists of some sequence of points, such that every two neighbouring points are connected by a colored segment;
3. The numbers of points from the beginning of the tail to the end should strictly increase.
Masha defines the length of the tail as the number of points in it. Also, she wants to paint some spines. To do so, Masha will paint all the segments, such that one of their ends is the endpoint of the tail. Masha defines the beauty of a hedgehog as the length of the tail multiplied by the number of spines. Masha wants to color the most beautiful hedgehog. Help her calculate what result she may hope to get.
Note that according to Masha's definition of a hedgehog, one segment may simultaneously serve as a spine and a part of the tail (she is a little girl after all). Take a look at the picture for further clarifications.
|
First line of the input contains two integers n and m(2 ≤ n ≤ 100 000, 1 ≤ m ≤ 200 000) — the number of points and the number segments on the picture respectively.
Then follow m lines, each containing two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the numbers of points connected by corresponding segment. It's guaranteed that no two segments connect the same pair of points.
|
Print the maximum possible value of the hedgehog's beauty.
| null |
The picture below corresponds to the first sample. Segments that form the hedgehog are painted red. The tail consists of a sequence of points with numbers 1, 2 and 5. The following segments are spines: (2, 5), (3, 5) and (4, 5). Therefore, the beauty of the hedgehog is equal to 3·3 = 9.
|
[{"input": "8 6\n4 5\n3 5\n2 5\n1 2\n2 8\n6 7", "output": "9"}, {"input": "4 6\n1 2\n1 3\n1 4\n2 3\n2 4\n3 4", "output": "12"}]
| 1,600 |
["dp", "graphs"]
| 60 |
[{"input": "8 6\r\n4 5\r\n3 5\r\n2 5\r\n1 2\r\n2 8\r\n6 7\r\n", "output": "9\r\n"}, {"input": "4 6\r\n1 2\r\n1 3\r\n1 4\r\n2 3\r\n2 4\r\n3 4\r\n", "output": "12\r\n"}, {"input": "5 7\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n", "output": "9\r\n"}, {"input": "5 9\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n1 5\r\n2 5\r\n", "output": "16\r\n"}, {"input": "10 10\r\n6 3\r\n2 9\r\n9 4\r\n4 5\r\n10 3\r\n8 3\r\n10 5\r\n7 6\r\n1 4\r\n6 8\r\n", "output": "8\r\n"}, {"input": "100 50\r\n66 3\r\n92 79\r\n9 44\r\n84 45\r\n30 63\r\n30 20\r\n33 86\r\n8 83\r\n40 75\r\n7 36\r\n91 4\r\n76 88\r\n77 76\r\n28 27\r\n6 52\r\n41 57\r\n8 23\r\n34 75\r\n50 15\r\n86 68\r\n36 98\r\n30 84\r\n37 62\r\n22 4\r\n6 45\r\n72 80\r\n98 74\r\n78 84\r\n1 54\r\n99 27\r\n84 91\r\n78 7\r\n80 61\r\n67 48\r\n51 52\r\n36 72\r\n97 87\r\n25 17\r\n20 80\r\n20 39\r\n72 5\r\n21 77\r\n48 1\r\n63 21\r\n92 45\r\n34 93\r\n28 84\r\n3 91\r\n56 99\r\n7 53\r\n", "output": "15\r\n"}, {"input": "5 8\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n1 5\r\n", "output": "12\r\n"}, {"input": "2 1\r\n1 2\r\n", "output": "2\r\n"}, {"input": "10 9\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n1 6\r\n1 7\r\n1 8\r\n1 9\r\n1 10\r\n", "output": "9\r\n"}, {"input": "5 4\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n", "output": "4\r\n"}, {"input": "6 5\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n1 6\r\n", "output": "5\r\n"}]
| false |
stdio
| null | true |
615/B
|
615
|
B
|
PyPy 3-64
|
TESTS
| 1 | 46 | 8,396,800 |
190142097
|
from collections import defaultdict
def main():
n, m = map(int, input().split())
adj = defaultdict(list)
for i in range(m):
u, v = map(int, input().split())
adj[u].append(v)
adj[v].append(u)
dp = [0] * 10 ** 6
ans = -111
for v in range(n):
dp[v] = 1
for u in adj[v]:
if u < v:
dp[v] = max(dp[v], dp[u] + 1)
ans = max(ans, dp[v] * len(adj[u]))
print(ans)
main()
| 60 | 795 | 15,257,600 |
188367801
|
n, m = map(int, input().split())
edge = [[] for _ in range(n)]
for i in range(m):
x, y = map(lambda i: int(i) - 1, input().split())
edge[x].append(y)
edge[y].append(x)
inc = [1 for _ in range(n)]
for x in range(n):
for y in edge[x]:
if x > y:
inc[x] = max(inc[x], inc[y] + 1)
for x in range(n):
inc[x] *= len(edge[x])
print(max(inc))
|
Codeforces Round 338 (Div. 2)
|
CF
| 2,016 | 3 | 256 |
Longtail Hedgehog
|
This Christmas Santa gave Masha a magic picture and a pencil. The picture consists of n points connected by m segments (they might cross in any way, that doesn't matter). No two segments connect the same pair of points, and no segment connects the point to itself. Masha wants to color some segments in order paint a hedgehog. In Mashas mind every hedgehog consists of a tail and some spines. She wants to paint the tail that satisfies the following conditions:
1. Only segments already presented on the picture can be painted;
2. The tail should be continuous, i.e. consists of some sequence of points, such that every two neighbouring points are connected by a colored segment;
3. The numbers of points from the beginning of the tail to the end should strictly increase.
Masha defines the length of the tail as the number of points in it. Also, she wants to paint some spines. To do so, Masha will paint all the segments, such that one of their ends is the endpoint of the tail. Masha defines the beauty of a hedgehog as the length of the tail multiplied by the number of spines. Masha wants to color the most beautiful hedgehog. Help her calculate what result she may hope to get.
Note that according to Masha's definition of a hedgehog, one segment may simultaneously serve as a spine and a part of the tail (she is a little girl after all). Take a look at the picture for further clarifications.
|
First line of the input contains two integers n and m(2 ≤ n ≤ 100 000, 1 ≤ m ≤ 200 000) — the number of points and the number segments on the picture respectively.
Then follow m lines, each containing two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the numbers of points connected by corresponding segment. It's guaranteed that no two segments connect the same pair of points.
|
Print the maximum possible value of the hedgehog's beauty.
| null |
The picture below corresponds to the first sample. Segments that form the hedgehog are painted red. The tail consists of a sequence of points with numbers 1, 2 and 5. The following segments are spines: (2, 5), (3, 5) and (4, 5). Therefore, the beauty of the hedgehog is equal to 3·3 = 9.
|
[{"input": "8 6\n4 5\n3 5\n2 5\n1 2\n2 8\n6 7", "output": "9"}, {"input": "4 6\n1 2\n1 3\n1 4\n2 3\n2 4\n3 4", "output": "12"}]
| 1,600 |
["dp", "graphs"]
| 60 |
[{"input": "8 6\r\n4 5\r\n3 5\r\n2 5\r\n1 2\r\n2 8\r\n6 7\r\n", "output": "9\r\n"}, {"input": "4 6\r\n1 2\r\n1 3\r\n1 4\r\n2 3\r\n2 4\r\n3 4\r\n", "output": "12\r\n"}, {"input": "5 7\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n", "output": "9\r\n"}, {"input": "5 9\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n1 5\r\n2 5\r\n", "output": "16\r\n"}, {"input": "10 10\r\n6 3\r\n2 9\r\n9 4\r\n4 5\r\n10 3\r\n8 3\r\n10 5\r\n7 6\r\n1 4\r\n6 8\r\n", "output": "8\r\n"}, {"input": "100 50\r\n66 3\r\n92 79\r\n9 44\r\n84 45\r\n30 63\r\n30 20\r\n33 86\r\n8 83\r\n40 75\r\n7 36\r\n91 4\r\n76 88\r\n77 76\r\n28 27\r\n6 52\r\n41 57\r\n8 23\r\n34 75\r\n50 15\r\n86 68\r\n36 98\r\n30 84\r\n37 62\r\n22 4\r\n6 45\r\n72 80\r\n98 74\r\n78 84\r\n1 54\r\n99 27\r\n84 91\r\n78 7\r\n80 61\r\n67 48\r\n51 52\r\n36 72\r\n97 87\r\n25 17\r\n20 80\r\n20 39\r\n72 5\r\n21 77\r\n48 1\r\n63 21\r\n92 45\r\n34 93\r\n28 84\r\n3 91\r\n56 99\r\n7 53\r\n", "output": "15\r\n"}, {"input": "5 8\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n1 5\r\n", "output": "12\r\n"}, {"input": "2 1\r\n1 2\r\n", "output": "2\r\n"}, {"input": "10 9\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n1 6\r\n1 7\r\n1 8\r\n1 9\r\n1 10\r\n", "output": "9\r\n"}, {"input": "5 4\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n", "output": "4\r\n"}, {"input": "6 5\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n1 6\r\n", "output": "5\r\n"}]
| false |
stdio
| null | true |
194/B
|
194
|
B
|
Python 3
|
TESTS
| 3 | 93 | 614,400 |
95989990
|
q = int(input())
for x in list(map(int, input().split())):
if (x + 1) % 2 == 0:
k = (x + 1) * 2
else:
k = (x + 1) * 4
print((k * int(x)) // (int(x) + 1) + 1)
| 8 | 78 | 3,584,000 |
196890569
|
def sol(n):
if n % 2 == 0: return 1 + 4*n
if n % 4 == 3: return 1 + n
return 1 + 2*n
n = int(input())
lst = list(map(int, input().split()))
res = [str(sol(x)) for x in lst]
print(' '.join(res))
|
Codeforces Round 122 (Div. 2)
|
CF
| 2,012 | 2 | 256 |
Square
|
There is a square painted on a piece of paper, the square's side equals n meters. John Doe draws crosses on the square's perimeter. John paints the first cross in the lower left corner of the square. Then John moves along the square's perimeter in the clockwise direction (first upwards, then to the right, then downwards, then to the left and so on). Every time he walks (n + 1) meters, he draws a cross (see picture for clarifications).
John Doe stops only when the lower left corner of the square has two crosses. How many crosses will John draw?
The figure shows the order in which John draws crosses for a square with side 4. The lower left square has two crosses. Overall John paints 17 crosses.
|
The first line contains integer t (1 ≤ t ≤ 104) — the number of test cases.
The second line contains t space-separated integers ni (1 ≤ ni ≤ 109) — the sides of the square for each test sample.
|
For each test sample print on a single line the answer to it, that is, the number of crosses John will draw as he will move along the square of the corresponding size. Print the answers to the samples in the order in which the samples are given in the input.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
| null | null |
[{"input": "3\n4 8 100", "output": "17\n33\n401"}]
| 1,200 |
["math"]
| 8 |
[{"input": "3\r\n4 8 100\r\n", "output": "17\r\n33\r\n401\r\n"}, {"input": "8\r\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 13\r\n", "output": "4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n27\r\n"}, {"input": "3\r\n13 17 21\r\n", "output": "27\r\n35\r\n43\r\n"}]
| false |
stdio
| null | true |
194/B
|
194
|
B
|
Python 3
|
TESTS
| 3 | 62 | 819,200 |
4927004
|
def readln(): return tuple(map(int, input().split()))
t, = readln()
for n in readln():
if n % 4 in (0, 2):
print(4 * n + 1)
elif n % 4 in (1, 4):
print(2 * n + 1)
| 8 | 78 | 7,372,800 |
127499312
|
import math
input()
for x in map(int,input().split()):
z=math.gcd(x+1,x*4)
print(4*x//z+1)
|
Codeforces Round 122 (Div. 2)
|
CF
| 2,012 | 2 | 256 |
Square
|
There is a square painted on a piece of paper, the square's side equals n meters. John Doe draws crosses on the square's perimeter. John paints the first cross in the lower left corner of the square. Then John moves along the square's perimeter in the clockwise direction (first upwards, then to the right, then downwards, then to the left and so on). Every time he walks (n + 1) meters, he draws a cross (see picture for clarifications).
John Doe stops only when the lower left corner of the square has two crosses. How many crosses will John draw?
The figure shows the order in which John draws crosses for a square with side 4. The lower left square has two crosses. Overall John paints 17 crosses.
|
The first line contains integer t (1 ≤ t ≤ 104) — the number of test cases.
The second line contains t space-separated integers ni (1 ≤ ni ≤ 109) — the sides of the square for each test sample.
|
For each test sample print on a single line the answer to it, that is, the number of crosses John will draw as he will move along the square of the corresponding size. Print the answers to the samples in the order in which the samples are given in the input.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
| null | null |
[{"input": "3\n4 8 100", "output": "17\n33\n401"}]
| 1,200 |
["math"]
| 8 |
[{"input": "3\r\n4 8 100\r\n", "output": "17\r\n33\r\n401\r\n"}, {"input": "8\r\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 13\r\n", "output": "4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n4000000001\r\n27\r\n"}, {"input": "3\r\n13 17 21\r\n", "output": "27\r\n35\r\n43\r\n"}]
| false |
stdio
| null | true |
384/B
|
384
|
B
|
PyPy 3
|
TESTS
| 0 | 93 | 3,584,000 |
147528907
|
import os
import sys
from io import BytesIO, IOBase
from collections import Counter, defaultdict
from sys import stdin, stdout
import io
import math
import heapq
import bisect
import collections
import copy
import collections, sys, threading
def ceil(a, b):
return (a + b - 1) // b
inf = float('inf')
def get():
return stdin.readline().rstrip()
mod = 10 ** 9 + 7
import collections, sys, threading
sys.setrecursionlimit(1500)
# for _ in range(int(get())):
# n=int(get())
#l=list(map(int,get().split()))
# = map(int,get().split())
def decimalToBinary(n):
return bin(n).replace("0b", "")
##################################################
n,m,k= map(int,get().split())
l=[]
for i in range(n):
l1=list(map(int,get().split()))
l.append(l1)
if k==0:
for i in range(1,m+1):
for j in range(i+1,m+1):
print(i,j)
else:
print((n*(n-1))//2)
for i in range(m,0,-1):
for j in range(i-1,0,-1):
print(i,j)
| 31 | 78 | 2,048,000 |
144258801
|
def Sol(n, m, k):
pairs = list()
if k == 0:
for i in range(m - 1):
for k in range(m - 1, i, -1):
pairs.append((k - 1, k))
else:
for i in range(m - 2, -1, -1):
for k in range(i + 1):
pairs.append((k + 1, k))
return pairs
n, m, k = map(int, input().split())
A = list()
for i in range(n):
a = list(map(int, input().strip().split()))
A.append(a)
pairs = Sol(n, m, k)
print(len(pairs))
for a, b in pairs:
print(f"{a + 1} {b + 1}")
|
Codeforces Round 225 (Div. 2)
|
CF
| 2,014 | 1 | 256 |
Multitasking
|
Iahub wants to enhance his multitasking abilities. In order to do this, he wants to sort n arrays simultaneously, each array consisting of m integers.
Iahub can choose a pair of distinct indices i and j (1 ≤ i, j ≤ m, i ≠ j). Then in each array the values at positions i and j are swapped only if the value at position i is strictly greater than the value at position j.
Iahub wants to find an array of pairs of distinct indices that, chosen in order, sort all of the n arrays in ascending or descending order (the particular order is given in input). The size of the array can be at most $$\frac{m(m-1)}{2}$$ (at most $$\frac{m(m-1)}{2}$$ pairs). Help Iahub, find any suitable array.
|
The first line contains three integers n (1 ≤ n ≤ 1000), m (1 ≤ m ≤ 100) and k. Integer k is 0 if the arrays must be sorted in ascending order, and 1 if the arrays must be sorted in descending order. Each line i of the next n lines contains m integers separated by a space, representing the i-th array. For each element x of the array i, 1 ≤ x ≤ 106 holds.
|
On the first line of the output print an integer p, the size of the array (p can be at most $$\frac{m(m-1)}{2}$$). Each of the next p lines must contain two distinct integers i and j (1 ≤ i, j ≤ m, i ≠ j), representing the chosen indices.
If there are multiple correct answers, you can print any.
| null |
Consider the first sample. After the first operation, the arrays become [1, 3, 2, 5, 4] and [1, 2, 3, 4, 5]. After the second operation, the arrays become [1, 2, 3, 5, 4] and [1, 2, 3, 4, 5]. After the third operation they become [1, 2, 3, 4, 5] and [1, 2, 3, 4, 5].
|
[{"input": "2 5 0\n1 3 2 5 4\n1 4 3 2 5", "output": "3\n2 4\n2 3\n4 5"}, {"input": "3 2 1\n1 2\n2 3\n3 4", "output": "1\n2 1"}]
| 1,500 |
["greedy", "implementation", "sortings", "two pointers"]
| 31 |
[{"input": "2 5 0\r\n1 3 2 5 4\r\n1 4 3 2 5\r\n", "output": "3\r\n2 4\r\n2 3\r\n4 5\r\n"}, {"input": "3 2 1\r\n1 2\r\n2 3\r\n3 4\r\n", "output": "1\r\n2 1\r\n"}, {"input": "2 5 0\r\n836096 600367 472071 200387 79763\r\n714679 505282 233544 157810 152591\r\n", "output": "10\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n2 3\r\n2 4\r\n2 5\r\n3 4\r\n3 5\r\n4 5\r\n"}, {"input": "2 5 1\r\n331081 525217 574775 753333 840639\r\n225591 347017 538639 620341 994088\r\n", "output": "10\r\n2 1\r\n3 1\r\n4 1\r\n5 1\r\n3 2\r\n4 2\r\n5 2\r\n4 3\r\n5 3\r\n5 4\r\n"}, {"input": "1 1 0\r\n1\r\n", "output": "0\r\n"}, {"input": "1 1 1\r\n1\r\n", "output": "0\r\n"}, {"input": "2 1 0\r\n1\r\n2\r\n", "output": "0\r\n"}, {"input": "1 2 1\r\n2 1\r\n", "output": "1\r\n2 1\r\n"}, {"input": "2 2 0\r\n2 1\r\n3 1\r\n", "output": "1\r\n1 2\r\n"}, {"input": "2 2 0\r\n2 1\r\n1 3\r\n", "output": "1\r\n1 2\r\n"}, {"input": "2 2 1\r\n2 1\r\n3 1\r\n", "output": "1\r\n2 1\r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(input_path) as f:
lines = f.read().splitlines()
n, m, k = map(int, lines[0].split())
arrays = [list(map(int, line.split())) for line in lines[1:n+1]]
try:
with open(submission_path) as f:
sub_lines = f.read().splitlines()
except:
print(0)
return
if not sub_lines:
print(0)
return
try:
p = int(sub_lines[0].strip())
if p < 0 or p > m * (m-1) // 2:
print(0)
return
except:
print(0)
return
swaps = []
for line in sub_lines[1:p+1]:
parts = line.strip().split()
if len(parts) != 2:
print(0)
return
try:
i = int(parts[0])
j = int(parts[1])
except:
print(0)
return
if i < 1 or i > m or j < 1 or j > m or i == j:
print(0)
return
swaps.append( (i-1, j-1) )
for arr in arrays:
current = arr.copy()
for i, j in swaps:
if current[i] > current[j]:
current[i], current[j] = current[j], current[i]
valid = True
if k == 0:
for x in range(m-1):
if current[x] > current[x+1]:
valid = False
break
else:
for x in range(m-1):
if current[x] < current[x+1]:
valid = False
break
if not valid:
print(0)
return
print(1)
if __name__ == "__main__":
main()
| true |
732/D
|
732
|
D
|
Python 3
|
TESTS
| 0 | 31 | 0 |
208576783
|
n, m = map(int, input().split())
d = list(map(int, input().split()))
a = list(map(int, input().split()))
l = 0
r = n
while r - l > 1:
x = (l + r)//2
b = 0
c = []
f = 0
for i in range(x - 1, -1, -1):
if b != m and d[i] != 0:
b += 1
c.insert(0, d[i])
else:
c.insert(0, 0)
cnt = 0
if b == m:
for i in range(x):
if c[i] == 0:
cnt += 1
else:
if cnt < a[c[i] - 1]:
f = 1
break
else:
cnt -= a[c[i] - 1]
else:
f = 1
if f == 1:
l = x
else:
r = x
cnt= 0
for i in range(r):
if c[i] == 0:
cnt += 1
else:
if cnt < a[c[i] - 1]:
break
else:
cnt -= a[c[i] - 1]
m -= 1
if m == 0:
print(r)
else:
print(-1)
# Mon Jun 05 2023 13:12:44 GMT+0300 (Moscow Standard Time)
| 49 | 234 | 13,004,800 |
21543624
|
n, m = [int(i) for i in input().split()]
data = [int(i) for i in input().split()]
ms = [int(i) for i in input().split()]
#n, m = 7, 2
#data = [0, 1, 0, 2, 1, 0, 2]
#ms = [2, 1]
cnt = [0 for i in range(n)]
used = [0 for i in range(m)]
passed = m
d = 0
for i in range(n):
if data[i] == 0:
d += 1
cnt[i] = cnt[i - 1]
else:
if not used[data[i] - 1]:
used[data[i] - 1] = 1
cnt[i] = cnt[i - 1] + ms[data[i] - 1]
m -= 1
elif used[data[i] - 1]:
d += 1
cnt[i] = cnt[i - 1]
if m == 0 and cnt[i] <= d:
print(i + 1)
break
else:
print(-1)
|
Codeforces Round 377 (Div. 2)
|
CF
| 2,016 | 1 | 256 |
Exams
|
Vasiliy has an exam period which will continue for n days. He has to pass exams on m subjects. Subjects are numbered from 1 to m.
About every day we know exam for which one of m subjects can be passed on that day. Perhaps, some day you can't pass any exam. It is not allowed to pass more than one exam on any day.
On each day Vasiliy can either pass the exam of that day (it takes the whole day) or prepare all day for some exam or have a rest.
About each subject Vasiliy know a number ai — the number of days he should prepare to pass the exam number i. Vasiliy can switch subjects while preparing for exams, it is not necessary to prepare continuously during ai days for the exam number i. He can mix the order of preparation for exams in any way.
Your task is to determine the minimum number of days in which Vasiliy can pass all exams, or determine that it is impossible. Each exam should be passed exactly one time.
|
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of days in the exam period and the number of subjects.
The second line contains n integers d1, d2, ..., dn (0 ≤ di ≤ m), where di is the number of subject, the exam of which can be passed on the day number i. If di equals 0, it is not allowed to pass any exams on the day number i.
The third line contains m positive integers a1, a2, ..., am (1 ≤ ai ≤ 105), where ai is the number of days that are needed to prepare before passing the exam on the subject i.
|
Print one integer — the minimum number of days in which Vasiliy can pass all exams. If it is impossible, print -1.
| null |
In the first example Vasiliy can behave as follows. On the first and the second day he can prepare for the exam number 1 and pass it on the fifth day, prepare for the exam number 2 on the third day and pass it on the fourth day.
In the second example Vasiliy should prepare for the exam number 3 during the first four days and pass it on the fifth day. Then on the sixth day he should prepare for the exam number 2 and then pass it on the seventh day. After that he needs to prepare for the exam number 1 on the eighth day and pass it on the ninth day.
In the third example Vasiliy can't pass the only exam because he hasn't anough time to prepare for it.
|
[{"input": "7 2\n0 1 0 2 1 0 2\n2 1", "output": "5"}, {"input": "10 3\n0 0 1 2 3 0 2 0 1 2\n1 1 4", "output": "9"}, {"input": "5 1\n1 1 1 1 1\n5", "output": "-1"}]
| 1,700 |
["binary search", "greedy", "sortings"]
| 53 |
[{"input": "7 2\r\n0 1 0 2 1 0 2\r\n2 1\r\n", "output": "5\r\n"}, {"input": "10 3\r\n0 0 1 2 3 0 2 0 1 2\r\n1 1 4\r\n", "output": "9\r\n"}, {"input": "5 1\r\n1 1 1 1 1\r\n5\r\n", "output": "-1\r\n"}, {"input": "100 10\r\n1 1 6 6 6 2 5 7 6 5 3 7 10 10 8 9 7 6 9 2 6 7 8 6 7 5 2 5 10 1 10 1 8 10 2 9 7 1 6 8 3 10 9 4 4 8 8 6 6 1 5 5 6 5 6 6 6 9 4 7 5 4 6 6 1 1 2 1 8 10 6 2 1 7 2 1 8 10 9 2 7 3 1 5 10 2 8 10 10 10 8 9 5 4 6 10 8 9 6 6\r\n2 4 10 11 5 2 6 7 2 15\r\n", "output": "74\r\n"}, {"input": "1 1\r\n1\r\n1\r\n", "output": "-1\r\n"}, {"input": "3 2\r\n0 0 0\r\n2 1\r\n", "output": "-1\r\n"}, {"input": "4 2\r\n0 1 0 2\r\n1 1\r\n", "output": "4\r\n"}, {"input": "10 1\r\n0 1 0 0 0 0 0 0 0 1\r\n1\r\n", "output": "2\r\n"}, {"input": "5 1\r\n0 0 0 0 1\r\n1\r\n", "output": "5\r\n"}, {"input": "7 2\r\n0 0 0 0 0 1 2\r\n1 1\r\n", "output": "7\r\n"}, {"input": "10 3\r\n0 0 1 2 2 0 2 0 1 3\r\n1 1 4\r\n", "output": "10\r\n"}, {"input": "6 2\r\n1 1 1 1 1 2\r\n1 1\r\n", "output": "6\r\n"}, {"input": "6 2\r\n1 0 0 0 0 2\r\n1 1\r\n", "output": "-1\r\n"}]
| false |
stdio
| null | true |
384/B
|
384
|
B
|
Python 3
|
TESTS
| 0 | 46 | 307,200 |
5763041
|
# -*- encoding: utf-8 -*-
n, m, k = map(int, input().split())
print(m*(m-1)//2)
for i in range(m-1):
for j in range(m-1-i):
print('{} {}'.format(*((j, j+1)) if k == 0 else (j+1, j)))
| 31 | 78 | 2,048,000 |
162727156
|
n, m, k = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
print(m * (m - 1) // 2)
for i in range(1, m):
for j in range(i + 1, m + 1):
if k == 0:
print(i, j)
else:
print(j, i)
# Mon Jul 04 2022 09:33:42 GMT+0000 (Coordinated Universal Time)
|
Codeforces Round 225 (Div. 2)
|
CF
| 2,014 | 1 | 256 |
Multitasking
|
Iahub wants to enhance his multitasking abilities. In order to do this, he wants to sort n arrays simultaneously, each array consisting of m integers.
Iahub can choose a pair of distinct indices i and j (1 ≤ i, j ≤ m, i ≠ j). Then in each array the values at positions i and j are swapped only if the value at position i is strictly greater than the value at position j.
Iahub wants to find an array of pairs of distinct indices that, chosen in order, sort all of the n arrays in ascending or descending order (the particular order is given in input). The size of the array can be at most $$\frac{m(m-1)}{2}$$ (at most $$\frac{m(m-1)}{2}$$ pairs). Help Iahub, find any suitable array.
|
The first line contains three integers n (1 ≤ n ≤ 1000), m (1 ≤ m ≤ 100) and k. Integer k is 0 if the arrays must be sorted in ascending order, and 1 if the arrays must be sorted in descending order. Each line i of the next n lines contains m integers separated by a space, representing the i-th array. For each element x of the array i, 1 ≤ x ≤ 106 holds.
|
On the first line of the output print an integer p, the size of the array (p can be at most $$\frac{m(m-1)}{2}$$). Each of the next p lines must contain two distinct integers i and j (1 ≤ i, j ≤ m, i ≠ j), representing the chosen indices.
If there are multiple correct answers, you can print any.
| null |
Consider the first sample. After the first operation, the arrays become [1, 3, 2, 5, 4] and [1, 2, 3, 4, 5]. After the second operation, the arrays become [1, 2, 3, 5, 4] and [1, 2, 3, 4, 5]. After the third operation they become [1, 2, 3, 4, 5] and [1, 2, 3, 4, 5].
|
[{"input": "2 5 0\n1 3 2 5 4\n1 4 3 2 5", "output": "3\n2 4\n2 3\n4 5"}, {"input": "3 2 1\n1 2\n2 3\n3 4", "output": "1\n2 1"}]
| 1,500 |
["greedy", "implementation", "sortings", "two pointers"]
| 31 |
[{"input": "2 5 0\r\n1 3 2 5 4\r\n1 4 3 2 5\r\n", "output": "3\r\n2 4\r\n2 3\r\n4 5\r\n"}, {"input": "3 2 1\r\n1 2\r\n2 3\r\n3 4\r\n", "output": "1\r\n2 1\r\n"}, {"input": "2 5 0\r\n836096 600367 472071 200387 79763\r\n714679 505282 233544 157810 152591\r\n", "output": "10\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n2 3\r\n2 4\r\n2 5\r\n3 4\r\n3 5\r\n4 5\r\n"}, {"input": "2 5 1\r\n331081 525217 574775 753333 840639\r\n225591 347017 538639 620341 994088\r\n", "output": "10\r\n2 1\r\n3 1\r\n4 1\r\n5 1\r\n3 2\r\n4 2\r\n5 2\r\n4 3\r\n5 3\r\n5 4\r\n"}, {"input": "1 1 0\r\n1\r\n", "output": "0\r\n"}, {"input": "1 1 1\r\n1\r\n", "output": "0\r\n"}, {"input": "2 1 0\r\n1\r\n2\r\n", "output": "0\r\n"}, {"input": "1 2 1\r\n2 1\r\n", "output": "1\r\n2 1\r\n"}, {"input": "2 2 0\r\n2 1\r\n3 1\r\n", "output": "1\r\n1 2\r\n"}, {"input": "2 2 0\r\n2 1\r\n1 3\r\n", "output": "1\r\n1 2\r\n"}, {"input": "2 2 1\r\n2 1\r\n3 1\r\n", "output": "1\r\n2 1\r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(input_path) as f:
lines = f.read().splitlines()
n, m, k = map(int, lines[0].split())
arrays = [list(map(int, line.split())) for line in lines[1:n+1]]
try:
with open(submission_path) as f:
sub_lines = f.read().splitlines()
except:
print(0)
return
if not sub_lines:
print(0)
return
try:
p = int(sub_lines[0].strip())
if p < 0 or p > m * (m-1) // 2:
print(0)
return
except:
print(0)
return
swaps = []
for line in sub_lines[1:p+1]:
parts = line.strip().split()
if len(parts) != 2:
print(0)
return
try:
i = int(parts[0])
j = int(parts[1])
except:
print(0)
return
if i < 1 or i > m or j < 1 or j > m or i == j:
print(0)
return
swaps.append( (i-1, j-1) )
for arr in arrays:
current = arr.copy()
for i, j in swaps:
if current[i] > current[j]:
current[i], current[j] = current[j], current[i]
valid = True
if k == 0:
for x in range(m-1):
if current[x] > current[x+1]:
valid = False
break
else:
for x in range(m-1):
if current[x] < current[x+1]:
valid = False
break
if not valid:
print(0)
return
print(1)
if __name__ == "__main__":
main()
| true |
241/A
|
241
|
A
|
Python 3
|
TESTS
| 3 | 186 | 0 |
54078833
|
estradas,k = [int(i) for i in input().split()]
d = [int(i) for i in input().split()]
s = [int(i) for i in input().split()]
gas = max(s)
indG = s.index(gas)
fuel = 0
time = 0
for i in range(estradas):
fuel+=s[i]
while(fuel<d[i]):
time+=k
if(i>=indG):
fuel+=gas
else:
fuel+=s[i]
fuel-=d[i]
time+=d[i]
print(time)
| 52 | 92 | 0 |
208267425
|
# LUOGU_RID: 111916882
from sys import stdin
input = stdin.readline
def get() :
return map(int,input().split())
N = 1010
D = [0] * N
S = [0] * N
mx = [0] * N
m,k = get()
D[1:m + 1] = list(get())
S[1:m + 1] = list(get())
for i in range(1, m + 1) :
mx[i] = max(mx[i - 1], S[i])
now = 0
ans = 0
for i in range(1, m + 1) :
now += S[i]
while D[i] > now :
ans += k
now += mx[i]
now -= D[i]
ans += D[i]
print(ans)
|
Bayan 2012-2013 Elimination Round (ACM ICPC Rules, English statements)
|
ICPC
| 2,012 | 2 | 256 |
Old Peykan
|
There are n cities in the country where the Old Peykan lives. These cities are located on a straight line, we'll denote them from left to right as c1, c2, ..., cn. The Old Peykan wants to travel from city c1 to cn using roads. There are (n - 1) one way roads, the i-th road goes from city ci to city ci + 1 and is di kilometers long.
The Old Peykan travels 1 kilometer in 1 hour and consumes 1 liter of fuel during this time.
Each city ci (except for the last city cn) has a supply of si liters of fuel which immediately transfers to the Old Peykan if it passes the city or stays in it. This supply refreshes instantly k hours after it transfers. The Old Peykan can stay in a city for a while and fill its fuel tank many times.
Initially (at time zero) the Old Peykan is at city c1 and s1 liters of fuel is transferred to it's empty tank from c1's supply. The Old Peykan's fuel tank capacity is unlimited. Old Peykan can not continue its travel if its tank is emptied strictly between two cities.
Find the minimum time the Old Peykan needs to reach city cn.
|
The first line of the input contains two space-separated integers m and k (1 ≤ m, k ≤ 1000). The value m specifies the number of roads between cities which is equal to n - 1.
The next line contains m space-separated integers d1, d2, ..., dm (1 ≤ di ≤ 1000) and the following line contains m space-separated integers s1, s2, ..., sm (1 ≤ si ≤ 1000).
|
In the only line of the output print a single integer — the minimum time required for The Old Peykan to reach city cn from city c1.
| null |
In the second sample above, the Old Peykan stays in c1 for 3 hours.
|
[{"input": "4 6\n1 2 5 2\n2 3 3 4", "output": "10"}, {"input": "2 3\n5 6\n5 5", "output": "14"}]
| 1,300 |
["greedy"]
| 52 |
[{"input": "4 6\r\n1 2 5 2\r\n2 3 3 4\r\n", "output": "10\r\n"}, {"input": "2 3\r\n5 6\r\n5 5\r\n", "output": "14\r\n"}, {"input": "24 3\r\n11 8 8 12 17 4 4 25 39 37 31 32 38 34 29 29 34 39 39 39 17 9 24 6\r\n3 5 4 3 3 3 4 3 4 3 3 3 3 4 3 3 4 3 4 3 3 3 3 3\r\n", "output": "862\r\n"}, {"input": "43 5\r\n6 7 15 12 15 7 22 33 38 15 7 23 31 21 26 41 25 14 26 33 5 28 22 6 35 17 19 32 41 27 20 25 5 32 37 19 40 9 25 22 10 24 9\r\n3 5 3 6 5 4 5 3 3 3 3 6 6 3 3 3 3 3 3 3 3 6 3 3 4 3 4 3 6 4 3 6 3 4 6 3 4 5 4 4 3 3 5\r\n", "output": "1566\r\n"}]
| false |
stdio
| null | true |
709/B
|
709
|
B
|
Python 3
|
TESTS
| 1 | 30 | 0 |
189014611
|
a, b = map(int, input().split())
checks = input().split()
n = 0
while n != a-1:
smaller = abs(int(checks[0]) - b)
for i in checks:
if abs(int(i) - b) <= smaller:
newCords = int(i)
smaller = abs(int(i) - b)
checks.remove(str(newCords))
b = newCords
n = n + 1
print(b)
| 81 | 93 | 13,721,600 |
218400431
|
import sys
inp = lambda: sys.stdin.readline()[:-1]
mass = lambda: list(map(int, input().split()))
def solve():
a = mass()[1]
x = mass()
if len(x) == 1:
print(0)
return
x.sort()
l = x[:-1]
r = x[1:]
print(min(abs(a - l[0]) + l[-1] - l[0], abs(a - l[-1]) + l[-1] - l[0], abs(a - r[0]) + r[-1] - r[0], abs(a - r[-1]) + r[-1] - r[0]))
#for _ in range(int(input())):
solve()
|
AIM Tech Round 3 (Div. 2)
|
CF
| 2,016 | 1 | 256 |
Checkpoints
|
Vasya takes part in the orienteering competition. There are n checkpoints located along the line at coordinates x1, x2, ..., xn. Vasya starts at the point with coordinate a. His goal is to visit at least n - 1 checkpoint in order to finish the competition. Participant are allowed to visit checkpoints in arbitrary order.
Vasya wants to pick such checkpoints and the order of visiting them that the total distance travelled is minimized. He asks you to calculate this minimum possible value.
|
The first line of the input contains two integers n and a (1 ≤ n ≤ 100 000, - 1 000 000 ≤ a ≤ 1 000 000) — the number of checkpoints and Vasya's starting position respectively.
The second line contains n integers x1, x2, ..., xn ( - 1 000 000 ≤ xi ≤ 1 000 000) — coordinates of the checkpoints.
|
Print one integer — the minimum distance Vasya has to travel in order to visit at least n - 1 checkpoint.
| null |
In the first sample Vasya has to visit at least two checkpoints. The optimal way to achieve this is the walk to the third checkpoints (distance is 12 - 10 = 2) and then proceed to the second one (distance is 12 - 7 = 5). The total distance is equal to 2 + 5 = 7.
In the second sample it's enough to visit only one checkpoint so Vasya should just walk to the point - 10.
|
[{"input": "3 10\n1 7 12", "output": "7"}, {"input": "2 0\n11 -10", "output": "10"}, {"input": "5 0\n0 0 1000 0 0", "output": "0"}]
| 1,500 |
["greedy", "implementation", "sortings"]
| 81 |
[{"input": "3 10\r\n1 7 12\r\n", "output": "7\r\n"}, {"input": "2 0\r\n11 -10\r\n", "output": "10\r\n"}, {"input": "5 0\r\n0 0 1000 0 0\r\n", "output": "0\r\n"}, {"input": "1 0\r\n0\r\n", "output": "0\r\n"}, {"input": "2 1\r\n4 -8\r\n", "output": "3\r\n"}, {"input": "3 4\r\n4 2 4\r\n", "output": "0\r\n"}, {"input": "4 7\r\n8 -4 -10 6\r\n", "output": "13\r\n"}, {"input": "5 7\r\n8 3 1 6 4\r\n", "output": "6\r\n"}, {"input": "6 -9\r\n-10 -7 4 -7 0 3\r\n", "output": "13\r\n"}, {"input": "9 -3\r\n-10 -7 -3 -4 7 -6 10 -10 -7\r\n", "output": "24\r\n"}, {"input": "18 8\r\n19 18 20 11 16 12 20 17 15 11 16 13 20 13 14 16 10 12\r\n", "output": "12\r\n"}, {"input": "26 3\r\n20 15 19 20 17 10 15 20 16 14 19 12 18 15 14 16 13 13 20 12 12 13 12 18 15 11\r\n", "output": "17\r\n"}, {"input": "40 4\r\n10 13 15 17 13 12 16 20 14 17 11 11 18 12 18 19 19 16 13 13 12 15 14 12 10 15 16 11 13 12 12 15 10 17 13 10 12 19 14 15\r\n", "output": "15\r\n"}, {"input": "44 4\r\n11 15 10 19 14 13 14 11 11 13 13 14 15 17 18 19 11 13 14 17 12 16 19 19 13 20 14 12 13 14 12 13 14 14 10 20 17 16 12 11 14 19 11 12\r\n", "output": "16\r\n"}, {"input": "51 5\r\n20 20 10 17 11 15 12 11 12 19 17 12 16 11 18 11 14 16 11 19 13 13 20 14 18 13 20 18 13 15 12 12 10 11 13 19 12 11 14 17 14 19 18 18 14 13 10 12 16 18 20\r\n", "output": "15\r\n"}, {"input": "65 13\r\n14 10 16 19 12 12 10 14 20 11 12 11 17 12 11 14 20 20 16 12 17 14 11 20 10 11 10 13 10 20 19 14 14 11 10 18 10 18 13 10 20 20 10 13 16 10 12 10 12 17 16 18 10 10 12 16 10 13 15 20 13 12 19 20 16\r\n", "output": "13\r\n"}, {"input": "73 14\r\n11 19 16 17 10 14 15 13 19 15 12 10 17 13 11 17 12 20 17 10 18 18 12 12 16 15 16 19 10 14 19 16 17 18 17 18 16 20 18 16 19 20 20 20 18 19 11 12 11 15 13 16 12 18 11 20 19 10 19 16 14 11 18 14 13 19 16 11 11 10 12 16 18\r\n", "output": "14\r\n"}, {"input": "87 1\r\n16 10 11 15 11 16 16 16 16 14 14 12 14 10 18 10 18 13 18 11 11 19 13 11 19 17 14 20 10 12 16 15 18 16 19 13 10 19 10 15 11 17 13 16 13 15 13 10 12 13 20 10 18 19 11 20 14 14 12 14 17 10 15 11 17 13 16 19 12 10 14 15 20 10 17 14 19 11 20 10 17 15 20 12 10 14 14\r\n", "output": "19\r\n"}, {"input": "91 25\r\n19 15 20 12 18 11 18 12 20 11 16 18 13 11 11 13 13 14 15 16 13 11 13 19 15 13 10 15 10 12 13 11 18 11 14 10 11 11 20 14 11 11 14 10 14 19 13 16 19 12 18 18 14 15 10 14 16 11 11 14 12 14 14 20 16 15 17 17 12 15 12 15 20 16 10 18 15 15 19 18 19 18 12 10 11 15 20 20 15 16 15\r\n", "output": "15\r\n"}, {"input": "11 -28\r\n-20 -18 -12 -11 -13 -14 -13 -17 -14 -10 -10\r\n", "output": "18\r\n"}, {"input": "28 -20\r\n-11 -16 -16 -18 -15 -12 -18 -13 -19 -20 -19 -20 -18 -15 -18 -15 -11 -10 -20 -17 -15 -14 -16 -13 -10 -16 -20 -17\r\n", "output": "10\r\n"}, {"input": "38 -29\r\n-13 -13 -10 -12 -13 -13 -13 -18 -18 -20 -19 -14 -17 -16 -19 -13 -10 -14 -19 -12 -16 -17 -11 -12 -12 -13 -18 -12 -11 -18 -15 -20 -20 -14 -13 -17 -12 -12\r\n", "output": "19\r\n"}, {"input": "45 -21\r\n-19 -13 -10 -16 -15 -18 -18 -18 -13 -19 -19 -15 -17 -17 -16 -16 -11 -19 -20 -12 -17 -12 -16 -18 -10 -17 -12 -18 -15 -20 -10 -16 -20 -17 -11 -18 -20 -10 -19 -11 -16 -18 -15 -16 -18\r\n", "output": "11\r\n"}, {"input": "59 -3\r\n-12 -15 -17 -12 -14 -13 -20 -15 -18 -19 -12 -16 -20 -17 -10 -15 -18 -12 -20 -20 -14 -15 -11 -13 -20 -19 -14 -16 -19 -15 -16 -12 -20 -12 -15 -16 -12 -19 -13 -16 -13 -17 -15 -13 -10 -13 -17 -17 -13 -13 -14 -12 -13 -18 -17 -18 -15 -14 -15\r\n", "output": "17\r\n"}, {"input": "61 -27\r\n-14 -15 -11 -20 -13 -15 -14 -19 -17 -18 -16 -11 -16 -18 -11 -17 -13 -17 -13 -19 -15 -14 -14 -12 -19 -16 -13 -15 -13 -20 -18 -15 -17 -14 -13 -10 -20 -17 -10 -13 -16 -12 -11 -19 -15 -10 -13 -13 -15 -20 -13 -15 -18 -11 -13 -19 -13 -17 -11 -16 -12\r\n", "output": "17\r\n"}, {"input": "76 -20\r\n-20 -12 -19 -13 -14 -19 -19 -19 -12 -17 -12 -16 -19 -19 -19 -16 -10 -18 -16 -19 -16 -10 -16 -11 -18 -13 -11 -10 -13 -11 -13 -10 -18 -20 -13 -15 -13 -19 -15 -18 -20 -10 -11 -20 -10 -11 -16 -17 -13 -12 -11 -14 -13 -16 -19 -13 -10 -11 -17 -19 -10 -10 -14 -13 -12 -15 -10 -10 -20 -20 -15 -14 -19 -18 -11 -17\r\n", "output": "10\r\n"}, {"input": "89 -6\r\n-11 -12 -12 -20 -13 -14 -13 -13 -14 -12 -20 -20 -15 -20 -20 -19 -10 -19 -13 -15 -17 -20 -14 -19 -17 -18 -16 -19 -10 -13 -19 -10 -18 -12 -18 -13 -17 -17 -19 -18 -13 -20 -19 -10 -15 -15 -12 -20 -14 -20 -14 -17 -18 -13 -15 -14 -10 -14 -20 -13 -16 -10 -20 -18 -15 -15 -15 -16 -19 -13 -15 -18 -18 -11 -13 -19 -18 -20 -12 -13 -11 -14 -10 -10 -14 -15 -15 -12 -13\r\n", "output": "14\r\n"}, {"input": "97 -13\r\n-17 -11 -20 -16 -11 -18 -17 -14 -19 -13 -11 -19 -15 -17 -11 -20 -10 -19 -10 -18 -11 -14 -11 -15 -13 -13 -11 -18 -18 -18 -11 -14 -20 -19 -10 -17 -18 -19 -17 -11 -11 -11 -20 -19 -16 -15 -18 -15 -15 -20 -19 -20 -16 -13 -17 -11 -13 -18 -10 -13 -10 -14 -12 -17 -20 -10 -11 -19 -19 -15 -19 -10 -18 -14 -15 -15 -11 -13 -20 -10 -10 -16 -18 -15 -14 -13 -13 -11 -16 -10 -16 -18 -11 -19 -11 -14 -18\r\n", "output": "13\r\n"}, {"input": "1 -42\r\n-100\r\n", "output": "0\r\n"}, {"input": "1 1000000\r\n-1000000\r\n", "output": "0\r\n"}, {"input": "1 -1000000\r\n1000000\r\n", "output": "0\r\n"}, {"input": "1 89765\r\n89782\r\n", "output": "0\r\n"}, {"input": "1 -78621\r\n-77777\r\n", "output": "0\r\n"}, {"input": "5 10\r\n1 1 1 1 1\r\n", "output": "9\r\n"}, {"input": "1 5\r\n0\r\n", "output": "0\r\n"}, {"input": "1 100\r\n300\r\n", "output": "0\r\n"}, {"input": "2 2\r\n2 2\r\n", "output": "0\r\n"}, {"input": "1 10\r\n1\r\n", "output": "0\r\n"}, {"input": "1 10\r\n7\r\n", "output": "0\r\n"}, {"input": "1 100\r\n1\r\n", "output": "0\r\n"}, {"input": "1 5\r\n-1\r\n", "output": "0\r\n"}, {"input": "5 3\r\n-100000 1 1 2 10\r\n", "output": "11\r\n"}, {"input": "3 1000\r\n0 1001 4004\r\n", "output": "1002\r\n"}, {"input": "6 51\r\n0 50 50 50 50 60\r\n", "output": "11\r\n"}, {"input": "6 4\r\n-100 1 2 3 4 5\r\n", "output": "5\r\n"}, {"input": "1 7\r\n7\r\n", "output": "0\r\n"}, {"input": "6 -2\r\n-3 1 2 3 4 6\r\n", "output": "8\r\n"}, {"input": "5 6\r\n-1000000 2 3 4 1000\r\n", "output": "1002\r\n"}]
| false |
stdio
| null | true |
735/B
|
735
|
B
|
Python 3
|
TESTS
| 3 | 108 | 0 |
54065774
|
inp=[int(s) for s in input().split()]
people=[int(s) for s in input().split()]
for i in range(inp[0]-inp[1]-inp[2]):
people.remove(min(people))
sum=0
if inp[1]<inp[2]:
for i in range(inp[1]):
per=max(people)
sum+=per/inp[1]
people.remove(per)
for a in people:
sum+=a/inp[2]
else:
for i in range(inp[2]):
per=max(people)
sum+=per/inp[2]
people.remove(per)
for a in people:
sum+=a/inp[1]
print(sum)
| 37 | 93 | 7,372,800 |
156026671
|
n, n1, n2 = map(int, input().split())
nums = list(map(int, input().split()))
nums.sort(reverse = True)
if n1 > n2:
n1, n2 = n2, n1
mean1 = sum(nums[:n1]) / n1
mean2 = sum(nums[n1: n1+n2]) / n2
print(mean1 + mean2)
|
Codeforces Round 382 (Div. 2)
|
CF
| 2,016 | 2 | 256 |
Urbanization
|
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
|
The first line of the input contains three integers n, n1 and n2 (1 ≤ n, n1, n2 ≤ 100 000, n1 + n2 ≤ n) — the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
|
Print one real value — the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if $$\frac{|a-b|}{\max(1,b)} \leq 10^{-6}$$.
| null |
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
|
[{"input": "2 1 1\n1 5", "output": "6.00000000"}, {"input": "4 2 1\n1 4 2 3", "output": "6.50000000"}]
| 1,100 |
["greedy", "number theory", "sortings"]
| 37 |
[{"input": "2 1 1\r\n1 5\r\n", "output": "6.00000000\r\n"}, {"input": "4 2 1\r\n1 4 2 3\r\n", "output": "6.50000000\r\n"}, {"input": "3 1 2\r\n1 2 3\r\n", "output": "4.50000000\r\n"}, {"input": "10 4 6\r\n3 5 7 9 12 25 67 69 83 96\r\n", "output": "88.91666667\r\n"}, {"input": "19 7 12\r\n1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 100000 100000\r\n", "output": "47052.10714286\r\n"}, {"input": "100 9 6\r\n109 711 40 95 935 48 228 253 308 726 816 534 252 8 966 363 162 508 84 83 807 506 748 178 45 30 106 108 764 698 825 198 336 353 158 790 64 262 403 334 577 571 742 541 946 602 279 621 910 776 421 886 29 133 114 394 762 965 339 263 750 530 49 80 124 31 322 292 27 590 960 278 111 932 849 491 561 744 469 511 106 271 156 160 836 363 149 473 457 543 976 809 490 29 85 626 265 88 995 946\r\n", "output": "1849.66666667\r\n"}, {"input": "69 6 63\r\n53475 22876 79144 6335 33763 79104 65441 45527 65847 94406 74670 43529 75330 19403 67629 56187 57949 23071 64910 54409 55348 18056 855 24961 50565 6622 26467 33989 22660 79469 41246 13965 79706 14422 16075 93378 81313 48173 13470 97348 2346 27452 59427 29925 29847 73823 32021 10988 24609 98855 90919 45939 17203 8439 43007 40138 55693 30314 71734 33458 66850 4011 20089 20546 92090 50842 78859 62756 40177\r\n", "output": "135712.88888889\r\n"}, {"input": "69 6 9\r\n2612 17461 69001 33130 10662 85485 88195 45974 16712 81365 67119 87797 15559 20197 74716 92979 97268 49466 68603 48351 99905 35606 54242 98603 68232 54398 82637 49647 38979 46171 54680 23334 15892 92186 69670 29711 67999 2220 32317 717 70667 68262 86760 55720 97158 61122 7251 138 21022 27197 12691 59331 13576 66999 38332 13574 83484 66646 17704 33065 98583 80259 64631 16745 69431 40747 82089 82788 32739\r\n", "output": "183129.44444444\r\n"}]
| false |
stdio
|
import sys
def main():
input_path, correct_output_path, submission_output_path = sys.argv[1:4]
with open(correct_output_path, 'r') as f:
correct_output = f.read().strip()
with open(submission_output_path, 'r') as f:
submission_output = f.read().strip()
try:
correct = float(correct_output)
submission = float(submission_output)
except:
print(0)
return
absolute_error = abs(submission - correct)
max_denominator = max(1.0, correct)
relative_error = absolute_error / max_denominator
if relative_error <= 1e-6:
print(100)
else:
print(0)
if __name__ == "__main__":
main()
| true |
241/A
|
241
|
A
|
PyPy 3-64
|
TESTS
| 3 | 122 | 0 |
164831945
|
import sys
input = sys.stdin.readline
from math import ceil
n, k = map(int, input().split())
w = list(map(int, input().split()))
s = list(map(int, input().split()))
d = []
c = 0
for i in range(n):
if s[i] > c:
c = s[i]
d.append(i)
d.append(n)
m = len(d)
x = 0
y = 0
t = 0
j = 1
while 1:
x = sum(w[d[j-1]:d[j]])
y += sum(s[d[j-1]:d[j]])
if y < x:
c = ceil((x-y)/s[j-1])
y += c*s[j-1]
t += c*k
t += x
y -= x
j += 1
if j == m:
break
print(t)
| 52 | 124 | 0 |
223956643
|
import math
if __name__ == '__main__':
m_k = input().split()
m = int(m_k[0])
k = int(m_k[1])
d_arr = input().split()
s_arr = input().split()
oil = 0
max_n = 0
count = 0
for distance in d_arr:
count += int(distance)
for i in range(0, m):
curr_s = int(s_arr[i])
oil += int(curr_s)
max_n = max(max_n, curr_s)
curr_d = int(d_arr[i])
if curr_d > oil:
refill = math.ceil((curr_d - oil) /max_n)
oil += max_n * refill
count += k * refill
oil -= curr_d
print(count)
|
Bayan 2012-2013 Elimination Round (ACM ICPC Rules, English statements)
|
ICPC
| 2,012 | 2 | 256 |
Old Peykan
|
There are n cities in the country where the Old Peykan lives. These cities are located on a straight line, we'll denote them from left to right as c1, c2, ..., cn. The Old Peykan wants to travel from city c1 to cn using roads. There are (n - 1) one way roads, the i-th road goes from city ci to city ci + 1 and is di kilometers long.
The Old Peykan travels 1 kilometer in 1 hour and consumes 1 liter of fuel during this time.
Each city ci (except for the last city cn) has a supply of si liters of fuel which immediately transfers to the Old Peykan if it passes the city or stays in it. This supply refreshes instantly k hours after it transfers. The Old Peykan can stay in a city for a while and fill its fuel tank many times.
Initially (at time zero) the Old Peykan is at city c1 and s1 liters of fuel is transferred to it's empty tank from c1's supply. The Old Peykan's fuel tank capacity is unlimited. Old Peykan can not continue its travel if its tank is emptied strictly between two cities.
Find the minimum time the Old Peykan needs to reach city cn.
|
The first line of the input contains two space-separated integers m and k (1 ≤ m, k ≤ 1000). The value m specifies the number of roads between cities which is equal to n - 1.
The next line contains m space-separated integers d1, d2, ..., dm (1 ≤ di ≤ 1000) and the following line contains m space-separated integers s1, s2, ..., sm (1 ≤ si ≤ 1000).
|
In the only line of the output print a single integer — the minimum time required for The Old Peykan to reach city cn from city c1.
| null |
In the second sample above, the Old Peykan stays in c1 for 3 hours.
|
[{"input": "4 6\n1 2 5 2\n2 3 3 4", "output": "10"}, {"input": "2 3\n5 6\n5 5", "output": "14"}]
| 1,300 |
["greedy"]
| 52 |
[{"input": "4 6\r\n1 2 5 2\r\n2 3 3 4\r\n", "output": "10\r\n"}, {"input": "2 3\r\n5 6\r\n5 5\r\n", "output": "14\r\n"}, {"input": "24 3\r\n11 8 8 12 17 4 4 25 39 37 31 32 38 34 29 29 34 39 39 39 17 9 24 6\r\n3 5 4 3 3 3 4 3 4 3 3 3 3 4 3 3 4 3 4 3 3 3 3 3\r\n", "output": "862\r\n"}, {"input": "43 5\r\n6 7 15 12 15 7 22 33 38 15 7 23 31 21 26 41 25 14 26 33 5 28 22 6 35 17 19 32 41 27 20 25 5 32 37 19 40 9 25 22 10 24 9\r\n3 5 3 6 5 4 5 3 3 3 3 6 6 3 3 3 3 3 3 3 3 6 3 3 4 3 4 3 6 4 3 6 3 4 6 3 4 5 4 4 3 3 5\r\n", "output": "1566\r\n"}]
| false |
stdio
| null | true |
735/B
|
735
|
B
|
PyPy 3
|
TESTS
| 3 | 93 | 0 |
114085322
|
import sys
from os import path
if (path.exists('input.txt') and path.exists('output.txt')):
sys.stdout = open('output.txt', 'w')
sys.stdin = open('input.txt', 'r')
def main():
n, n1, n2 = (int(i) for i in input().split())
l = sorted([int(i) for i in input().split()], reverse=True)
if n1 > n2: n1, n2 = n2, n1
ans = sum(l[:n1]) / n1 + sum(l[n1:n2 + 1]) / n2
print(ans)
main()
| 37 | 93 | 7,372,800 |
156028545
|
n, n1, n2 = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort(reverse = True)
if n1 > n2:
n1, n2 = n2, n1
sumOfN1 = sum(arr[:n1])
sumOfN2 = sum(arr[n1:n1 + n2])
print(sumOfN1/n1 + sumOfN2/n2)
|
Codeforces Round 382 (Div. 2)
|
CF
| 2,016 | 2 | 256 |
Urbanization
|
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
|
The first line of the input contains three integers n, n1 and n2 (1 ≤ n, n1, n2 ≤ 100 000, n1 + n2 ≤ n) — the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
|
Print one real value — the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if $$\frac{|a-b|}{\max(1,b)} \leq 10^{-6}$$.
| null |
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
|
[{"input": "2 1 1\n1 5", "output": "6.00000000"}, {"input": "4 2 1\n1 4 2 3", "output": "6.50000000"}]
| 1,100 |
["greedy", "number theory", "sortings"]
| 37 |
[{"input": "2 1 1\r\n1 5\r\n", "output": "6.00000000\r\n"}, {"input": "4 2 1\r\n1 4 2 3\r\n", "output": "6.50000000\r\n"}, {"input": "3 1 2\r\n1 2 3\r\n", "output": "4.50000000\r\n"}, {"input": "10 4 6\r\n3 5 7 9 12 25 67 69 83 96\r\n", "output": "88.91666667\r\n"}, {"input": "19 7 12\r\n1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 100000 100000\r\n", "output": "47052.10714286\r\n"}, {"input": "100 9 6\r\n109 711 40 95 935 48 228 253 308 726 816 534 252 8 966 363 162 508 84 83 807 506 748 178 45 30 106 108 764 698 825 198 336 353 158 790 64 262 403 334 577 571 742 541 946 602 279 621 910 776 421 886 29 133 114 394 762 965 339 263 750 530 49 80 124 31 322 292 27 590 960 278 111 932 849 491 561 744 469 511 106 271 156 160 836 363 149 473 457 543 976 809 490 29 85 626 265 88 995 946\r\n", "output": "1849.66666667\r\n"}, {"input": "69 6 63\r\n53475 22876 79144 6335 33763 79104 65441 45527 65847 94406 74670 43529 75330 19403 67629 56187 57949 23071 64910 54409 55348 18056 855 24961 50565 6622 26467 33989 22660 79469 41246 13965 79706 14422 16075 93378 81313 48173 13470 97348 2346 27452 59427 29925 29847 73823 32021 10988 24609 98855 90919 45939 17203 8439 43007 40138 55693 30314 71734 33458 66850 4011 20089 20546 92090 50842 78859 62756 40177\r\n", "output": "135712.88888889\r\n"}, {"input": "69 6 9\r\n2612 17461 69001 33130 10662 85485 88195 45974 16712 81365 67119 87797 15559 20197 74716 92979 97268 49466 68603 48351 99905 35606 54242 98603 68232 54398 82637 49647 38979 46171 54680 23334 15892 92186 69670 29711 67999 2220 32317 717 70667 68262 86760 55720 97158 61122 7251 138 21022 27197 12691 59331 13576 66999 38332 13574 83484 66646 17704 33065 98583 80259 64631 16745 69431 40747 82089 82788 32739\r\n", "output": "183129.44444444\r\n"}]
| false |
stdio
|
import sys
def main():
input_path, correct_output_path, submission_output_path = sys.argv[1:4]
with open(correct_output_path, 'r') as f:
correct_output = f.read().strip()
with open(submission_output_path, 'r') as f:
submission_output = f.read().strip()
try:
correct = float(correct_output)
submission = float(submission_output)
except:
print(0)
return
absolute_error = abs(submission - correct)
max_denominator = max(1.0, correct)
relative_error = absolute_error / max_denominator
if relative_error <= 1e-6:
print(100)
else:
print(0)
if __name__ == "__main__":
main()
| true |
735/B
|
735
|
B
|
PyPy 3
|
TESTS
| 3 | 78 | 20,172,800 |
124453446
|
n, n1, n2 = map(int, input().split())
wealths = sorted(map(int, input().split()))[::-1]
res = 0
res += sum(wealths[:min(n1, n2)])/min(n1, n2) + sum(wealths[min(n1, n2):max(n1, n2)+1])/max(n1, n2)
print(res)
| 37 | 93 | 7,372,800 |
182431643
|
n, n1, n2 = map(int,input().split())
a = list(sorted(list(map(int,input().split()))))[::-1]
n1, n2 = min(n1,n2), max(n1,n2)
print(sum(a[:n1])/n1+sum(a[n1:n1+n2])/n2)
|
Codeforces Round 382 (Div. 2)
|
CF
| 2,016 | 2 | 256 |
Urbanization
|
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
|
The first line of the input contains three integers n, n1 and n2 (1 ≤ n, n1, n2 ≤ 100 000, n1 + n2 ≤ n) — the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
|
Print one real value — the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if $$\frac{|a-b|}{\max(1,b)} \leq 10^{-6}$$.
| null |
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
|
[{"input": "2 1 1\n1 5", "output": "6.00000000"}, {"input": "4 2 1\n1 4 2 3", "output": "6.50000000"}]
| 1,100 |
["greedy", "number theory", "sortings"]
| 37 |
[{"input": "2 1 1\r\n1 5\r\n", "output": "6.00000000\r\n"}, {"input": "4 2 1\r\n1 4 2 3\r\n", "output": "6.50000000\r\n"}, {"input": "3 1 2\r\n1 2 3\r\n", "output": "4.50000000\r\n"}, {"input": "10 4 6\r\n3 5 7 9 12 25 67 69 83 96\r\n", "output": "88.91666667\r\n"}, {"input": "19 7 12\r\n1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 100000 100000\r\n", "output": "47052.10714286\r\n"}, {"input": "100 9 6\r\n109 711 40 95 935 48 228 253 308 726 816 534 252 8 966 363 162 508 84 83 807 506 748 178 45 30 106 108 764 698 825 198 336 353 158 790 64 262 403 334 577 571 742 541 946 602 279 621 910 776 421 886 29 133 114 394 762 965 339 263 750 530 49 80 124 31 322 292 27 590 960 278 111 932 849 491 561 744 469 511 106 271 156 160 836 363 149 473 457 543 976 809 490 29 85 626 265 88 995 946\r\n", "output": "1849.66666667\r\n"}, {"input": "69 6 63\r\n53475 22876 79144 6335 33763 79104 65441 45527 65847 94406 74670 43529 75330 19403 67629 56187 57949 23071 64910 54409 55348 18056 855 24961 50565 6622 26467 33989 22660 79469 41246 13965 79706 14422 16075 93378 81313 48173 13470 97348 2346 27452 59427 29925 29847 73823 32021 10988 24609 98855 90919 45939 17203 8439 43007 40138 55693 30314 71734 33458 66850 4011 20089 20546 92090 50842 78859 62756 40177\r\n", "output": "135712.88888889\r\n"}, {"input": "69 6 9\r\n2612 17461 69001 33130 10662 85485 88195 45974 16712 81365 67119 87797 15559 20197 74716 92979 97268 49466 68603 48351 99905 35606 54242 98603 68232 54398 82637 49647 38979 46171 54680 23334 15892 92186 69670 29711 67999 2220 32317 717 70667 68262 86760 55720 97158 61122 7251 138 21022 27197 12691 59331 13576 66999 38332 13574 83484 66646 17704 33065 98583 80259 64631 16745 69431 40747 82089 82788 32739\r\n", "output": "183129.44444444\r\n"}]
| false |
stdio
|
import sys
def main():
input_path, correct_output_path, submission_output_path = sys.argv[1:4]
with open(correct_output_path, 'r') as f:
correct_output = f.read().strip()
with open(submission_output_path, 'r') as f:
submission_output = f.read().strip()
try:
correct = float(correct_output)
submission = float(submission_output)
except:
print(0)
return
absolute_error = abs(submission - correct)
max_denominator = max(1.0, correct)
relative_error = absolute_error / max_denominator
if relative_error <= 1e-6:
print(100)
else:
print(0)
if __name__ == "__main__":
main()
| true |
735/B
|
735
|
B
|
Python 3
|
TESTS
| 3 | 77 | 6,963,200 |
129620082
|
# بسم الله الرحمن الرحيم
def main():
n, n1, n2 = [int(i) for i in input().split()]
wealthes = [int(i) for i in input().split()]
sorted_wealthes = sorted(wealthes)
# print(sorted_wealthes)
max_mean1 = 0
max_mean2 = 0
if n1 <= n2:
# start fill n1 with people hav maxis wealthes
sum = 0
for i in range(n-1, n-n1-1, -1):
sum += sorted_wealthes[i]
max_mean1 = sum / n1
sum = 0
for i in range(n-n1-1, n-n2-1-1, -1):
sum += sorted_wealthes[i]
max_mean2 = sum / n2
else:
# start fill n2 with people hav maxis wealthes
sum = 0
for i in range(n-1, n-n2-1, -1): # [4]
sum += sorted_wealthes[i]
max_mean2 = sum / n2
# then continue fill n1 with people hav maxis wealthes after those on n2
sum = 0
for i in range(n-n2-1, n-n1-1-1, -1): # [2, 1]
sum += sorted_wealthes[i]
max_mean1 = sum / n1
print(max_mean1+max_mean2)
if __name__=='__main__':
main()
| 37 | 93 | 7,372,800 |
200317194
|
from heapq import nlargest,heapify
def solve():
n,n1,n2=map(int,input().split());a=sorted(list(map(int,input().split())))
ans=0
t1=sum(a[n-(min(n1,n2))::])/min(n1,n2)
for i in range(min(n1,n2)):a.pop()
t2=sum(a[(n-min(n1,n2))-max(n1,n2)::])/max(n1,n2)
print(t1+t2)
solve()
# 3 2
# 2 3 4 5 6
|
Codeforces Round 382 (Div. 2)
|
CF
| 2,016 | 2 | 256 |
Urbanization
|
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
|
The first line of the input contains three integers n, n1 and n2 (1 ≤ n, n1, n2 ≤ 100 000, n1 + n2 ≤ n) — the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
|
Print one real value — the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if $$\frac{|a-b|}{\max(1,b)} \leq 10^{-6}$$.
| null |
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
|
[{"input": "2 1 1\n1 5", "output": "6.00000000"}, {"input": "4 2 1\n1 4 2 3", "output": "6.50000000"}]
| 1,100 |
["greedy", "number theory", "sortings"]
| 37 |
[{"input": "2 1 1\r\n1 5\r\n", "output": "6.00000000\r\n"}, {"input": "4 2 1\r\n1 4 2 3\r\n", "output": "6.50000000\r\n"}, {"input": "3 1 2\r\n1 2 3\r\n", "output": "4.50000000\r\n"}, {"input": "10 4 6\r\n3 5 7 9 12 25 67 69 83 96\r\n", "output": "88.91666667\r\n"}, {"input": "19 7 12\r\n1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 100000 100000\r\n", "output": "47052.10714286\r\n"}, {"input": "100 9 6\r\n109 711 40 95 935 48 228 253 308 726 816 534 252 8 966 363 162 508 84 83 807 506 748 178 45 30 106 108 764 698 825 198 336 353 158 790 64 262 403 334 577 571 742 541 946 602 279 621 910 776 421 886 29 133 114 394 762 965 339 263 750 530 49 80 124 31 322 292 27 590 960 278 111 932 849 491 561 744 469 511 106 271 156 160 836 363 149 473 457 543 976 809 490 29 85 626 265 88 995 946\r\n", "output": "1849.66666667\r\n"}, {"input": "69 6 63\r\n53475 22876 79144 6335 33763 79104 65441 45527 65847 94406 74670 43529 75330 19403 67629 56187 57949 23071 64910 54409 55348 18056 855 24961 50565 6622 26467 33989 22660 79469 41246 13965 79706 14422 16075 93378 81313 48173 13470 97348 2346 27452 59427 29925 29847 73823 32021 10988 24609 98855 90919 45939 17203 8439 43007 40138 55693 30314 71734 33458 66850 4011 20089 20546 92090 50842 78859 62756 40177\r\n", "output": "135712.88888889\r\n"}, {"input": "69 6 9\r\n2612 17461 69001 33130 10662 85485 88195 45974 16712 81365 67119 87797 15559 20197 74716 92979 97268 49466 68603 48351 99905 35606 54242 98603 68232 54398 82637 49647 38979 46171 54680 23334 15892 92186 69670 29711 67999 2220 32317 717 70667 68262 86760 55720 97158 61122 7251 138 21022 27197 12691 59331 13576 66999 38332 13574 83484 66646 17704 33065 98583 80259 64631 16745 69431 40747 82089 82788 32739\r\n", "output": "183129.44444444\r\n"}]
| false |
stdio
|
import sys
def main():
input_path, correct_output_path, submission_output_path = sys.argv[1:4]
with open(correct_output_path, 'r') as f:
correct_output = f.read().strip()
with open(submission_output_path, 'r') as f:
submission_output = f.read().strip()
try:
correct = float(correct_output)
submission = float(submission_output)
except:
print(0)
return
absolute_error = abs(submission - correct)
max_denominator = max(1.0, correct)
relative_error = absolute_error / max_denominator
if relative_error <= 1e-6:
print(100)
else:
print(0)
if __name__ == "__main__":
main()
| true |
735/B
|
735
|
B
|
PyPy 3
|
TESTS
| 3 | 77 | 0 |
103902618
|
n, n1, n2 = map(int,input().split())
l = list(map(int,input().split()))
l.sort(reverse=True)
ans = 0
if n1>n2:
ans1 = 0
for i in range(n2):
ans1+=l[i]
ans2 = 0
for j in range(n2, n1+1):
ans2+=l[j]
ans = (ans1/n2)+(ans2/n1)
else:
ans1 = 0
for i in range(n1):
ans1+=l[i]
ans2 = 0
for j in range(n1, n2+1):
ans2+=l[j]
ans = (ans1/n1)+(ans2/n2)
print(ans)
| 37 | 93 | 10,649,600 |
183806458
|
from sys import stdin ,stdout
input=stdin.readline
def print(*args, end='\n', sep=' ') -> None:
stdout.write(sep.join(map(str, args)) + end)
n,n1,n2=map(int,input().split()) ; arr=[int(i) for i in input().split()] ; arr.sort() ; na1=n1 ; na2=n2 ; summ1=0 ; summ2=0
if n2>n1:
for i in range(n-1,-1,-1):
if na1!=0:
summ1+=arr[i]
na1-=1
elif na2!=0:
summ2+=arr[i]
na2-=1
else:
break
else:
for i in range(n-1,-1,-1):
if na2!=0:
summ2+=arr[i]
na2-=1
elif na1!=0:
summ1+=arr[i]
na1-=1
else:
break
print(summ1/n1+summ2/n2)
|
Codeforces Round 382 (Div. 2)
|
CF
| 2,016 | 2 | 256 |
Urbanization
|
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
|
The first line of the input contains three integers n, n1 and n2 (1 ≤ n, n1, n2 ≤ 100 000, n1 + n2 ≤ n) — the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
|
Print one real value — the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if $$\frac{|a-b|}{\max(1,b)} \leq 10^{-6}$$.
| null |
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
|
[{"input": "2 1 1\n1 5", "output": "6.00000000"}, {"input": "4 2 1\n1 4 2 3", "output": "6.50000000"}]
| 1,100 |
["greedy", "number theory", "sortings"]
| 37 |
[{"input": "2 1 1\r\n1 5\r\n", "output": "6.00000000\r\n"}, {"input": "4 2 1\r\n1 4 2 3\r\n", "output": "6.50000000\r\n"}, {"input": "3 1 2\r\n1 2 3\r\n", "output": "4.50000000\r\n"}, {"input": "10 4 6\r\n3 5 7 9 12 25 67 69 83 96\r\n", "output": "88.91666667\r\n"}, {"input": "19 7 12\r\n1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 100000 100000\r\n", "output": "47052.10714286\r\n"}, {"input": "100 9 6\r\n109 711 40 95 935 48 228 253 308 726 816 534 252 8 966 363 162 508 84 83 807 506 748 178 45 30 106 108 764 698 825 198 336 353 158 790 64 262 403 334 577 571 742 541 946 602 279 621 910 776 421 886 29 133 114 394 762 965 339 263 750 530 49 80 124 31 322 292 27 590 960 278 111 932 849 491 561 744 469 511 106 271 156 160 836 363 149 473 457 543 976 809 490 29 85 626 265 88 995 946\r\n", "output": "1849.66666667\r\n"}, {"input": "69 6 63\r\n53475 22876 79144 6335 33763 79104 65441 45527 65847 94406 74670 43529 75330 19403 67629 56187 57949 23071 64910 54409 55348 18056 855 24961 50565 6622 26467 33989 22660 79469 41246 13965 79706 14422 16075 93378 81313 48173 13470 97348 2346 27452 59427 29925 29847 73823 32021 10988 24609 98855 90919 45939 17203 8439 43007 40138 55693 30314 71734 33458 66850 4011 20089 20546 92090 50842 78859 62756 40177\r\n", "output": "135712.88888889\r\n"}, {"input": "69 6 9\r\n2612 17461 69001 33130 10662 85485 88195 45974 16712 81365 67119 87797 15559 20197 74716 92979 97268 49466 68603 48351 99905 35606 54242 98603 68232 54398 82637 49647 38979 46171 54680 23334 15892 92186 69670 29711 67999 2220 32317 717 70667 68262 86760 55720 97158 61122 7251 138 21022 27197 12691 59331 13576 66999 38332 13574 83484 66646 17704 33065 98583 80259 64631 16745 69431 40747 82089 82788 32739\r\n", "output": "183129.44444444\r\n"}]
| false |
stdio
|
import sys
def main():
input_path, correct_output_path, submission_output_path = sys.argv[1:4]
with open(correct_output_path, 'r') as f:
correct_output = f.read().strip()
with open(submission_output_path, 'r') as f:
submission_output = f.read().strip()
try:
correct = float(correct_output)
submission = float(submission_output)
except:
print(0)
return
absolute_error = abs(submission - correct)
max_denominator = max(1.0, correct)
relative_error = absolute_error / max_denominator
if relative_error <= 1e-6:
print(100)
else:
print(0)
if __name__ == "__main__":
main()
| true |
735/B
|
735
|
B
|
Python 3
|
TESTS
| 3 | 46 | 4,608,000 |
25331930
|
n,a,b=map(int,input().split())
a,b=map(int,sorted([a,b]))
x=sorted(list(map(int,input().split())))[::-1]
print(sum(x[:a])/a+sum(x[a:b+1])/b)
| 37 | 93 | 13,721,600 |
164991866
|
n,n1,n2=map(int,input().split())
arr=list(map(int,input().split()))
arr.sort()
n1,n2=min(n1,n2),max(n1,n2)
ans=0
res=0
for i in range(n1):
ans+=arr.pop()
ans=ans/n1
for j in range(n2):
res+=arr.pop()
res=res/n2
print(ans+res)
|
Codeforces Round 382 (Div. 2)
|
CF
| 2,016 | 2 | 256 |
Urbanization
|
Local authorities have heard a lot about combinatorial abilities of Ostap Bender so they decided to ask his help in the question of urbanization. There are n people who plan to move to the cities. The wealth of the i of them is equal to ai. Authorities plan to build two cities, first for n1 people and second for n2 people. Of course, each of n candidates can settle in only one of the cities. Thus, first some subset of candidates of size n1 settle in the first city and then some subset of size n2 is chosen among the remaining candidates and the move to the second city. All other candidates receive an official refuse and go back home.
To make the statistic of local region look better in the eyes of their bosses, local authorities decided to pick subsets of candidates in such a way that the sum of arithmetic mean of wealth of people in each of the cities is as large as possible. Arithmetic mean of wealth in one city is the sum of wealth ai among all its residents divided by the number of them (n1 or n2 depending on the city). The division should be done in real numbers without any rounding.
Please, help authorities find the optimal way to pick residents for two cities.
|
The first line of the input contains three integers n, n1 and n2 (1 ≤ n, n1, n2 ≤ 100 000, n1 + n2 ≤ n) — the number of candidates who want to move to the cities, the planned number of residents of the first city and the planned number of residents of the second city.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100 000), the i-th of them is equal to the wealth of the i-th candidate.
|
Print one real value — the maximum possible sum of arithmetic means of wealth of cities' residents. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if $$\frac{|a-b|}{\max(1,b)} \leq 10^{-6}$$.
| null |
In the first sample, one of the optimal solutions is to move candidate 1 to the first city and candidate 2 to the second.
In the second sample, the optimal solution is to pick candidates 3 and 4 for the first city, and candidate 2 for the second one. Thus we obtain (a3 + a4) / 2 + a2 = (3 + 2) / 2 + 4 = 6.5
|
[{"input": "2 1 1\n1 5", "output": "6.00000000"}, {"input": "4 2 1\n1 4 2 3", "output": "6.50000000"}]
| 1,100 |
["greedy", "number theory", "sortings"]
| 37 |
[{"input": "2 1 1\r\n1 5\r\n", "output": "6.00000000\r\n"}, {"input": "4 2 1\r\n1 4 2 3\r\n", "output": "6.50000000\r\n"}, {"input": "3 1 2\r\n1 2 3\r\n", "output": "4.50000000\r\n"}, {"input": "10 4 6\r\n3 5 7 9 12 25 67 69 83 96\r\n", "output": "88.91666667\r\n"}, {"input": "19 7 12\r\n1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 100000 100000\r\n", "output": "47052.10714286\r\n"}, {"input": "100 9 6\r\n109 711 40 95 935 48 228 253 308 726 816 534 252 8 966 363 162 508 84 83 807 506 748 178 45 30 106 108 764 698 825 198 336 353 158 790 64 262 403 334 577 571 742 541 946 602 279 621 910 776 421 886 29 133 114 394 762 965 339 263 750 530 49 80 124 31 322 292 27 590 960 278 111 932 849 491 561 744 469 511 106 271 156 160 836 363 149 473 457 543 976 809 490 29 85 626 265 88 995 946\r\n", "output": "1849.66666667\r\n"}, {"input": "69 6 63\r\n53475 22876 79144 6335 33763 79104 65441 45527 65847 94406 74670 43529 75330 19403 67629 56187 57949 23071 64910 54409 55348 18056 855 24961 50565 6622 26467 33989 22660 79469 41246 13965 79706 14422 16075 93378 81313 48173 13470 97348 2346 27452 59427 29925 29847 73823 32021 10988 24609 98855 90919 45939 17203 8439 43007 40138 55693 30314 71734 33458 66850 4011 20089 20546 92090 50842 78859 62756 40177\r\n", "output": "135712.88888889\r\n"}, {"input": "69 6 9\r\n2612 17461 69001 33130 10662 85485 88195 45974 16712 81365 67119 87797 15559 20197 74716 92979 97268 49466 68603 48351 99905 35606 54242 98603 68232 54398 82637 49647 38979 46171 54680 23334 15892 92186 69670 29711 67999 2220 32317 717 70667 68262 86760 55720 97158 61122 7251 138 21022 27197 12691 59331 13576 66999 38332 13574 83484 66646 17704 33065 98583 80259 64631 16745 69431 40747 82089 82788 32739\r\n", "output": "183129.44444444\r\n"}]
| false |
stdio
|
import sys
def main():
input_path, correct_output_path, submission_output_path = sys.argv[1:4]
with open(correct_output_path, 'r') as f:
correct_output = f.read().strip()
with open(submission_output_path, 'r') as f:
submission_output = f.read().strip()
try:
correct = float(correct_output)
submission = float(submission_output)
except:
print(0)
return
absolute_error = abs(submission - correct)
max_denominator = max(1.0, correct)
relative_error = absolute_error / max_denominator
if relative_error <= 1e-6:
print(100)
else:
print(0)
if __name__ == "__main__":
main()
| true |
741/C
|
741
|
C
|
Python 3
|
TESTS
| 1 | 30 | 0 |
132194250
|
t=int(input())
la={}
for times in range(t):
a,b=map(int,input().split())
la[a]=b
la[b]=a
lb = [1] * (t*2)
for i in range(1,t+1):
lb[la[i]-1] = 2
num_1 = 0
num_2 = 0
last = -1
for i in range(t*2-2):
if lb[i] == lb[i+1] and lb[i+1] == lb[i+2]:
lb[i+1],lb[la[lb[i+1]]]=lb[la[lb[i+1]]],lb[i+1]
for i in range(1,t+1):
print(lb[i-1],lb[la[lb[i-1]]])
| 94 | 452 | 33,280,000 |
22770741
|
import sys
def solve():
n = int(input())
partner = [0]*(2*n)
pacani = []
for line in sys.stdin:
pacan, telka = [int(x) - 1 for x in line.split()]
partner[pacan] = telka
partner[telka] = pacan
pacani.append(pacan)
khavka = [None]*(2*n)
for i in range(2*n):
while khavka[i] is None:
khavka[i] = 1
khavka[i^1] = 2
i = partner[i^1]
for pacan in pacani:
print(khavka[pacan], khavka[partner[pacan]])
solve()
|
Codeforces Round 383 (Div. 1)
|
CF
| 2,016 | 1 | 256 |
Arpa’s overnight party and Mehrdad’s silent entering
|
Note that girls in Arpa’s land are really attractive.
Arpa loves overnight parties. In the middle of one of these parties Mehrdad suddenly appeared. He saw n pairs of friends sitting around a table. i-th pair consisted of a boy, sitting on the ai-th chair, and his girlfriend, sitting on the bi-th chair. The chairs were numbered 1 through 2n in clockwise direction. There was exactly one person sitting on each chair.
There were two types of food: Kooft and Zahre-mar. Now Mehrdad wonders, was there any way to serve food for the guests such that:
- Each person had exactly one type of food,
- No boy had the same type of food as his girlfriend,
- Among any three guests sitting on consecutive chairs, there was two of them who had different type of food. Note that chairs 2n and 1 are considered consecutive.
Find the answer for the Mehrdad question. If it was possible, find some arrangement of food types that satisfies the conditions.
|
The first line contains an integer n (1 ≤ n ≤ 105) — the number of pairs of guests.
The i-th of the next n lines contains a pair of integers ai and bi (1 ≤ ai, bi ≤ 2n) — the number of chair on which the boy in the i-th pair was sitting and the number of chair on which his girlfriend was sitting. It's guaranteed that there was exactly one person sitting on each chair.
|
If there is no solution, print -1.
Otherwise print n lines, the i-th of them should contain two integers which represent the type of food for the i-th pair. The first integer in the line is the type of food the boy had, and the second integer is the type of food the girl had. If someone had Kooft, print 1, otherwise print 2.
If there are multiple solutions, print any of them.
| null | null |
[{"input": "3\n1 4\n2 5\n3 6", "output": "1 2\n2 1\n1 2"}]
| 2,600 |
["constructive algorithms", "dfs and similar", "graphs"]
| 94 |
[{"input": "3\r\n1 4\r\n2 5\r\n3 6\r\n", "output": "1 2\r\n2 1\r\n1 2\r\n"}, {"input": "6\r\n3 2\r\n5 11\r\n7 12\r\n6 9\r\n8 4\r\n1 10\r\n", "output": "1 2\r\n1 2\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n"}, {"input": "19\r\n30 27\r\n6 38\r\n10 28\r\n20 5\r\n14 18\r\n32 2\r\n36 29\r\n12 1\r\n31 24\r\n15 4\r\n35 11\r\n3 7\r\n21 17\r\n25 19\r\n16 8\r\n23 22\r\n37 33\r\n13 9\r\n34 26\r\n", "output": "1 2\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n1 2\r\n2 1\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n"}, {"input": "4\r\n4 2\r\n6 8\r\n5 1\r\n3 7\r\n", "output": "1 2\r\n1 2\r\n2 1\r\n2 1\r\n"}, {"input": "17\r\n11 12\r\n17 22\r\n34 7\r\n3 1\r\n5 24\r\n18 20\r\n27 30\r\n16 33\r\n23 21\r\n19 4\r\n2 15\r\n29 28\r\n9 8\r\n13 25\r\n6 10\r\n32 26\r\n31 14\r\n", "output": "1 2\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n"}, {"input": "19\r\n10 7\r\n9 17\r\n21 30\r\n36 8\r\n14 11\r\n25 24\r\n1 23\r\n38 33\r\n4 20\r\n3 37\r\n27 5\r\n28 19\r\n22 2\r\n6 34\r\n12 15\r\n31 32\r\n35 13\r\n16 29\r\n18 26\r\n", "output": "1 2\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n"}, {"input": "17\r\n17 31\r\n11 23\r\n34 22\r\n24 8\r\n4 1\r\n7 14\r\n20 27\r\n3 19\r\n12 26\r\n32 25\r\n28 18\r\n16 29\r\n21 9\r\n6 2\r\n33 30\r\n5 13\r\n10 15\r\n", "output": "1 2\r\n1 2\r\n2 1\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n"}, {"input": "6\r\n2 7\r\n5 9\r\n12 8\r\n1 4\r\n3 6\r\n10 11\r\n", "output": "2 1\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n"}, {"input": "8\r\n10 3\r\n2 16\r\n14 13\r\n5 15\r\n1 7\r\n11 8\r\n6 4\r\n12 9\r\n", "output": "1 2\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n1 2\r\n"}, {"input": "4\r\n2 8\r\n3 5\r\n4 7\r\n1 6\r\n", "output": "2 1\r\n2 1\r\n1 2\r\n1 2\r\n"}, {"input": "2\r\n2 3\r\n1 4\r\n", "output": "2 1\r\n1 2\r\n"}, {"input": "15\r\n16 22\r\n4 17\r\n27 3\r\n23 24\r\n18 20\r\n15 21\r\n9 7\r\n2 28\r\n29 19\r\n8 30\r\n14 10\r\n6 26\r\n25 11\r\n12 1\r\n13 5\r\n", "output": "2 1\r\n2 1\r\n2 1\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n"}, {"input": "10\r\n19 6\r\n8 2\r\n15 18\r\n17 14\r\n16 7\r\n20 10\r\n5 1\r\n13 3\r\n9 12\r\n11 4\r\n", "output": "2 1\r\n1 2\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n"}, {"input": "9\r\n12 7\r\n10 15\r\n16 14\r\n2 4\r\n1 17\r\n6 9\r\n8 3\r\n13 5\r\n11 18\r\n", "output": "1 2\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n2 1\r\n1 2\r\n2 1\r\n2 1\r\n"}, {"input": "7\r\n3 14\r\n7 4\r\n13 10\r\n11 8\r\n6 1\r\n5 9\r\n2 12\r\n", "output": "2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n2 1\r\n"}, {"input": "6\r\n2 11\r\n7 1\r\n12 8\r\n4 10\r\n3 9\r\n5 6\r\n", "output": "2 1\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n"}, {"input": "8\r\n13 6\r\n10 5\r\n1 12\r\n11 15\r\n7 16\r\n4 14\r\n9 2\r\n8 3\r\n", "output": "1 2\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n"}, {"input": "8\r\n16 5\r\n10 15\r\n8 11\r\n2 14\r\n6 4\r\n7 3\r\n1 13\r\n9 12\r\n", "output": "1 2\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n2 1\r\n1 2\r\n2 1\r\n"}, {"input": "7\r\n10 14\r\n4 6\r\n1 11\r\n7 2\r\n9 8\r\n5 13\r\n3 12\r\n", "output": "2 1\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n"}, {"input": "5\r\n2 5\r\n10 9\r\n1 6\r\n3 8\r\n4 7\r\n", "output": "2 1\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n"}, {"input": "8\r\n14 2\r\n7 9\r\n15 6\r\n13 11\r\n12 16\r\n10 5\r\n8 1\r\n3 4\r\n", "output": "1 2\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n2 1\r\n1 2\r\n"}, {"input": "5\r\n4 6\r\n5 1\r\n2 3\r\n7 8\r\n9 10\r\n", "output": "2 1\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n"}, {"input": "23\r\n46 21\r\n17 3\r\n27 38\r\n34 43\r\n7 6\r\n8 37\r\n22 4\r\n16 42\r\n36 32\r\n12 9\r\n10 45\r\n26 2\r\n13 24\r\n23 29\r\n18 15\r\n33 30\r\n31 5\r\n11 25\r\n1 14\r\n44 39\r\n19 20\r\n35 28\r\n41 40\r\n", "output": "2 1\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n"}, {"input": "26\r\n8 10\r\n52 21\r\n2 33\r\n18 34\r\n30 51\r\n5 19\r\n22 32\r\n36 28\r\n42 16\r\n13 49\r\n11 17\r\n31 39\r\n43 37\r\n50 15\r\n29 20\r\n35 46\r\n47 23\r\n3 1\r\n44 7\r\n9 27\r\n6 48\r\n40 24\r\n26 14\r\n45 4\r\n12 25\r\n41 38\r\n", "output": "2 1\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n"}, {"input": "20\r\n34 12\r\n9 6\r\n5 3\r\n13 26\r\n18 15\r\n16 22\r\n7 14\r\n17 37\r\n38 40\r\n4 2\r\n11 23\r\n21 8\r\n10 36\r\n30 33\r\n28 19\r\n29 31\r\n39 20\r\n35 24\r\n25 32\r\n1 27\r\n", "output": "1 2\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n"}, {"input": "17\r\n3 14\r\n34 22\r\n24 9\r\n16 17\r\n6 30\r\n33 12\r\n5 10\r\n21 8\r\n32 2\r\n26 23\r\n31 27\r\n19 15\r\n29 4\r\n7 18\r\n25 13\r\n20 28\r\n1 11\r\n", "output": "1 2\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n"}, {"input": "24\r\n30 4\r\n41 1\r\n2 11\r\n22 42\r\n29 43\r\n7 14\r\n16 6\r\n40 5\r\n27 34\r\n46 33\r\n17 10\r\n21 39\r\n28 31\r\n19 32\r\n23 20\r\n25 48\r\n12 9\r\n47 37\r\n38 3\r\n44 8\r\n36 18\r\n13 26\r\n24 15\r\n45 35\r\n", "output": "1 2\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n2 1\r\n2 1\r\n1 2\r\n"}, {"input": "15\r\n21 14\r\n25 5\r\n7 28\r\n2 6\r\n8 27\r\n29 18\r\n9 15\r\n4 26\r\n12 1\r\n19 16\r\n17 20\r\n24 10\r\n11 23\r\n13 22\r\n30 3\r\n", "output": "1 2\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n2 1\r\n2 1\r\n2 1\r\n1 2\r\n1 2\r\n1 2\r\n1 2\r\n"}]
| false |
stdio
|
import sys
def main(input_path, output_path, submission_path):
# Read input
with open(input_path) as f:
n = int(f.readline())
pairs = [tuple(map(int, f.readline().split())) for _ in range(n)]
# Read reference output
with open(output_path) as f:
ref_lines = [line.strip() for line in f.readlines()]
# Read submission output
with open(submission_path) as f:
sub_lines = [line.strip() for line in f.readlines()]
# Check if reference is -1
if ref_lines and ref_lines[0].strip() == '-1':
if len(sub_lines) != 1 or sub_lines[0].strip() != '-1':
print(0)
return
else:
print(1)
return
else:
if len(sub_lines) == 1 and sub_lines[0].strip() == '-1':
print(0)
return
if len(sub_lines) != n:
print(0)
return
chair_food = {}
for i in range(n):
line = sub_lines[i]
parts = line.split()
if len(parts) != 2:
print(0)
return
try:
a, b = map(int, parts)
except:
print(0)
return
if a not in (1, 2) or b not in (1, 2) or a == b:
print(0)
return
ai, bi = pairs[i]
chair_food[ai] = a
chair_food[bi] = b
all_chairs = set()
for a, b in pairs:
all_chairs.add(a)
all_chairs.add(b)
for chair in all_chairs:
if chair not in chair_food:
print(0)
return
for i in range(1, 2 * n + 1):
next_i = i + 1 if i < 2 * n else 1
nextnext_i = next_i + 1 if next_i < 2 * n else 1
a = chair_food.get(i, 0)
b = chair_food.get(next_i, 0)
c = chair_food.get(nextnext_i, 0)
if a == b == c:
print(0)
return
print(1)
if __name__ == "__main__":
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
main(input_path, output_path, submission_path)
| true |
463/D
|
463
|
D
|
PyPy 3
|
TESTS
| 1 | 155 | 1,740,800 |
118349369
|
from collections import deque
tt=0
def dfs(i,cnt):
global tt
vis=[0]*n
q=deque()
q.append((i,cnt))
while q:
xx=q.popleft()
vis[xx[0]]=1
tt=max(tt,xx[1])
for i in adj[xx[0]]:
if not vis[i]:
q.append((i,xx[1]+1))
n,k=map(int,input().split())
matx=[]
p=[[] for i in range(n)]
adj=[[] for i in range(n) ]
for i in range(k):
matx.append([int(x)-1 for x in input().split() ])
for j in range(len(matx[-1])):
p[matx[-1][j]].append(j)
for i in range(n):
for j in range(i+1,n):
c=0
for q in range(k):
if p[i][q]>p[j][q]:
c+=1
if c==0:
adj[i].append(j)
elif c==k:
adj[j].append(i)
for i in range(n):
dfs(i,0)
print(tt+1)
| 40 | 171 | 3,379,200 |
116205354
|
from sys import stdin, stdout, setrecursionlimit
input = stdin.readline
# import string
# characters = string.ascii_lowercase
# digits = string.digits
# setrecursionlimit(int(1e6))
# dir = [-1,0,1,0,-1]
# moves = 'NESW'
inf = float('inf')
from functools import cmp_to_key
from collections import defaultdict as dd
from collections import Counter, deque
from heapq import *
import math
from math import floor, ceil, sqrt
def geti(): return map(int, input().strip().split())
def getl(): return list(map(int, input().strip().split()))
def getis(): return map(str, input().strip().split())
def getls(): return list(map(str, input().strip().split()))
def gets(): return input().strip()
def geta(): return int(input())
def print_s(s): stdout.write(s+'\n')
def solve():
n, k = geti()
mat = []
pos = [[-1]*(n+1) for _ in range(k)]
for i in range(k):
mat.append(getl())
for j in range(n):
pos[i][mat[-1][j]] = j
dp = [1]*n
for i in range(n):
for j in range(i):
for now in range(k):
if pos[now][mat[0][i]] <= pos[now][mat[0][j]]:
break
else:
dp[i] = max(dp[i], dp[j] + 1)
# print(i, dp)
ans = max(dp)
print(ans)
if __name__=='__main__':
solve()
|
Codeforces Round 264 (Div. 2)
|
CF
| 2,014 | 2 | 256 |
Gargari and Permutations
|
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
|
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
|
Print the length of the longest common subsequence.
| null |
The answer for the first test sample is subsequence [1, 2, 3].
|
[{"input": "4 3\n1 4 2 3\n4 1 2 3\n1 2 4 3", "output": "3"}]
| 1,900 |
["dfs and similar", "dp", "graphs", "implementation"]
| 40 |
[{"input": "4 3\r\n1 4 2 3\r\n4 1 2 3\r\n1 2 4 3\r\n", "output": "3\r\n"}, {"input": "6 3\r\n2 5 1 4 6 3\r\n5 1 4 3 2 6\r\n5 4 2 6 3 1\r\n", "output": "3\r\n"}, {"input": "41 4\r\n24 15 17 35 13 41 4 14 23 5 8 16 21 18 30 36 6 22 11 29 26 1 40 31 7 3 32 10 28 38 12 20 39 37 34 19 33 27 2 25 9\r\n22 13 25 24 38 35 29 12 15 8 11 37 3 19 4 23 18 32 30 40 36 21 16 34 27 9 5 41 39 2 14 17 31 33 26 7 1 10 20 6 28\r\n31 27 39 16 22 12 13 32 6 10 19 29 37 7 18 33 24 21 1 9 36 4 34 41 25 28 17 40 30 35 23 14 11 8 2 15 38 20 26 5 3\r\n8 18 39 38 7 34 16 31 15 1 40 20 37 4 25 11 17 19 33 26 6 14 13 41 12 32 2 21 10 35 27 9 28 5 30 24 22 23 29 3 36\r\n", "output": "4\r\n"}, {"input": "1 2\r\n1\r\n1\r\n", "output": "1\r\n"}, {"input": "28 5\r\n3 14 12 16 13 27 20 8 1 10 24 11 5 9 7 18 17 23 22 25 28 19 4 21 26 6 15 2\r\n7 12 23 27 22 26 16 18 19 5 6 9 11 28 25 4 10 3 1 14 8 17 15 2 20 13 24 21\r\n21 20 2 5 19 15 12 4 18 9 23 16 11 14 8 6 25 27 13 17 10 26 7 24 28 1 3 22\r\n12 2 23 11 20 18 25 21 13 27 14 8 4 6 9 16 7 3 10 1 22 15 26 19 5 17 28 24\r\n13 2 6 19 22 23 4 1 28 10 18 17 21 8 9 3 26 11 12 27 14 20 24 25 15 5 16 7\r\n", "output": "3\r\n"}, {"input": "6 3\r\n2 5 1 4 6 3\r\n5 1 4 6 2 3\r\n5 4 2 6 3 1\r\n", "output": "4\r\n"}, {"input": "41 4\r\n24 15 17 35 13 41 4 14 23 5 8 16 21 18 30 36 6 22 11 29 26 1 40 31 7 3 32 10 28 38 12 20 39 37 34 19 33 27 2 25 9\r\n22 13 25 24 38 35 29 12 15 8 11 37 3 19 4 23 18 32 30 40 36 21 16 34 27 9 5 41 39 2 14 17 31 33 26 7 1 10 20 6 28\r\n31 27 39 16 22 12 13 32 6 10 19 29 37 7 18 33 24 21 1 9 36 4 34 41 25 28 17 40 30 35 23 14 11 8 2 15 38 20 26 5 3\r\n8 18 39 38 7 34 16 31 15 1 40 20 37 4 25 11 17 19 33 26 6 14 13 41 12 32 2 21 10 35 27 9 28 5 30 24 22 23 29 3 36\r\n", "output": "4\r\n"}, {"input": "37 3\r\n6 3 19 20 15 4 1 35 8 24 12 21 34 26 18 14 23 33 28 9 36 11 37 31 25 32 29 22 13 27 16 17 10 7 5 30 2\r\n10 3 35 17 34 21 14 8 26 28 11 19 27 7 4 23 24 22 12 13 16 1 25 29 5 31 30 20 32 18 15 9 2 36 37 33 6\r\n19 9 22 32 26 35 29 23 5 6 14 34 33 10 2 28 15 11 24 4 13 7 8 31 37 36 1 27 3 16 30 25 20 21 18 17 12\r\n", "output": "7\r\n"}]
| false |
stdio
| null | true |
274/B
|
274
|
B
|
Python 3
|
TESTS
| 1 | 62 | 102,400 |
163713558
|
from sys import setrecursionlimit
from sys import stdin
input=stdin.readline
#setrecursionlimit(10**6)
from collections import defaultdict
n=int(input())
g=defaultdict(list)
for _ in range(n-1):
u,v=map(int,input().split())
u-=1;v-=1
g[u].append(v)
g[v].append(u)
q=[(0,-1)]
for x in range(n):
cn,p=q[x]
for nn in g[cn]:
if nn!=p:
q.append((nn,cn))
val=[int(i) for i in input().split()]
res=[-1 for i in range(n)]
for cn,p in q[::-1]:
np=0
nn=0
for nn in g[cn]:
if nn!=p:
op,on=res[nn]
np=max(np,op)
nn=max(nn,on)
nn=max(nn,np+val[cn])
np=max(np,nn-val[cn])
res[cn]=(np,nn)
n,p=res[0]
print(n+p)
| 27 | 934 | 66,150,400 |
174618887
|
import sys
from types import GeneratorType
input = sys.stdin.readline
n = int(input())
g = [[] for _ in range(n + 1)]
for _ in range(n - 1):
a, b = map(int, input().split())
g[a].append(b)
g[b].append(a)
v = [-1] + list(map(int, input().split()))
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
@bootstrap
def dfs(node, fa):
minus, plus = 0, 0
for ch in g[node]:
if ch == fa:
continue
a, b = yield dfs(ch, node)
minus = max(minus, a)
plus = max(plus, b)
v[node] += plus - minus
if v[node] > 0:
minus += v[node]
elif v[node] < 0:
plus += -v[node]
yield minus, plus
print(sum(dfs(1, 0)))
|
Codeforces Round 168 (Div. 1)
|
CF
| 2,013 | 2 | 256 |
Zero Tree
|
A tree is a graph with n vertices and exactly n - 1 edges; this graph should meet the following condition: there exists exactly one shortest (by number of edges) path between any pair of its vertices.
A subtree of a tree T is a tree with both vertices and edges as subsets of vertices and edges of T.
You're given a tree with n vertices. Consider its vertices numbered with integers from 1 to n. Additionally an integer is written on every vertex of this tree. Initially the integer written on the i-th vertex is equal to vi. In one move you can apply the following operation:
1. Select the subtree of the given tree that includes the vertex with number 1.
2. Increase (or decrease) by one all the integers which are written on the vertices of that subtree.
Calculate the minimum number of moves that is required to make all the integers written on the vertices of the given tree equal to zero.
|
The first line of the input contains n (1 ≤ n ≤ 105). Each of the next n - 1 lines contains two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi) indicating there's an edge between vertices ai and bi. It's guaranteed that the input graph is a tree.
The last line of the input contains a list of n space-separated integers v1, v2, ..., vn (|vi| ≤ 109).
|
Print the minimum number of operations needed to solve the task.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
| null | null |
[{"input": "3\n1 2\n1 3\n1 -1 1", "output": "3"}]
| 1,800 |
["dfs and similar", "dp", "greedy", "trees"]
| 27 |
[{"input": "3\r\n1 2\r\n1 3\r\n1 -1 1\r\n", "output": "3\r\n"}, {"input": "5\r\n2 3\r\n4 5\r\n2 5\r\n1 3\r\n0 2 1 4 3\r\n", "output": "8\r\n"}, {"input": "10\r\n5 6\r\n8 2\r\n9 3\r\n4 1\r\n6 10\r\n9 8\r\n7 10\r\n7 4\r\n5 2\r\n0 -6 -9 -1 -5 -4 -2 -7 -8 -3\r\n", "output": "18\r\n"}, {"input": "5\r\n3 1\r\n2 4\r\n3 4\r\n2 5\r\n0 -3 -1 2 4\r\n", "output": "20\r\n"}, {"input": "12\r\n1 6\r\n10 1\r\n4 1\r\n7 1\r\n1 2\r\n5 1\r\n1 8\r\n1 11\r\n3 1\r\n12 1\r\n9 1\r\n580660007 861441526 -264928594 488291045 253254575 -974301934 709266786 926718320 87511873 514836444 -702876508 848928657\r\n", "output": "2529263875\r\n"}]
| false |
stdio
| null | true |
831/B
|
831
|
B
|
PyPy 3-64
|
TESTS
| 1 | 62 | 0 |
225828230
|
a = str(input())
b = str(input())
c = str(input())
massiv = []
massiv2 = []
massiv3 = []
massiv4 = []
massiv2+=c
counter=0
for i in range(len(massiv2)):
if massiv2[i].istitle():
massiv4.append(massiv2.index(massiv2[i]))
c = c.lower()
massiv2 = []
massiv2+=c
for i in range(len(a)):
massiv.append([a[i], i+1])
massiv3.append([b[i], i+1])
while len(massiv2) != len(massiv):
massiv2.append(999)
for i in range(0, len(massiv)):
for j in range(0, len(massiv)):
if massiv2[i] == massiv[j][0]:
massiv2[i] = massiv[j][1]
for i in range(0, len(massiv)):
for j in range(0, len(massiv)):
if massiv2[i] == massiv[j][0]:
massiv2[i] = massiv[j][1]
for i in range(0, len(massiv3)):
for j in range(0, len(massiv3)):
if massiv2[i] == massiv3[j][1]:
massiv2[i] = massiv3[j][0]
for i in range(len(massiv2)):
if massiv2[i] != 999:
counter+=1
massiv2 = massiv2[0:counter]
for i in range(len(massiv2)-1):
if len(massiv4) != 0:
if massiv2.index(massiv2[i]) == massiv4[0]:
massiv2[i] = massiv2[i].capitalize()
massiv4.pop(0)
else:
break
print(*massiv2, sep='')
| 19 | 31 | 0 |
145715138
|
#!/usr/bin/env/python
# -*- coding: utf-8 -*-
s1 = input()
s2 = input()
dc = {s1[i]: s2[i] for i in range(26)}
res = ''
for c in input():
if '0' <= c <= '9':
res += c
elif 'a' <= c <= 'z':
res += dc[c]
else:
res += dc[c.lower()].upper()
print(res)
|
Codeforces Round 424 (Div. 2, rated, based on VK Cup Finals)
|
CF
| 2,017 | 1 | 256 |
Keyboard Layouts
|
There are two popular keyboard layouts in Berland, they differ only in letters positions. All the other keys are the same. In Berland they use alphabet with 26 letters which coincides with English alphabet.
You are given two strings consisting of 26 distinct letters each: all keys of the first and the second layouts in the same order.
You are also given some text consisting of small and capital English letters and digits. It is known that it was typed in the first layout, but the writer intended to type it in the second layout. Print the text if the same keys were pressed in the second layout.
Since all keys but letters are the same in both layouts, the capitalization of the letters should remain the same, as well as all other characters.
|
The first line contains a string of length 26 consisting of distinct lowercase English letters. This is the first layout.
The second line contains a string of length 26 consisting of distinct lowercase English letters. This is the second layout.
The third line contains a non-empty string s consisting of lowercase and uppercase English letters and digits. This is the text typed in the first layout. The length of s does not exceed 1000.
|
Print the text if the same keys were pressed in the second layout.
| null | null |
[{"input": "qwertyuiopasdfghjklzxcvbnm\nveamhjsgqocnrbfxdtwkylupzi\nTwccpQZAvb2017", "output": "HelloVKCup2017"}, {"input": "mnbvcxzlkjhgfdsapoiuytrewq\nasdfghjklqwertyuiopzxcvbnm\n7abaCABAABAcaba7", "output": "7uduGUDUUDUgudu7"}]
| 800 |
["implementation", "strings"]
| 19 |
[{"input": "qwertyuiopasdfghjklzxcvbnm\r\nveamhjsgqocnrbfxdtwkylupzi\r\nTwccpQZAvb2017\r\n", "output": "HelloVKCup2017\r\n"}, {"input": "mnbvcxzlkjhgfdsapoiuytrewq\r\nasdfghjklqwertyuiopzxcvbnm\r\n7abaCABAABAcaba7\r\n", "output": "7uduGUDUUDUgudu7\r\n"}, {"input": "ayvguplhjsoiencbkxdrfwmqtz\r\nkhzvtbspcndierqumlojyagfwx\r\n3\r\n", "output": "3\r\n"}, {"input": "oaihbljgekzsxucwnqyrvfdtmp\r\nwznqcfvrthjibokeglmudpayxs\r\ntZ8WI33UZZytE8A99EvJjck228LxUQtL5A8q7O217KrmdhpmdhN7JEdVXc8CRm07TFidlIou9AKW9cCl1c4289rfU87oXoSCwHpZO7ggC2GmmDl0KGuA2IimDco2iKaBKl46H089r2tw16mhzI44d2X6g3cnoD0OU5GvA8l89nhNpzTbY9FtZ2wE3Y2a5EC7zXryudTZhXFr9EEcX8P71fp6694aa02B4T0w1pDaVml8FM3N2qB78DBrS723Vpku105sbTJEdBpZu77b1C47DujdoR7rjm5k2nsaPBqX93EfhW95Mm0sBnFtgo12gS87jegSR5u88tM5l420dkt1l1b18UjatzU7P2i9KNJA528caiEpE3JtRw4m4TJ7M1zchxO53skt3Fqvxk2C51gD8XEY7YJC2xmTUqyEUFmPX581Gow2HWq4jaP8FK87\r\n", "output": "yJ8EN33OJJmyT8Z99TdVvkh228FbOLyF5Z8l7W217HuxaqsxaqG7VTaDBk8KUx07YPnafNwo9ZHE9kKf1k4289upO87wBwIKeQsJW7rrK2RxxAf0HRoZ2NnxAkw2nHzCHf46Q089u2ye16xqjN44a2B6r3kgwA0WO5RdZ8f89gqGsjYcM9PyJ2eT3M2z5TK7jBumoaYJqBPu9TTkB8S71ps6694zz02C4Y0e1sAzDxf8PX3G2lC78ACuI723Dsho105icYVTaCsJo77c1K47AovawU7uvx5h2gizSClB93TpqE95Xx0iCgPyrw12rI87vtrIU5o88yX5f420ahy1f1c18OvzyjO7S2n9HGVZ528kznTsT3VyUe4x4YV7X1jkqbW53ihy3Pldbh2K51rA8BTM7MVK2bxYOlmTOPxSB581Rwe2QEl4vzS8PH87\r\n"}, {"input": "aymrnptzhklcbuxfdvjsgqweio\r\nwzsavqryltmjnfgcedxpiokbuh\r\nB5\r\n", "output": "N5\r\n"}, {"input": "unbclszprgiqjodxeawkymvfth\r\ncxfwbdvuqlotkgparmhsyinjze\r\nk081O\r\n", "output": "s081G\r\n"}, {"input": "evfsnczuiodgbhqmlypkjatxrw\r\nhvsockwjxtgreqmyanlzidpbuf\r\n306QMPpaqZ\r\n", "output": "306MYLldmW\r\n"}, {"input": "pbfjtvryklwmuhxnqsoceiadgz\r\ntaipfdvlzemhjsnkwyocqgrxbu\r\nTm9H66Ux59PuGe3lEG94q18u11Dda6w59q1hAAIvHR1qquKI2Xf5ZFdKAPhcEnqKT6BF6Oh16P48YvrIKWGDlRcx9BZwwEF64o0As\r\n", "output": "Fh9S66Jn59TjBq3eQB94w18j11Xxr6m59w1sRRGdSV1wwjZG2Ni5UIxZRTscQkwZF6AI6Os16T48LdvGZMBXeVcn9AUmmQI64o0Ry\r\n"}, {"input": "rtqgahmkeoldsiynjbuwpvcxfz\r\noxqiuwflvebnapyrmcghtkdjzs\r\nJqNskelr3FNjbDhfKPfPXxlqOw72p9BVBwf0tN8Ucs48Vlfjxqo9V3ruU5205UgTYi3JKFbW91NLQ1683315VJ4RSLFW7s26s6uZKs5cO2wAT4JS8rCytZVlPWXdNXaCTq06F1v1Fj2zq7DeJbBSfM5Eko6vBndR75d46mf5Pq7Ark9NARTtQ176ukljBdaqXRsYxrBYl7hda1V7sy38hfbjz59HYM9U55P9eh1CX7tUE44NFlQu7zSjSBHyS3Tte2XaXD3O470Q8U20p8W5rViIh8lsn2TvmcdFdxrF3Ye26J2ZK0BR3KShN597WSJmHJTl4ZZ88IMhzHi6vFyr7MuGYNFGebTB573e6Crwj8P18h344yd8sR2NPge36Y3QC8Y2uW577CO2w4fz\r\n", "output": "MqRalvbo3ZRmcNwzLTzTJjbqEh72t9CKChz0xR8Gda48Kbzmjqe9K3ogG5205GiXYp3MLZcH91RBQ1683315KM4OABZH7a26a6gSLa5dE2hUX4MA8oDyxSKbTHJnRJuDXq06Z1k1Zm2sq7NvMcCAzF5Vle6kCrnO75n46fz5Tq7Uol9RUOXxQ176glbmCnuqJOaYjoCYb7wnu1K7ay38wzcms59WYF9G55T9vw1DJ7xGV44RZbQg7sAmACWyA3Xxv2JuJN3E470Q8G20t8H5oKpPw8bar2XkfdnZnjoZ3Yv26M2SL0CO3LAwR597HAMfWMXb4SS88PFwsWp6kZyo7FgIYRZIvcXC573v6Dohm8T18w344yn8aO2RTiv36Y3QD8Y2gH577DE2h4zs\r\n"}, {"input": "buneohqdgxjsafrmwtzickvlpy\r\nzblwamjxifyuqtnrgdkchpoves\r\n4RZf8YivG6414X1GdDfcCbc10GA0Wz8514LI9D647XzPb66UNh7lX1rDQv0hQvJ7aqhyh1Z39yABGKn24g185Y85ER5q9UqPFaQ2JeK97wHZ78CMSuU8Zf091mePl2OX61BLe5KdmUWodt4BXPiseOZkZ4SZ27qtBM4hT499mCirjy6nB0ZqjQie4Wr3uhW2mGqBlHyEZbW7A6QnsNX9d3j5aHQN0H6GF8J0365KWuAmcroutnJD6l6HI3kSSq17Sdo2htt9y967y8sc98ZAHbutH1m9MOVT1E9Mb5UIK3qNatk9A0m2i1fQl9A65204Q4z4O4rQf374YEq0s2sfmQNW9K7E1zSbj51sGINJVr5736Gw8aW6u9Cjr0sjffXctLopJ0YQ47xD1yEP6bB3odG7slgiM8hJ9BuwfGUwN8tbAgJU8wMI2L0P446MO\r\n", "output": "4NKt8ScoI6414F1IxXthHzh10IQ0Gk8514VC9X647FkEz66BLm7vF1nXJo0mJoY7qjmsm1K39sQZIPl24i185S85WN5j9BjETqJ2YwP97gMK78HRUbB8Kt091rwEv2AF61ZVw5PxrBGaxd4ZFEcuwAKpK4UK27jdZR4mD499rHcnys6lZ0KjyJcw4Gn3bmG2rIjZvMsWKzG7Q6JluLF9x3y5qMJL0M6IT8Y0365PGbQrhnabdlYX6v6MC3pUUj17Uxa2mdd9s967s8uh98KQMzbdM1r9RAOD1W9Rz5BCP3jLqdp9Q0r2c1tJv9Q65204J4k4A4nJt374SWj0u2utrJLG9P7W1kUzy51uICLYOn5736Ig8qG6b9Hyn0uyttFhdVaeY0SJ47fX1sWE6zZ3axI7uvicR8mY9ZbgtIBgL8dzQiYB8gRC2V0E446RA\r\n"}, {"input": "qwertyuiopasdfghjklzxcvbnm\r\nqwertyuiopasdfghjklzxcvbnm\r\nqwertyuiopasdfghjklzxcvbnmPOIUYTREWQLKJHGFDSAMNBVCXZ12345678900987654321ASDFGHJKLqwertyuiopZXCVBNM\r\n", "output": "qwertyuiopasdfghjklzxcvbnmPOIUYTREWQLKJHGFDSAMNBVCXZ12345678900987654321ASDFGHJKLqwertyuiopZXCVBNM\r\n"}, {"input": "qwertyuiopasdfghjklzxcvbnm\r\nmnbvcxzlkjhgfdsapoiuytrewq\r\nasdfghjklzxcvbnmqwertyuiopASDFGHJKLQWERTYUIOPZXCVBNM12345678900987654321QWSDFGVBNxcvghjkoWQEDFGHNJMzxcfghjkl\r\n", "output": "hgfdsapoiuytrewqmnbvcxzlkjHGFDSAPOIMNBVCXZLKJUYTREWQ12345678900987654321MNGFDSREWytrsapokNMBFDSAWPQuytdsapoi\r\n"}]
| false |
stdio
| null | true |
832/D
|
832
|
D
|
PyPy 3-64
|
TESTS
| 3 | 124 | 15,769,600 |
139310892
|
from sys import stdin, stdout
from itertools import permutations
def dfs(v, p):
global timer
timer += 1
IN[v] = timer
up[0][v] = p
for i in range(1, LG):
up[i][v] = up[i - 1][up[i - 1][v]]
for q in G[v]:
if q[0] != p:
dep[q[0]] = dep[v] + q[1]
dfs(q[0], v)
out[v] = timer
def upper(u, v):
return IN[u] <= IN[v] and out[v] <= out[u]
def lca(u, v):
if IN[u] > IN[v]:
u, v = v, u
if upper(u, v):
return u
for i in range(LG-1, -1, -1):
if not upper(up[i][u], v):
u = up[i][u]
return up[0][u]
def calc(f, s, t):
ans = 0
fs = lca(f, s)
ft = lca(f, t)
st = lca(s, t)
is1 = fs == f
is2 = ft == f
if is1 != is2:
return 1
if is1:
ans = max(ans, dep[st] - dep[f])
elif fs != ft:
ans = max(ans, dep[f] - max(dep[fs], dep[ft]))
else:
ans = max(ans, dep[f] + dep[st] - 2 * dep[ft])
return ans + 1
n, q = stdin.readline().split()
n = int(n)
q = int(q)
stations = list(map(int, input().split()))
w = 1
LG = 18
N = 10**5
G = [] # [[] for i in range(n)]
IN = [] # [0 for i in range(n)]
out = [] # [0 for i in range(n)]
dep = [] # [0 for i in range(n)]
for i in range(n + 1):
G.append([])
IN.append(0)
out.append(0)
dep.append(0)
timer = 0
up = [[0 for i in range(N)] for j in range(LG)]
for i in range(2, n+1):
G[i].append([stations[i - 2], w])
G[stations[i - 2]].append([i, w])
dfs(1, 0)
#print(f'G: {G}')
#print(f'IN: {IN}')
#print(f'out: {out}')
#print(f'dep: {dep}')
for i in range(q):
a, b, c = stdin.readline().split()
a = int(a)
b = int(b)
c = int(c)
stdout.write(str(max(calc(a, b, c), calc(b, a, c), calc(c, b, a))) + '\n')
| 94 | 1,325 | 40,550,400 |
110042385
|
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def pre(n,path,lim):
# lim = n.bit_length()
up = [[-1]*(lim+1) for _ in range(n)]
st,visi,height = [0],[1]+[0]*(n-1),[0]*n
start,finish,time = [0]*n,[0]*n,0
while len(st):
x = st[-1]
y,j = up[x][0],0
while y != -1:
up[x][j] = y
y = up[y][j]
j += 1
while len(path[x]) and visi[path[x][-1]]:
path[x].pop()
if not len(path[x]):
time += 1
finish[x] = time
st.pop()
else:
i = path[x].pop()
st.append(i)
time += 1
visi[i],start[i],up[i][0],height[i] = 1,time,x,height[x]+1
return start,finish,up,height
def is_ancestor(u,v,start,finish):
return start[u] <= start[v] and finish[u] >= finish[v]
def lca(u,v,up,start,finish,lim):
if is_ancestor(u,v,start,finish):
return u
if is_ancestor(v,u,start,finish):
return v
for i in range(lim,-1,-1):
if up[u][i] != -1 and not is_ancestor(up[u][i],v,start,finish):
u = up[u][i]
return up[u][0]
def solve(s,f,t,up,start,finish,lim,height):
a = lca(s,f,up,start,finish,lim)
b = lca(t,f,up,start,finish,lim)
ans = height[f]-max(height[a],height[b])+1
if a == b:
x = lca(s,t,up,start,finish,lim)
ans += height[x]-height[a]
return ans
def main():
n,q = map(int,input().split())
path = [[] for _ in range(n)]
for ind,i in enumerate(map(int,input().split())):
path[ind+1].append(i-1)
path[i-1].append(ind+1)
lim = n.bit_length()
start,finish,up,height = pre(n,path,lim)
for _ in range(q):
a,b,c = map(lambda xx:int(xx)-1,input().split())
print(max(solve(a,b,c,up,start,finish,lim,height),
solve(a,c,b,up,start,finish,lim,height),
solve(b,a,c,up,start,finish,lim,height)))
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
|
Codeforces Round 425 (Div. 2)
|
CF
| 2,017 | 2 | 256 |
Misha, Grisha and Underground
|
Misha and Grisha are funny boys, so they like to use new underground. The underground has n stations connected with n - 1 routes so that each route connects two stations, and it is possible to reach every station from any other.
The boys decided to have fun and came up with a plan. Namely, in some day in the morning Misha will ride the underground from station s to station f by the shortest path, and will draw with aerosol an ugly text "Misha was here" on every station he will pass through (including s and f). After that on the same day at evening Grisha will ride from station t to station f by the shortest path and will count stations with Misha's text. After that at night the underground workers will wash the texts out, because the underground should be clean.
The boys have already chosen three stations a, b and c for each of several following days, one of them should be station s on that day, another should be station f, and the remaining should be station t. They became interested how they should choose these stations s, f, t so that the number Grisha will count is as large as possible. They asked you for help.
|
The first line contains two integers n and q (2 ≤ n ≤ 105, 1 ≤ q ≤ 105) — the number of stations and the number of days.
The second line contains n - 1 integers p2, p3, ..., pn (1 ≤ pi ≤ n). The integer pi means that there is a route between stations pi and i. It is guaranteed that it's possible to reach every station from any other.
The next q lines contains three integers a, b and c each (1 ≤ a, b, c ≤ n) — the ids of stations chosen by boys for some day. Note that some of these ids could be same.
|
Print q lines. In the i-th of these lines print the maximum possible number Grisha can get counting when the stations s, t and f are chosen optimally from the three stations on the i-th day.
| null |
In the first example on the first day if s = 1, f = 2, t = 3, Misha would go on the route 1 $$\rightarrow$$ 2, and Grisha would go on the route 3 $$\rightarrow$$ 1 $$\rightarrow$$ 2. He would see the text at the stations 1 and 2. On the second day, if s = 3, f = 2, t = 3, both boys would go on the route 3 $$\rightarrow$$ 1 $$\rightarrow$$ 2. Grisha would see the text at 3 stations.
In the second examle if s = 1, f = 3, t = 2, Misha would go on the route 1 $$\rightarrow$$ 2 $$\rightarrow$$ 3, and Grisha would go on the route 2 $$\rightarrow$$ 3 and would see the text at both stations.
|
[{"input": "3 2\n1 1\n1 2 3\n2 3 3", "output": "2\n3"}, {"input": "4 1\n1 2 3\n1 2 3", "output": "2"}]
| 1,900 |
["dfs and similar", "graphs", "trees"]
| 94 |
[{"input": "3 2\r\n1 1\r\n1 2 3\r\n2 3 3\r\n", "output": "2\r\n3\r\n"}, {"input": "4 1\r\n1 2 3\r\n1 2 3\r\n", "output": "2\r\n"}, {"input": "2 4\r\n1\r\n1 1 1\r\n1 1 2\r\n1 2 2\r\n2 2 2\r\n", "output": "1\r\n2\r\n2\r\n1\r\n"}, {"input": "5 20\r\n4 1 1 4\r\n2 2 5\r\n3 2 5\r\n2 3 4\r\n4 2 5\r\n4 1 2\r\n5 3 1\r\n2 1 2\r\n4 3 2\r\n1 3 3\r\n4 2 5\r\n5 1 4\r\n4 5 4\r\n1 2 4\r\n3 3 1\r\n5 4 5\r\n1 1 1\r\n1 4 4\r\n5 3 2\r\n4 2 1\r\n3 1 4\r\n", "output": "3\r\n3\r\n3\r\n2\r\n2\r\n3\r\n3\r\n3\r\n2\r\n2\r\n2\r\n2\r\n2\r\n2\r\n2\r\n1\r\n2\r\n3\r\n2\r\n2\r\n"}, {"input": "5 20\r\n5 5 1 4\r\n1 4 3\r\n2 4 1\r\n1 5 5\r\n5 1 4\r\n5 1 5\r\n1 5 5\r\n5 4 4\r\n2 3 3\r\n4 4 1\r\n1 4 1\r\n4 5 4\r\n1 4 5\r\n4 1 5\r\n2 4 2\r\n4 3 3\r\n2 5 5\r\n1 5 4\r\n3 3 4\r\n5 5 1\r\n3 4 1\r\n", "output": "3\r\n3\r\n3\r\n2\r\n3\r\n3\r\n2\r\n3\r\n2\r\n2\r\n2\r\n2\r\n2\r\n3\r\n3\r\n2\r\n2\r\n3\r\n3\r\n3\r\n"}]
| false |
stdio
| null | true |
613/B
|
613
|
B
|
Python 3
|
TESTS
| 1 | 46 | 5,529,600 |
33278578
|
f = lambda: map(int, input().split())
g = lambda: m - l * p[l - 1] + s[l]
n, b, x, y, m = f()
t = list(f())
p = sorted(t)
s = [0] * (n + 1)
for j in range(n): s[j + 1] = p[j] + s[j]
l = r = n
a = v = 0
d = [-1]
while r >= 0 and m >= 0 and a < b:
if r:
while g() < 0: l -= 1
u = p[l - 1]
a = min(u + g() // l, b)
else: a, u = b, -1
f = x * (n - r) + y * a
if d[0] < f: d = (f, u, v, a)
r -= 1
v = p[r]
m += v - b
p[r] = b
f, u, v, a = d
print(f)
for q in t: print(a if q <= u else q if q < v else b)
| 35 | 920 | 20,684,800 |
197615001
|
f = lambda: map(int, input().split())
g = lambda: m - l * p[l - 1] + s[l]
n, A, x, y, m = f()
t = sorted((q, i) for i, q in enumerate(f()))
p = [q for q, i in t]
s = [0] * (n + 1)
for j in range(n): s[j + 1] = p[j] + s[j]
l = r = n
F = L = R = B = -1
while 1:
if p:
while l > r or g() < 0: l -= 1
b = min(p[l - 1] + g() // l, A)
else: b, l = A, 0
f = x * (n - r) + y * b
if F < f: F, L, R, B = f, l, r, b
if not p: break
m += p.pop() - A
r -= 1
if m < 0: break
print(F)
p = [(i, B if j < L else q if j < R else A) for j, (q, i) in enumerate(t)]
for i, q in sorted(p): print(q)
|
Codeforces Round 339 (Div. 1)
|
CF
| 2,016 | 2 | 256 |
Skills
|
Lesha plays the recently published new version of the legendary game hacknet. In this version character skill mechanism was introduced. Now, each player character has exactly n skills. Each skill is represented by a non-negative integer ai — the current skill level. All skills have the same maximum level A.
Along with the skills, global ranking of all players was added. Players are ranked according to the so-called Force. The Force of a player is the sum of the following values:
- The number of skills that a character has perfected (i.e., such that ai = A), multiplied by coefficient cf.
- The minimum skill level among all skills (min ai), multiplied by coefficient cm.
Now Lesha has m hacknetian currency units, which he is willing to spend. Each currency unit can increase the current level of any skill by 1 (if it's not equal to A yet). Help him spend his money in order to achieve the maximum possible value of the Force.
|
The first line of the input contains five space-separated integers n, A, cf, cm and m (1 ≤ n ≤ 100 000, 1 ≤ A ≤ 109, 0 ≤ cf, cm ≤ 1000, 0 ≤ m ≤ 1015).
The second line contains exactly n integers ai (0 ≤ ai ≤ A), separated by spaces, — the current levels of skills.
|
On the first line print the maximum value of the Force that the character can achieve using no more than m currency units.
On the second line print n integers a'i (ai ≤ a'i ≤ A), skill levels which one must achieve in order to reach the specified value of the Force, while using no more than m currency units. Numbers should be separated by spaces.
| null |
In the first test the optimal strategy is to increase the second skill to its maximum, and increase the two others by 1.
In the second test one should increase all skills to maximum.
|
[{"input": "3 5 10 1 5\n1 3 1", "output": "12\n2 5 2"}, {"input": "3 5 10 1 339\n1 3 1", "output": "35\n5 5 5"}]
| 1,900 |
["binary search", "brute force", "dp", "greedy", "sortings", "two pointers"]
| 35 |
[{"input": "3 5 10 1 5\r\n1 3 1\r\n", "output": "12\r\n2 5 2 \r\n"}, {"input": "3 5 10 1 339\r\n1 3 1\r\n", "output": "35\r\n5 5 5 \r\n"}, {"input": "2 6 0 1 4\r\n5 1\r\n", "output": "5\r\n5 5 \r\n"}, {"input": "1 1000000000 1000 1000 1000000000000000\r\n0\r\n", "output": "1000000001000\r\n1000000000 \r\n"}, {"input": "1 100 1 2 30\r\n1\r\n", "output": "62\r\n31 \r\n"}, {"input": "1 100 1 2 30\r\n71\r\n", "output": "201\r\n100 \r\n"}, {"input": "1 1000000000 1000 1000 1000000000000000\r\n1000000000\r\n", "output": "1000000001000\r\n1000000000 \r\n"}, {"input": "5 5 10 20 50\r\n0 0 0 0 0\r\n", "output": "150\r\n5 5 5 5 5 \r\n"}, {"input": "5 5 10 20 50\r\n3 3 3 3 3\r\n", "output": "150\r\n5 5 5 5 5 \r\n"}, {"input": "4 5 3 7 15\r\n4 3 3 1\r\n", "output": "47\r\n5 5 5 5 \r\n"}, {"input": "3 6 4 6 8\r\n6 4 5\r\n", "output": "48\r\n6 6 6 \r\n"}]
| false |
stdio
| null | true |
786/A
|
786
|
A
|
Python 3
|
TESTS
| 1 | 109 | 0 |
41253346
|
RESULT = ['Lose', 'Loop', 'Win']
class Player(object):
"""docstring for Player"""
def __init__(self):
super(Player, self).__init__()
self.a = list(map(int, input().split()))
self.f = [len(self.a)] * n
self.f[0] = 0
def prev(self, i):
for x in self.a:
yield (i - x) % n
def print_result(self):
print(*[RESULT[min(x, 1)] for x in self.f[1:]])
n = int(input())
a, b = Player(), Player()
q = [(a, b, 0), (b, a, 0)]
while q:
x, y, i = q.pop()
for j in y.prev(i):
if y.f[j] == - 1:
continue
y.f[j] = -1
for k in x.prev(j):
if x.f[k] == -1:
continue
x.f[k] -= 1
if x.f[k] == 0:
q.append((x, y, k))
a.print_result()
b.print_result()
| 49 | 733 | 4,300,800 |
53973991
|
import sys
#range = xrange
#input = raw_input
n = int(input())
k1,*A = [int(x) for x in input().split()]
k2,*B = [int(x) for x in input().split()]
DPA = [None]*n
DPA[0] = False
counterA = [k1]*n
counterA[0] = -1
DPB = [None]*n
DPB[0] = False
counterB = [k2]*n
counterB[0] = -1
QA = [0]
QB = [0]
while QA or QB:
while QA:
i = QA.pop()
if DPA[i] == False:
for b in B:
if i!=b:
if not DPB[i-b]:
QB.append((i-b)%n)
DPB[i-b] = True
elif DPA[i]:
for b in B:
counterB[i-b] -= 1
if not counterB[i-b]:
#assert(DPB[i-b]==None)
DPB[i-b] = False
QB.append((i-b)%n)
while QB:
i = QB.pop()
if DPB[i] == False:
for a in A:
if i!=a:
if not DPA[i-a]:
QA.append((i-a)%n)
DPA[i-a] = True
elif DPB[i]:
for a in A:
counterA[i-a] -= 1
if not counterA[i-a]:
#assert(DPA[i-a]==None)
DPA[i-a] = False
QA.append((i-a)%n)
def f(x):
if x==None:
return 'Loop'
if x:
return 'Win'
return 'Lose'
print(*[f(x) for x in DPA[1:]])
print(*[f(x) for x in DPB[1:]])
|
Codeforces Round 406 (Div. 1)
|
CF
| 2,017 | 4 | 256 |
Berzerk
|
Rick and Morty are playing their own version of Berzerk (which has nothing in common with the famous Berzerk game). This game needs a huge space, so they play it with a computer.
In this game there are n objects numbered from 1 to n arranged in a circle (in clockwise order). Object number 1 is a black hole and the others are planets. There's a monster in one of the planet. Rick and Morty don't know on which one yet, only that he's not initially in the black hole, but Unity will inform them before the game starts. But for now, they want to be prepared for every possible scenario.
Each one of them has a set of numbers between 1 and n - 1 (inclusive). Rick's set is s1 with k1 elements and Morty's is s2 with k2 elements. One of them goes first and the player changes alternatively. In each player's turn, he should choose an arbitrary number like x from his set and the monster will move to his x-th next object from its current position (clockwise). If after his move the monster gets to the black hole he wins.
Your task is that for each of monster's initial positions and who plays first determine if the starter wins, loses, or the game will stuck in an infinite loop. In case when player can lose or make game infinity, it more profitable to choose infinity game.
|
The first line of input contains a single integer n (2 ≤ n ≤ 7000) — number of objects in game.
The second line contains integer k1 followed by k1 distinct integers s1, 1, s1, 2, ..., s1, k1 — Rick's set.
The third line contains integer k2 followed by k2 distinct integers s2, 1, s2, 2, ..., s2, k2 — Morty's set
1 ≤ ki ≤ n - 1 and 1 ≤ si, 1, si, 2, ..., si, ki ≤ n - 1 for 1 ≤ i ≤ 2.
|
In the first line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Rick plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Similarly, in the second line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Morty plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
| null | null |
[{"input": "5\n2 3 2\n3 1 2 3", "output": "Lose Win Win Loop\nLoop Win Win Win"}, {"input": "8\n4 6 2 3 4\n2 3 6", "output": "Win Win Win Win Win Win Win\nLose Win Lose Lose Win Lose Lose"}]
| 2,000 |
["dfs and similar", "dp", "games"]
| 49 |
[{"input": "5\r\n2 3 2\r\n3 1 2 3\r\n", "output": "Lose Win Win Loop\r\nLoop Win Win Win\r\n"}, {"input": "8\r\n4 6 2 3 4\r\n2 3 6\r\n", "output": "Win Win Win Win Win Win Win\r\nLose Win Lose Lose Win Lose Lose\r\n"}, {"input": "10\r\n3 4 7 5\r\n2 8 5\r\n", "output": "Win Win Win Win Win Win Win Loop Win\r\nLose Win Loop Lose Win Lose Lose Lose Lose\r\n"}, {"input": "17\r\n1 10\r\n1 12\r\n", "output": "Win Win Win Win Win Win Win Win Win Win Win Lose Win Win Win Win\r\nLose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose\r\n"}, {"input": "23\r\n1 20\r\n3 9 2 12\r\n", "output": "Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose\r\nWin Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win\r\n"}, {"input": "85\r\n12 76 7 75 51 43 41 66 13 59 48 81 73\r\n3 65 60 25\r\n", "output": "Loop Loop Loop Win Loop Loop Loop Loop Win Win Loop Win Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Win Loop Loop Loop Loop Win Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}, {"input": "100\r\n84 80 73 28 76 21 44 97 63 59 6 77 41 2 8 71 57 19 33 46 92 5 61 88 53 68 94 56 14 35 4 47 17 79 84 10 67 58 45 38 13 12 87 3 91 30 15 11 24 55 62 39 83 43 89 1 81 75 50 86 72 18 52 78 7 29 64 42 70 49 37 25 66 74 95 36 85 48 99 60 51 98 27 40 93\r\n47 52 76 9 4 25 8 63 29 74 97 61 93 35 49 62 5 10 57 73 42 3 19 23 71 70 43 67 48 2 34 31 41 90 18 6 40 83 98 72 14 51 38 46 21 99 65 37\r\n", "output": "Win Win Win Loop Win Win Win Win Win Loop Win Win Win Win Win Win Win Loop Win Win Win Win Win Win Win Win Win Win Win Win Loop Win Win Win Loop Win Win Win Win Win Win Win Win Win Win Loop Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Loop Win Loop Loop Win Win Win Win Loop Win Win Loop Loop Win Loop Win Win Win Loop Win Win Win Win Win Win Loop Win Win Win Win Win Win Win Win \nWin Win Win Loop Loop Loop Win Loop Loop Win Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Win Loop Win Win Win Win Win Loop Loop Win Loop Win Loop Win Win Win Loop Loop Loop Win Loop Loop Loop Loop Win Win Loop Win Win Loop Win Loop Loop Win Win Win Win Loop Win Win Loop Win Win Loop Loop Win Loop Win Loop Loop Loop Win Loop Win Loop Win Loop Win Win Loop Loop Loop Win Loop Loop Loop Win Win Win Loop Win Win Win Win Win Loop \n"}, {"input": "100\r\n66 70 54 10 72 81 84 56 15 27 19 43 55 49 44 52 33 63 40 95 17 58 2 51 39 22 18 82 1 16 99 32 29 24 94 9 98 5 37 47 14 42 73 41 31 79 64 12 6 53 26 68 67 89 13 90 4 21 93 46 74 75 88 66 57 23 7\r\n18 8 47 76 39 34 52 62 5 36 19 22 80 32 71 55 7 37 57\r\n", "output": "Win Win Loop Loop Win Win Win Loop Loop Win Win Win Loop Loop Loop Win Loop Win Win Loop Win Loop Loop Loop Win Win Win Win Loop Win Loop Win Win Win Loop Win Win Loop Loop Loop Loop Win Win Win Win Win Win Win Win Loop Win Loop Win Win Loop Win Win Win Win Win Win Loop Win Loop Loop Loop Win Win Win Loop Win Loop Win Win Loop Win Win Win Win Loop Win Win Win Win Win Win Win Win Loop Win Win Loop Win Win Win Win Loop Win Win \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Win Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Win Loop Win Loop Loop Win Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Win Loop Win Win Loop Win Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Win Loop Win Loop Loop Loop Loop \n"}, {"input": "300\r\n1 179\r\n2 293 180\r\n", "output": "Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose \nWin Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win \n"}, {"input": "1000\r\n14 77 649 670 988 469 453 445 885 101 58 728 474 488 230\r\n8 83 453 371 86 834 277 847 958\r\n", "output": "Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}, {"input": "2\r\n1 1\r\n1 1\r\n", "output": "Win\r\nWin\r\n"}, {"input": "2\r\n1 1\r\n1 1\r\n", "output": "Win\r\nWin\r\n"}, {"input": "3\r\n1 1\r\n1 2\r\n", "output": "Loop Win\r\nWin Loop\r\n"}, {"input": "20\r\n1 1\r\n1 11\r\n", "output": "Loop Loop Win Lose Loop Loop Win Lose Loop Loop Win Lose Loop Loop Win Lose Loop Loop Win\r\nWin Loop Loop Lose Win Loop Loop Lose Win Loop Loop Lose Win Loop Loop Lose Win Loop Loop\r\n"}, {"input": "309\r\n30 197 38 142 159 163 169 263 70 151 288 264 41 285 225 216 306 128 242 221 94 39 43 292 54 157 78 272 257 97 57\r\n3 97 172 165\r\n", "output": "Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Win Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Win Win Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Win Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Win Loop Loop Loop Win Loop Win Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Win Loop Win Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}, {"input": "1000\r\n1 312\r\n1 171\r\n", "output": "Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose \nWin Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win Lose Win Win Win Win Win Win \n"}, {"input": "1000\r\n1 481\r\n2 468 9\r\n", "output": "Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose \nWin Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win \n"}, {"input": "1000\r\n3 469 637 369\r\n2 801 339\r\n", "output": "Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}, {"input": "4096\r\n6 3736 3640 553 2608 1219 1640\r\n4 112 2233 3551 2248\r\n", "output": "Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}, {"input": "6341\r\n9 6045 2567 3242 5083 5429 1002 4547 1838 4829\r\n5 5533 3084 6323 4015 2889\r\n", "output": "Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}, {"input": "7000\r\n1 5244\r\n1 2980\r\n", "output": "Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop \nLoop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop Lose Loop Loop Loop Win Loop Loop Loop \n"}, {"input": "7000\r\n1 6694\r\n1 2973\r\n", "output": "Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop Lose Loop Loop Loop Loop Win Loop \nLoop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop Lose Loop Win Loop Loop Loop Loop \n"}, {"input": "7000\r\n1 3041\r\n1 6128\r\n", "output": "Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win \nLose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Lose Win Win Win Win Win Win Win Win Win Win Win Win Win Win Win \n"}, {"input": "7000\r\n5 5080 4890 1201 4903 1360\r\n5 2415 6678 5200 2282 4648\r\n", "output": "Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}, {"input": "7000\r\n3 6965 1271 5818\r\n3 6331 5681 6636\r\n", "output": "Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}, {"input": "7000\r\n3 2706 2040 6698\r\n10 4118 846 1075 1624 2342 766 6441 2361 4662 1574\r\n", "output": "Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}, {"input": "7000\r\n12 3489 6630 4582 292 5489 1456 5101 6920 632 2963 5136 5886\r\n11 434 5878 3806 656 3047 6614 1073 5932 6537 704 5253\r\n", "output": "Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}, {"input": "7000\r\n7 419 1631 1925 3861 6940 379 493\r\n29 5389 5925 2923 4696 972 6125 3779 6044 5477 1305 6488 5059 5515 3238 3863 248 6947 4023 6168 1915 6607 2991 2220 2023 200 4457 6398 1017 447\r\n", "output": "Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}, {"input": "6999\r\n2 3992 782\r\n2 4903 6815\r\n", "output": "Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \nLoop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Win Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop Loop \n"}]
| false |
stdio
| null | true |
46/D
|
46
|
D
|
Python 3
|
TESTS
| 0 | 60 | 0 |
215862732
|
L, b, f = map(int, input().split())
n = int(input())
requests = []
cars = []
empty_slots = []
for i in range(n):
type, value = map(int, input().split())
if type == 1:
cars.append([0, value, 0])
requests.append([type, value])
path = -b
current_car = 0
for request in requests:
if request[0] == 1:
is_on_empty = False
for slot in empty_slots:
if request[1] == slot[1]:
print(slot[0])
empty_slots.remove(slot)
is_on_empty = True
break
if request[1] < slot[1]:
slot[2] -= request[1] - slot[1]
slot[1] -= request[1]
is_on_empty = True
break
if is_on_empty:
continue
path += b
if path + request[1] > L:
print(-1)
print(path)
cars[current_car][0] = path
path += cars[current_car][1]
cars[current_car][0] = path
current_car += 1
if request[0] == 2:
empty_slots.append([*cars[request[1] - 1]])
| 30 | 124 | 0 |
13790581
|
class Car:
def __init__(self, id, size, location):
self.id = id
self.size = size
self.location = location
print(location)
cars = []
lot_size, back_gap, front_gap = map(int, input().split())
q = int(input())
for id in range(1, q + 1):
request, value = map(int, input().split())
if request == 1:
size = value
# Only car in the lot.
if len(cars) == 0:
if size <= lot_size:
cars.append(Car(id, size, 0))
else:
print(-1)
continue
# Park before first car.
if size + front_gap <= cars[0].location:
cars.insert(0, Car(id, size, 0))
continue
# Park between two cars.
found = False
for pos in range(1, len(cars)):
a, b = cars[pos - 1], cars[pos]
x = a.location + a.size + back_gap
if x + size + front_gap <= b.location:
cars.insert(pos, Car(id, size, x))
found = True
break
if found:
continue
# Park after last car.
a = cars[len(cars) - 1]
x = a.location + a.size + back_gap
if x + size <= lot_size:
cars.append(Car(id, size, x))
continue
# Fail.
print(-1)
else:
id = value
for pos, car in enumerate(cars):
if car.id == id:
del cars[pos]
break
|
School Personal Contest #2 (Winter Computer School 2010/11) - Codeforces Beta Round 43 (ACM-ICPC Rules)
|
ICPC
| 2,010 | 2 | 256 |
Parking Lot
|
Nowadays it is becoming increasingly difficult to park a car in cities successfully. Let's imagine a segment of a street as long as L meters along which a parking lot is located. Drivers should park their cars strictly parallel to the pavement on the right side of the street (remember that in the country the authors of the tasks come from the driving is right side!). Every driver when parking wants to leave for themselves some extra space to move their car freely, that's why a driver is looking for a place where the distance between his car and the one behind his will be no less than b meters and the distance between his car and the one in front of his will be no less than f meters (if there's no car behind then the car can be parked at the parking lot segment edge; the same is true for the case when there're no cars parked in front of the car). Let's introduce an axis of coordinates along the pavement. Let the parking lot begin at point 0 and end at point L. The drivers drive in the direction of the coordinates' increasing and look for the earliest place (with the smallest possible coordinate) where they can park the car. In case there's no such place, the driver drives on searching for his perfect peaceful haven. Sometimes some cars leave the street and free some space for parking. Considering that there never are two moving cars on a street at a time write a program that can use the data on the drivers, entering the street hoping to park there and the drivers leaving it, to model the process and determine a parking lot space for each car.
|
The first line contains three integers L, b и f (10 ≤ L ≤ 100000, 1 ≤ b, f ≤ 100). The second line contains an integer n (1 ≤ n ≤ 100) that indicates the number of requests the program has got. Every request is described on a single line and is given by two numbers. The first number represents the request type. If the request type is equal to 1, then in that case the second number indicates the length of a car (in meters) that enters the street looking for a place to park. And if the request type is equal to 2, then the second number identifies the number of such a request (starting with 1) that the car whose arrival to the parking lot was described by a request with this number, leaves the parking lot. It is guaranteed that that car was parked at the moment the request of the 2 type was made. The lengths of cars are integers from 1 to 1000.
|
For every request of the 1 type print number -1 on the single line if the corresponding car couldn't find place to park along the street. Otherwise, print a single number equal to the distance between the back of the car in its parked position and the beginning of the parking lot zone.
| null | null |
[{"input": "30 1 2\n6\n1 5\n1 4\n1 5\n2 2\n1 5\n1 4", "output": "0\n6\n11\n17\n23"}, {"input": "30 1 1\n6\n1 5\n1 4\n1 5\n2 2\n1 5\n1 4", "output": "0\n6\n11\n17\n6"}, {"input": "10 1 1\n1\n1 12", "output": "-1"}]
| 1,800 |
["data structures", "implementation"]
| 30 |
[{"input": "30 1 2\r\n6\r\n1 5\r\n1 4\r\n1 5\r\n2 2\r\n1 5\r\n1 4\r\n", "output": "0\r\n6\r\n11\r\n17\r\n23\r\n"}, {"input": "30 1 1\r\n6\r\n1 5\r\n1 4\r\n1 5\r\n2 2\r\n1 5\r\n1 4\r\n", "output": "0\r\n6\r\n11\r\n17\r\n6\r\n"}, {"input": "10 1 1\r\n1\r\n1 12\r\n", "output": "-1\r\n"}, {"input": "10 1 1\r\n1\r\n1 9\r\n", "output": "0\r\n"}, {"input": "10 1 1\r\n1\r\n1 10\r\n", "output": "0\r\n"}, {"input": "10 1 1\r\n2\r\n1 3\r\n1 6\r\n", "output": "0\r\n4\r\n"}, {"input": "10 1 1\r\n2\r\n1 3\r\n1 7\r\n", "output": "0\r\n-1\r\n"}, {"input": "10 1 1\r\n5\r\n1 1\r\n1 2\r\n1 3\r\n2 2\r\n1 4\r\n", "output": "0\r\n2\r\n5\r\n-1\r\n"}, {"input": "10 1 1\r\n5\r\n1 4\r\n2 1\r\n1 3\r\n2 3\r\n1 1\r\n", "output": "0\r\n0\r\n0\r\n"}, {"input": "10 1 1\r\n5\r\n1 2\r\n1 3\r\n1 1\r\n1 4\r\n1 2\r\n", "output": "0\r\n3\r\n7\r\n-1\r\n-1\r\n"}, {"input": "20 1 2\r\n10\r\n1 3\r\n1 2\r\n2 2\r\n2 1\r\n1 4\r\n1 2\r\n1 2\r\n2 7\r\n1 2\r\n1 1\r\n", "output": "0\r\n4\r\n0\r\n5\r\n8\r\n8\r\n11\r\n"}, {"input": "20 2 1\r\n10\r\n1 5\r\n1 2\r\n1 1\r\n1 1\r\n1 2\r\n2 4\r\n1 3\r\n1 1\r\n2 5\r\n1 5\r\n", "output": "0\r\n7\r\n11\r\n14\r\n17\r\n-1\r\n14\r\n-1\r\n"}, {"input": "20 2 2\r\n10\r\n1 2\r\n1 3\r\n1 3\r\n1 5\r\n1 5\r\n1 1\r\n1 2\r\n1 5\r\n1 5\r\n1 5\r\n", "output": "0\r\n4\r\n9\r\n14\r\n-1\r\n-1\r\n-1\r\n-1\r\n-1\r\n-1\r\n"}, {"input": "30 2 1\r\n10\r\n1 4\r\n2 1\r\n1 1\r\n1 3\r\n1 1\r\n1 1\r\n1 2\r\n1 5\r\n2 4\r\n2 7\r\n", "output": "0\r\n0\r\n3\r\n8\r\n11\r\n14\r\n18\r\n"}, {"input": "30 1 2\r\n10\r\n1 1\r\n1 1\r\n2 1\r\n1 5\r\n1 2\r\n2 4\r\n1 6\r\n2 5\r\n2 2\r\n2 7\r\n", "output": "0\r\n2\r\n4\r\n10\r\n13\r\n"}, {"input": "50 2 3\r\n15\r\n1 7\r\n1 6\r\n1 1\r\n2 3\r\n2 1\r\n2 2\r\n1 1\r\n1 4\r\n1 6\r\n1 2\r\n1 8\r\n1 6\r\n2 7\r\n1 8\r\n2 9\r\n", "output": "0\r\n9\r\n17\r\n0\r\n3\r\n9\r\n17\r\n21\r\n31\r\n39\r\n"}, {"input": "50 2 4\r\n15\r\n1 4\r\n1 4\r\n2 1\r\n2 2\r\n1 8\r\n1 7\r\n2 5\r\n1 2\r\n1 7\r\n2 8\r\n1 7\r\n2 11\r\n1 3\r\n2 6\r\n2 9\r\n", "output": "0\r\n6\r\n0\r\n10\r\n0\r\n19\r\n28\r\n0\r\n"}, {"input": "50 3 3\r\n20\r\n1 4\r\n2 1\r\n1 1\r\n2 3\r\n1 1\r\n2 5\r\n1 7\r\n2 7\r\n1 4\r\n1 1\r\n1 10\r\n1 5\r\n1 2\r\n2 9\r\n2 11\r\n1 1\r\n1 9\r\n2 13\r\n1 8\r\n1 1\r\n", "output": "0\r\n0\r\n0\r\n0\r\n0\r\n7\r\n11\r\n24\r\n32\r\n0\r\n11\r\n32\r\n43\r\n"}, {"input": "50 3 2\r\n20\r\n1 6\r\n1 1\r\n2 2\r\n1 2\r\n1 3\r\n1 1\r\n1 2\r\n2 4\r\n1 7\r\n1 1\r\n2 6\r\n1 9\r\n2 12\r\n2 9\r\n1 8\r\n1 6\r\n1 1\r\n1 8\r\n2 15\r\n1 2\r\n", "output": "0\r\n9\r\n9\r\n14\r\n20\r\n24\r\n29\r\n9\r\n39\r\n29\r\n40\r\n20\r\n-1\r\n29\r\n"}, {"input": "50 3 1\r\n30\r\n1 9\r\n2 1\r\n1 6\r\n1 5\r\n1 8\r\n1 1\r\n2 6\r\n1 7\r\n2 3\r\n2 8\r\n1 7\r\n2 4\r\n2 5\r\n2 11\r\n1 2\r\n2 15\r\n1 6\r\n1 3\r\n2 17\r\n1 9\r\n1 3\r\n2 18\r\n1 3\r\n2 23\r\n2 21\r\n1 8\r\n1 2\r\n2 27\r\n1 8\r\n2 29\r\n", "output": "0\r\n0\r\n9\r\n17\r\n28\r\n28\r\n0\r\n0\r\n0\r\n9\r\n15\r\n0\r\n6\r\n0\r\n11\r\n27\r\n"}]
| false |
stdio
| null | true |
691/E
|
691
|
E
|
PyPy 3-64
|
TESTS
| 3 | 46 | 1,433,600 |
176840275
|
mod=10**9+7
def matmul(A,B,mod):
res = [[0]*len(B[0]) for _ in [None]*len(A)]
for i, resi in enumerate(res):
for k, aik in enumerate(A[i]):
for j,bkj in enumerate(B[k]):
resi[j] += aik*bkj
resi[j] %= mod
return res
def matpow(A,p,mod):
if p%2:
return matmul(A, matpow(A,p-1,mod),mod)
elif p > 0:
b = matpow(A,p//2,mod)
return matmul(b,b,mod)
else:
return [[int(i==j) for j in range(len(A))] for i in range(len(A))]
n,k=map(int,input().split())
a=list(map(int,input().split()))
mat=[[0]*n for i in range(n)]
for i in range(n):
for j in range(n):
if (a[i]^a[j])%3==0:
mat[i][j]=1
matp=matpow(mat,k-1,mod)
ansmat=matmul(matp,[[1] for i in range(n)],mod)
ans=0
for i in range(n):
ans+=ansmat[i][0]
print(ans%mod)
| 12 | 482 | 9,420,800 |
176840656
|
mod=10**9+7
def popcount(n):
c=(n&0x5555555555555555)+((n>>1)&0x5555555555555555)
c=(c&0x3333333333333333)+((c>>2)&0x3333333333333333)
c=(c&0x0f0f0f0f0f0f0f0f)+((c>>4)&0x0f0f0f0f0f0f0f0f)
c=(c&0x00ff00ff00ff00ff)+((c>>8)&0x00ff00ff00ff00ff)
c=(c&0x0000ffff0000ffff)+((c>>16)&0x0000ffff0000ffff)
c=(c&0x00000000ffffffff)+((c>>32)&0x00000000ffffffff)
return c
def matmul(A,B):
res = [[0]*len(B[0]) for _ in [None]*len(A)]
for i, resi in enumerate(res):
for k, aik in enumerate(A[i]):
for j,bkj in enumerate(B[k]):
resi[j] += aik*bkj
resi[j] %= mod
return res
def matpow(A,p):
if p%2:
return matmul(A, matpow(A,p-1))
elif p > 0:
b = matpow(A,p//2)
return matmul(b,b)
else:
return [[int(i==j) for j in range(len(A))] for i in range(len(A))]
n,k=map(int,input().split())
a=list(map(int,input().split()))
mat=[[0]*n for i in range(n)]
for i in range(n):
for j in range(n):
if popcount(a[i]^a[j])%3==0:
mat[i][j]=1
matp=matpow(mat,k-1)
ansmat=matmul(matp,[[1] for i in range(n)])
ans=0
for i in range(n):
ans+=ansmat[i][0]
print(ans%mod)
|
Educational Codeforces Round 14
|
ICPC
| 2,016 | 3 | 256 |
Xor-sequences
|
You are given n integers a1, a2, ..., an.
A sequence of integers x1, x2, ..., xk is called a "xor-sequence" if for every 1 ≤ i ≤ k - 1 the number of ones in the binary representation of the number xi $$\times$$ xi + 1's is a multiple of 3 and $$x_i \in \{a_1, a_2, \ldots, a_n\}$$ for all 1 ≤ i ≤ k. The symbol $$\times$$ is used for the binary exclusive or operation.
How many "xor-sequences" of length k exist? Output the answer modulo 109 + 7.
Note if a = [1, 1] and k = 1 then the answer is 2, because you should consider the ones from a as different.
|
The first line contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1018) — the number of given integers and the length of the "xor-sequences".
The second line contains n integers ai (0 ≤ ai ≤ 1018).
|
Print the only integer c — the number of "xor-sequences" of length k modulo 109 + 7.
| null | null |
[{"input": "5 2\n15 1 2 4 8", "output": "13"}, {"input": "5 1\n15 1 2 4 8", "output": "5"}]
| 1,900 |
["matrices"]
| 12 |
[{"input": "5 2\r\n15 1 2 4 8\r\n", "output": "13\r\n"}, {"input": "5 1\r\n15 1 2 4 8\r\n", "output": "5\r\n"}, {"input": "10 1\r\n44 65 23 44 100 19 19 23 19 40\r\n", "output": "10\r\n"}, {"input": "10 2\r\n93 93 85 48 44 98 93 100 98 98\r\n", "output": "52\r\n"}, {"input": "10 100\r\n22 0 41 63 22 41 17 22 15 42\r\n", "output": "205668186\r\n"}, {"input": "10 1000000000\r\n454240622 216977025 454240622 509843007 509843007 26552516 488949284 708817573 453191950 447767457\r\n", "output": "108319885\r\n"}, {"input": "100 576460752303423487\r\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\r\n", "output": "959277620\r\n"}, {"input": "100 576460752303423488\r\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\r\n", "output": "927761335\r\n"}]
| false |
stdio
| null | true |
615/B
|
615
|
B
|
Python 3
|
TESTS
| 0 | 46 | 0 |
209766175
|
def calculate_beauty(n, m, segments):
# Tạo một danh sách liên kết chứa các đỉnh kề của mỗi đỉnh
adjacent = [[] for _ in range(n + 1)]
for u, v in segments:
adjacent[u].append(v)
# Tạo một mảng lưu trữ độ dài đuôi dài nhất kết thúc tại mỗi đỉnh
tail_lengths = [0] * (n + 1)
# Duyệt qua từng đỉnh
for u in range(1, n + 1):
# Duyệt qua các đỉnh kề của u
for v in adjacent[u]:
# Cập nhật độ dài đuôi của v nếu có thể
tail_lengths[v] = max(tail_lengths[v], tail_lengths[u] + 1)
# Tìm độ dài đuôi lớn nhất
max_tail_length = max(tail_lengths)
# Tính toán kết quả
beauty = max_tail_length * m
return beauty
# Đọc dữ liệu đầu vào
n, m = map(int, input().split())
segments = []
for _ in range(m):
u, v = map(int, input().split())
segments.append((u, v))
# Gọi hàm tính toán và in kết quả
result = calculate_beauty(n, m, segments)
print(result)
| 60 | 1,075 | 13,209,600 |
15243597
|
n, m = [int(x) for x in input().split()]
values = [1] * n
nodes = [list() for _ in range(n)]
spikes = [0] * n
for _ in range(m):
n1, n2 = [int(x) for x in input().split()]
if n1 > n2:
n1, n2 = n2, n1
nodes[n1-1].append(n2-1)
spikes[n1-1] += 1
spikes[n2-1] += 1
for i in range(0, n):
for node in nodes[i]:
values[node] = max(values[node], values[i] + 1)
m = max(range(n), key=lambda i: spikes[i] * values[i])
print(spikes[m] * values[m])
|
Codeforces Round 338 (Div. 2)
|
CF
| 2,016 | 3 | 256 |
Longtail Hedgehog
|
This Christmas Santa gave Masha a magic picture and a pencil. The picture consists of n points connected by m segments (they might cross in any way, that doesn't matter). No two segments connect the same pair of points, and no segment connects the point to itself. Masha wants to color some segments in order paint a hedgehog. In Mashas mind every hedgehog consists of a tail and some spines. She wants to paint the tail that satisfies the following conditions:
1. Only segments already presented on the picture can be painted;
2. The tail should be continuous, i.e. consists of some sequence of points, such that every two neighbouring points are connected by a colored segment;
3. The numbers of points from the beginning of the tail to the end should strictly increase.
Masha defines the length of the tail as the number of points in it. Also, she wants to paint some spines. To do so, Masha will paint all the segments, such that one of their ends is the endpoint of the tail. Masha defines the beauty of a hedgehog as the length of the tail multiplied by the number of spines. Masha wants to color the most beautiful hedgehog. Help her calculate what result she may hope to get.
Note that according to Masha's definition of a hedgehog, one segment may simultaneously serve as a spine and a part of the tail (she is a little girl after all). Take a look at the picture for further clarifications.
|
First line of the input contains two integers n and m(2 ≤ n ≤ 100 000, 1 ≤ m ≤ 200 000) — the number of points and the number segments on the picture respectively.
Then follow m lines, each containing two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the numbers of points connected by corresponding segment. It's guaranteed that no two segments connect the same pair of points.
|
Print the maximum possible value of the hedgehog's beauty.
| null |
The picture below corresponds to the first sample. Segments that form the hedgehog are painted red. The tail consists of a sequence of points with numbers 1, 2 and 5. The following segments are spines: (2, 5), (3, 5) and (4, 5). Therefore, the beauty of the hedgehog is equal to 3·3 = 9.
|
[{"input": "8 6\n4 5\n3 5\n2 5\n1 2\n2 8\n6 7", "output": "9"}, {"input": "4 6\n1 2\n1 3\n1 4\n2 3\n2 4\n3 4", "output": "12"}]
| 1,600 |
["dp", "graphs"]
| 60 |
[{"input": "8 6\r\n4 5\r\n3 5\r\n2 5\r\n1 2\r\n2 8\r\n6 7\r\n", "output": "9\r\n"}, {"input": "4 6\r\n1 2\r\n1 3\r\n1 4\r\n2 3\r\n2 4\r\n3 4\r\n", "output": "12\r\n"}, {"input": "5 7\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n", "output": "9\r\n"}, {"input": "5 9\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n1 5\r\n2 5\r\n", "output": "16\r\n"}, {"input": "10 10\r\n6 3\r\n2 9\r\n9 4\r\n4 5\r\n10 3\r\n8 3\r\n10 5\r\n7 6\r\n1 4\r\n6 8\r\n", "output": "8\r\n"}, {"input": "100 50\r\n66 3\r\n92 79\r\n9 44\r\n84 45\r\n30 63\r\n30 20\r\n33 86\r\n8 83\r\n40 75\r\n7 36\r\n91 4\r\n76 88\r\n77 76\r\n28 27\r\n6 52\r\n41 57\r\n8 23\r\n34 75\r\n50 15\r\n86 68\r\n36 98\r\n30 84\r\n37 62\r\n22 4\r\n6 45\r\n72 80\r\n98 74\r\n78 84\r\n1 54\r\n99 27\r\n84 91\r\n78 7\r\n80 61\r\n67 48\r\n51 52\r\n36 72\r\n97 87\r\n25 17\r\n20 80\r\n20 39\r\n72 5\r\n21 77\r\n48 1\r\n63 21\r\n92 45\r\n34 93\r\n28 84\r\n3 91\r\n56 99\r\n7 53\r\n", "output": "15\r\n"}, {"input": "5 8\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n1 5\r\n", "output": "12\r\n"}, {"input": "2 1\r\n1 2\r\n", "output": "2\r\n"}, {"input": "10 9\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n1 6\r\n1 7\r\n1 8\r\n1 9\r\n1 10\r\n", "output": "9\r\n"}, {"input": "5 4\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n", "output": "4\r\n"}, {"input": "6 5\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n1 6\r\n", "output": "5\r\n"}]
| false |
stdio
| null | true |
463/D
|
463
|
D
|
Python 3
|
TESTS
| 1 | 78 | 0 |
148165325
|
def lcs(s1,s2):
n1=len(s1)
n2=len(s2)
dp=[[None]*(n2+1) for i in range(n1+1)]
for i in range(n1+1):
for j in range(n2+1):
if i==0 or j==0:
dp[i][j]=0
elif s1[i-1]==s2[j-1]:
dp[i][j]=dp[i-1][j-1]+1
else:
dp[i][j]=max(dp[i-1][j],dp[i][j-1])
return dp[n1][n2]
n,k=[int(x) for x in input().split()]
values=[]
for i in range(k):
l=list(input().split(' '))
s=''.join(l)
#print(s)
values.append(s)
ans=float('inf')
for i in range(len(values)):
for j in range(i+1,len(values)):
ans=min(ans,lcs(values[i],values[j]))
print(ans)
| 40 | 233 | 3,584,000 |
162224619
|
n, k = map(int, input().split())
v = [list(map(int, input().split())) for _ in range(k)]
pos = [[0] * (n + 1) for _ in range(k)]
e = [[] for _ in range(n + 1)]
for j in range(k):
for p, x in enumerate(v[j]):
pos[j][x] = p
e[x].append(p)
e = sorted((e[j], j) for j in range(1, n + 1))
#print(e)
dp = [0] * n
for j in range(n - 1, -1, -1):
dp[j] = 1
for b in range(j + 1, n):
if all(e[b][0][x] > e[j][0][x] for x in range(k)):
#print('Hi')
dp[j] = max(dp[j], 1 + dp[b])
print(max(dp))
|
Codeforces Round 264 (Div. 2)
|
CF
| 2,014 | 2 | 256 |
Gargari and Permutations
|
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
|
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
|
Print the length of the longest common subsequence.
| null |
The answer for the first test sample is subsequence [1, 2, 3].
|
[{"input": "4 3\n1 4 2 3\n4 1 2 3\n1 2 4 3", "output": "3"}]
| 1,900 |
["dfs and similar", "dp", "graphs", "implementation"]
| 40 |
[{"input": "4 3\r\n1 4 2 3\r\n4 1 2 3\r\n1 2 4 3\r\n", "output": "3\r\n"}, {"input": "6 3\r\n2 5 1 4 6 3\r\n5 1 4 3 2 6\r\n5 4 2 6 3 1\r\n", "output": "3\r\n"}, {"input": "41 4\r\n24 15 17 35 13 41 4 14 23 5 8 16 21 18 30 36 6 22 11 29 26 1 40 31 7 3 32 10 28 38 12 20 39 37 34 19 33 27 2 25 9\r\n22 13 25 24 38 35 29 12 15 8 11 37 3 19 4 23 18 32 30 40 36 21 16 34 27 9 5 41 39 2 14 17 31 33 26 7 1 10 20 6 28\r\n31 27 39 16 22 12 13 32 6 10 19 29 37 7 18 33 24 21 1 9 36 4 34 41 25 28 17 40 30 35 23 14 11 8 2 15 38 20 26 5 3\r\n8 18 39 38 7 34 16 31 15 1 40 20 37 4 25 11 17 19 33 26 6 14 13 41 12 32 2 21 10 35 27 9 28 5 30 24 22 23 29 3 36\r\n", "output": "4\r\n"}, {"input": "1 2\r\n1\r\n1\r\n", "output": "1\r\n"}, {"input": "28 5\r\n3 14 12 16 13 27 20 8 1 10 24 11 5 9 7 18 17 23 22 25 28 19 4 21 26 6 15 2\r\n7 12 23 27 22 26 16 18 19 5 6 9 11 28 25 4 10 3 1 14 8 17 15 2 20 13 24 21\r\n21 20 2 5 19 15 12 4 18 9 23 16 11 14 8 6 25 27 13 17 10 26 7 24 28 1 3 22\r\n12 2 23 11 20 18 25 21 13 27 14 8 4 6 9 16 7 3 10 1 22 15 26 19 5 17 28 24\r\n13 2 6 19 22 23 4 1 28 10 18 17 21 8 9 3 26 11 12 27 14 20 24 25 15 5 16 7\r\n", "output": "3\r\n"}, {"input": "6 3\r\n2 5 1 4 6 3\r\n5 1 4 6 2 3\r\n5 4 2 6 3 1\r\n", "output": "4\r\n"}, {"input": "41 4\r\n24 15 17 35 13 41 4 14 23 5 8 16 21 18 30 36 6 22 11 29 26 1 40 31 7 3 32 10 28 38 12 20 39 37 34 19 33 27 2 25 9\r\n22 13 25 24 38 35 29 12 15 8 11 37 3 19 4 23 18 32 30 40 36 21 16 34 27 9 5 41 39 2 14 17 31 33 26 7 1 10 20 6 28\r\n31 27 39 16 22 12 13 32 6 10 19 29 37 7 18 33 24 21 1 9 36 4 34 41 25 28 17 40 30 35 23 14 11 8 2 15 38 20 26 5 3\r\n8 18 39 38 7 34 16 31 15 1 40 20 37 4 25 11 17 19 33 26 6 14 13 41 12 32 2 21 10 35 27 9 28 5 30 24 22 23 29 3 36\r\n", "output": "4\r\n"}, {"input": "37 3\r\n6 3 19 20 15 4 1 35 8 24 12 21 34 26 18 14 23 33 28 9 36 11 37 31 25 32 29 22 13 27 16 17 10 7 5 30 2\r\n10 3 35 17 34 21 14 8 26 28 11 19 27 7 4 23 24 22 12 13 16 1 25 29 5 31 30 20 32 18 15 9 2 36 37 33 6\r\n19 9 22 32 26 35 29 23 5 6 14 34 33 10 2 28 15 11 24 4 13 7 8 31 37 36 1 27 3 16 30 25 20 21 18 17 12\r\n", "output": "7\r\n"}]
| false |
stdio
| null | true |
463/D
|
463
|
D
|
PyPy 3
|
TESTS
| 1 | 77 | 1,536,000 |
147021243
|
length,no_of_permutations = map(int,input().split(" "))
P = [-1]*(no_of_permutations+1)
position = [[0]*(length+1)]*(no_of_permutations+1)
for k in range(1,no_of_permutations+1):
P[k] = list(map(int,input().split(" ")))
P[k].insert(0,0)
for i in range(1,length+1):
element = P[k][i]
position[k][element] = i
answer = 1
maximum_length_till = [0]*(length+1)
for i in range(1,length+1):
maximum_length_till[i] = 1
for j in range(1,i):
current,previous = P[1][i],P[1][j]
previous_always_before_current = 1
for k in range(1,no_of_permutations+1):
if(position[k][previous] > position[k][current]):
previous_always_before_current = 0
if(previous_always_before_current):
maximum_length_till[i] = max(maximum_length_till[i], 1 + maximum_length_till[j])
answer = max(answer,maximum_length_till[i])
print(answer)
| 40 | 389 | 7,372,800 |
118350342
|
n, k = map(int, input().split())
ra = [[0] * k for _ in range(n)]
for p in range(k):
for i, v in enumerate(map(int, input().split())):
v -= 1
ra[v][p] = i
g = [[] for _ in range(n)]
for u in range(n):
for v in range(n):
if all(x < y for x, y in zip(ra[u], ra[v])):
g[u].append(v)
memo = [-1] * n
def dfs(v):
if memo[v] != -1:
return memo[v]
r = 1
for u in g[v]:
r = max(r, dfs(u) + 1)
memo[v] = r
return r
print(max(dfs(s) for s in range(n)))
|
Codeforces Round 264 (Div. 2)
|
CF
| 2,014 | 2 | 256 |
Gargari and Permutations
|
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
|
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
|
Print the length of the longest common subsequence.
| null |
The answer for the first test sample is subsequence [1, 2, 3].
|
[{"input": "4 3\n1 4 2 3\n4 1 2 3\n1 2 4 3", "output": "3"}]
| 1,900 |
["dfs and similar", "dp", "graphs", "implementation"]
| 40 |
[{"input": "4 3\r\n1 4 2 3\r\n4 1 2 3\r\n1 2 4 3\r\n", "output": "3\r\n"}, {"input": "6 3\r\n2 5 1 4 6 3\r\n5 1 4 3 2 6\r\n5 4 2 6 3 1\r\n", "output": "3\r\n"}, {"input": "41 4\r\n24 15 17 35 13 41 4 14 23 5 8 16 21 18 30 36 6 22 11 29 26 1 40 31 7 3 32 10 28 38 12 20 39 37 34 19 33 27 2 25 9\r\n22 13 25 24 38 35 29 12 15 8 11 37 3 19 4 23 18 32 30 40 36 21 16 34 27 9 5 41 39 2 14 17 31 33 26 7 1 10 20 6 28\r\n31 27 39 16 22 12 13 32 6 10 19 29 37 7 18 33 24 21 1 9 36 4 34 41 25 28 17 40 30 35 23 14 11 8 2 15 38 20 26 5 3\r\n8 18 39 38 7 34 16 31 15 1 40 20 37 4 25 11 17 19 33 26 6 14 13 41 12 32 2 21 10 35 27 9 28 5 30 24 22 23 29 3 36\r\n", "output": "4\r\n"}, {"input": "1 2\r\n1\r\n1\r\n", "output": "1\r\n"}, {"input": "28 5\r\n3 14 12 16 13 27 20 8 1 10 24 11 5 9 7 18 17 23 22 25 28 19 4 21 26 6 15 2\r\n7 12 23 27 22 26 16 18 19 5 6 9 11 28 25 4 10 3 1 14 8 17 15 2 20 13 24 21\r\n21 20 2 5 19 15 12 4 18 9 23 16 11 14 8 6 25 27 13 17 10 26 7 24 28 1 3 22\r\n12 2 23 11 20 18 25 21 13 27 14 8 4 6 9 16 7 3 10 1 22 15 26 19 5 17 28 24\r\n13 2 6 19 22 23 4 1 28 10 18 17 21 8 9 3 26 11 12 27 14 20 24 25 15 5 16 7\r\n", "output": "3\r\n"}, {"input": "6 3\r\n2 5 1 4 6 3\r\n5 1 4 6 2 3\r\n5 4 2 6 3 1\r\n", "output": "4\r\n"}, {"input": "41 4\r\n24 15 17 35 13 41 4 14 23 5 8 16 21 18 30 36 6 22 11 29 26 1 40 31 7 3 32 10 28 38 12 20 39 37 34 19 33 27 2 25 9\r\n22 13 25 24 38 35 29 12 15 8 11 37 3 19 4 23 18 32 30 40 36 21 16 34 27 9 5 41 39 2 14 17 31 33 26 7 1 10 20 6 28\r\n31 27 39 16 22 12 13 32 6 10 19 29 37 7 18 33 24 21 1 9 36 4 34 41 25 28 17 40 30 35 23 14 11 8 2 15 38 20 26 5 3\r\n8 18 39 38 7 34 16 31 15 1 40 20 37 4 25 11 17 19 33 26 6 14 13 41 12 32 2 21 10 35 27 9 28 5 30 24 22 23 29 3 36\r\n", "output": "4\r\n"}, {"input": "37 3\r\n6 3 19 20 15 4 1 35 8 24 12 21 34 26 18 14 23 33 28 9 36 11 37 31 25 32 29 22 13 27 16 17 10 7 5 30 2\r\n10 3 35 17 34 21 14 8 26 28 11 19 27 7 4 23 24 22 12 13 16 1 25 29 5 31 30 20 32 18 15 9 2 36 37 33 6\r\n19 9 22 32 26 35 29 23 5 6 14 34 33 10 2 28 15 11 24 4 13 7 8 31 37 36 1 27 3 16 30 25 20 21 18 17 12\r\n", "output": "7\r\n"}]
| false |
stdio
| null | true |
1000/E
|
1000
|
E
|
PyPy 3-64
|
TESTS
| 2 | 342 | 16,179,200 |
203203035
|
def dfs(node,p):
global time,ans
visited[node] = True
time += 1
tin[node] = time
low[node] = time
for child in adj[node]:
if child == p:
continue
if visited[child]:
low[node] = min(low[node],low[child])
else:
dfs(child,node)
low[node] = min(low[node],low[child])
if low[child] > tin[node]:
ans += 1
n,m = map(int,input().split(" "))
adj = []
for i in range(n+1):
adj.append([])
for i in range(m):
x,y = map(int,input().split(" "))
adj[x].append(y)
adj[y].append(x)
visited = [False] * (n+1)
tin = [-1] * (n+1)
low = [-1] * (n+1)
ans = 0
time = 0
for node in range(1,n+1):
if not visited[node]:
dfs(node,-1)
print(ans)
| 55 | 1,200 | 146,432,000 |
186307945
|
from sys import stdin
input=lambda :stdin.readline()[:-1]
def lowlink(links):
n = len(links)
order = [-1] * n
low = [n] * n
parent = [-1] * n
child = [[] for _ in range(n)]
roots = set()
x = 0
for root in range(n):
if order[root] != -1:
continue
roots.add(root)
stack = [root]
parent[root] = -2
while stack:
i = stack.pop()
if i >= 0:
if order[i] != -1:
continue
order[i] = x
low[i] = x
x += 1
if i != root:
child[parent[i]].append(i)
stack.append(~i)
check_p = 0
for j in links[i]:
if j == parent[i] and check_p == 0:
check_p += 1
continue
elif order[j] != -1:
low[i] = min(low[i], order[j])
else:
parent[j] = i
stack.append(j)
else:
i = ~i
if i == root:
continue
p = parent[i]
low[p] = min(low[p], low[i])
return order,low,roots,child
def get_articulation(links):
n = len(links)
order,low,roots,child = lowlink(links)
articulation = [0] * n
for i in range(n):
if i in roots:
if len(child[i]) >= 2:
articulation[i] = 1
continue
for j in child[i]:
if order[i] <= low[j]:
articulation[i] = 1
break
return articulation
def get_bridge(links):
n = len(links)
order,low,roots,child = lowlink(links)
bridge = []
for root in roots:
stack = [root]
while stack:
i = stack.pop()
for j in child[i]:
if order[i] < low[j]:
bridge.append([i,j])
stack.append(j)
return bridge
def two_edge_connected_componets(links):
n = len(links)
order,low,roots,child = lowlink(links)
components = [-1] * n
new_edges = []
x = 0
for root in roots:
components[root] = x
stack = [root]
while stack:
i = stack.pop()
for j in child[i]:
if order[i] < low[j]:
x += 1
components[j] = x
new_edges.append([components[i],x])
else:
components[j] = components[i]
stack.append(j)
x += 1
return components,new_edges
from sys import stdin
input=lambda :stdin.readline()[:-1]
n,m=map(int,input().split())
edge=[[] for i in range(n)]
for _ in range(m):
x,y=map(lambda x:int(x)-1,input().split())
edge[x].append(y)
edge[y].append(x)
components,new_edges = two_edge_connected_componets(edge)
N=max(components)+1
edge2=[[] for i in range(N)]
for x,y in new_edges:
edge2[x].append(y)
edge2[y].append(x)
def dfs(start):
dist=[-1]*N
dist[start]=0
todo=[start]
while todo:
v=todo.pop()
for u in edge2[v]:
if dist[u]==-1:
dist[u]=dist[v]+1
todo.append(u)
mx=max(dist)
idx=dist.index(mx)
return mx,idx
_,v0=dfs(0)
ans,_=dfs(v0)
print(ans)
|
Educational Codeforces Round 46 (Rated for Div. 2)
|
ICPC
| 2,018 | 2 | 256 |
We Need More Bosses
|
Your friend is developing a computer game. He has already decided how the game world should look like — it should consist of $$$n$$$ locations connected by $$$m$$$ two-way passages. The passages are designed in such a way that it should be possible to get from any location to any other location.
Of course, some passages should be guarded by the monsters (if you just can go everywhere without any difficulties, then it's not fun, right?). Some crucial passages will be guarded by really fearsome monsters, requiring the hero to prepare for battle and designing his own tactics of defeating them (commonly these kinds of monsters are called bosses). And your friend wants you to help him place these bosses.
The game will start in location $$$s$$$ and end in location $$$t$$$, but these locations are not chosen yet. After choosing these locations, your friend will place a boss in each passage such that it is impossible to get from $$$s$$$ to $$$t$$$ without using this passage. Your friend wants to place as much bosses as possible (because more challenges means more fun, right?), so he asks you to help him determine the maximum possible number of bosses, considering that any location can be chosen as $$$s$$$ or as $$$t$$$.
|
The first line contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n \le 3 \cdot 10^5$$$, $$$n - 1 \le m \le 3 \cdot 10^5$$$) — the number of locations and passages, respectively.
Then $$$m$$$ lines follow, each containing two integers $$$x$$$ and $$$y$$$ ($$$1 \le x, y \le n$$$, $$$x \ne y$$$) describing the endpoints of one of the passages.
It is guaranteed that there is no pair of locations directly connected by two or more passages, and that any location is reachable from any other location.
|
Print one integer — the maximum number of bosses your friend can place, considering all possible choices for $$$s$$$ and $$$t$$$.
| null | null |
[{"input": "5 5\n1 2\n2 3\n3 1\n4 1\n5 2", "output": "2"}, {"input": "4 3\n1 2\n4 3\n3 2", "output": "3"}]
| 2,100 |
["dfs and similar", "graphs", "trees"]
| 55 |
[{"input": "5 5\r\n1 2\r\n2 3\r\n3 1\r\n4 1\r\n5 2\r\n", "output": "2\r\n"}, {"input": "4 3\r\n1 2\r\n4 3\r\n3 2\r\n", "output": "3\r\n"}, {"input": "50 72\r\n35 38\r\n19 46\r\n35 12\r\n27 30\r\n23 41\r\n50 16\r\n31 6\r\n20 33\r\n38 1\r\n10 35\r\n13 43\r\n29 25\r\n25 4\r\n1 13\r\n4 20\r\n36 29\r\n13 47\r\n48 5\r\n30 21\r\n30 38\r\n28 50\r\n41 45\r\n25 43\r\n40 36\r\n19 47\r\n31 32\r\n26 28\r\n8 13\r\n43 24\r\n27 35\r\n14 29\r\n14 38\r\n50 9\r\n34 49\r\n12 34\r\n43 42\r\n41 15\r\n46 29\r\n48 11\r\n48 7\r\n40 29\r\n48 21\r\n18 26\r\n15 11\r\n12 39\r\n18 42\r\n27 12\r\n6 9\r\n19 37\r\n45 39\r\n5 36\r\n37 22\r\n18 49\r\n15 38\r\n24 42\r\n34 45\r\n43 3\r\n2 1\r\n18 48\r\n43 30\r\n26 10\r\n30 13\r\n2 27\r\n8 3\r\n22 42\r\n14 4\r\n14 27\r\n13 3\r\n14 10\r\n41 25\r\n17 50\r\n44 9\r\n", "output": "8\r\n"}, {"input": "5 6\r\n1 5\r\n2 3\r\n3 5\r\n2 1\r\n2 5\r\n2 4\r\n", "output": "1\r\n"}]
| false |
stdio
| null | true |
1000/E
|
1000
|
E
|
PyPy 3-64
|
TESTS
| 2 | 342 | 19,763,200 |
203203102
|
def dfs(node,p):
global time,ans
visited[node] = True
time += 1
tin[node] = time
low[node] = time
for child in adj[node]:
if child == p:
continue
if visited[child]:
low[node] = min(low[node],low[child])
else:
dfs(child,node)
low[node] = min(low[node],low[child])
if low[child] > tin[node]:
ans += 1
n,m = map(int,input().split(" "))
adj = []
for i in range(n+1):
adj.append([])
edges = set()
for i in range(m):
x,y = map(int,input().split(" "))
edges.add((x,y))
edges.add((y,x))
for x,y in edges:
adj[x].append(y)
visited = [False] * (n+1)
tin = [-1] * (n+1)
low = [-1] * (n+1)
ans = 0
time = 0
for node in range(1,n+1):
if not visited[node]:
dfs(node,-1)
print(ans)
| 55 | 1,200 | 146,432,000 |
186307945
|
from sys import stdin
input=lambda :stdin.readline()[:-1]
def lowlink(links):
n = len(links)
order = [-1] * n
low = [n] * n
parent = [-1] * n
child = [[] for _ in range(n)]
roots = set()
x = 0
for root in range(n):
if order[root] != -1:
continue
roots.add(root)
stack = [root]
parent[root] = -2
while stack:
i = stack.pop()
if i >= 0:
if order[i] != -1:
continue
order[i] = x
low[i] = x
x += 1
if i != root:
child[parent[i]].append(i)
stack.append(~i)
check_p = 0
for j in links[i]:
if j == parent[i] and check_p == 0:
check_p += 1
continue
elif order[j] != -1:
low[i] = min(low[i], order[j])
else:
parent[j] = i
stack.append(j)
else:
i = ~i
if i == root:
continue
p = parent[i]
low[p] = min(low[p], low[i])
return order,low,roots,child
def get_articulation(links):
n = len(links)
order,low,roots,child = lowlink(links)
articulation = [0] * n
for i in range(n):
if i in roots:
if len(child[i]) >= 2:
articulation[i] = 1
continue
for j in child[i]:
if order[i] <= low[j]:
articulation[i] = 1
break
return articulation
def get_bridge(links):
n = len(links)
order,low,roots,child = lowlink(links)
bridge = []
for root in roots:
stack = [root]
while stack:
i = stack.pop()
for j in child[i]:
if order[i] < low[j]:
bridge.append([i,j])
stack.append(j)
return bridge
def two_edge_connected_componets(links):
n = len(links)
order,low,roots,child = lowlink(links)
components = [-1] * n
new_edges = []
x = 0
for root in roots:
components[root] = x
stack = [root]
while stack:
i = stack.pop()
for j in child[i]:
if order[i] < low[j]:
x += 1
components[j] = x
new_edges.append([components[i],x])
else:
components[j] = components[i]
stack.append(j)
x += 1
return components,new_edges
from sys import stdin
input=lambda :stdin.readline()[:-1]
n,m=map(int,input().split())
edge=[[] for i in range(n)]
for _ in range(m):
x,y=map(lambda x:int(x)-1,input().split())
edge[x].append(y)
edge[y].append(x)
components,new_edges = two_edge_connected_componets(edge)
N=max(components)+1
edge2=[[] for i in range(N)]
for x,y in new_edges:
edge2[x].append(y)
edge2[y].append(x)
def dfs(start):
dist=[-1]*N
dist[start]=0
todo=[start]
while todo:
v=todo.pop()
for u in edge2[v]:
if dist[u]==-1:
dist[u]=dist[v]+1
todo.append(u)
mx=max(dist)
idx=dist.index(mx)
return mx,idx
_,v0=dfs(0)
ans,_=dfs(v0)
print(ans)
|
Educational Codeforces Round 46 (Rated for Div. 2)
|
ICPC
| 2,018 | 2 | 256 |
We Need More Bosses
|
Your friend is developing a computer game. He has already decided how the game world should look like — it should consist of $$$n$$$ locations connected by $$$m$$$ two-way passages. The passages are designed in such a way that it should be possible to get from any location to any other location.
Of course, some passages should be guarded by the monsters (if you just can go everywhere without any difficulties, then it's not fun, right?). Some crucial passages will be guarded by really fearsome monsters, requiring the hero to prepare for battle and designing his own tactics of defeating them (commonly these kinds of monsters are called bosses). And your friend wants you to help him place these bosses.
The game will start in location $$$s$$$ and end in location $$$t$$$, but these locations are not chosen yet. After choosing these locations, your friend will place a boss in each passage such that it is impossible to get from $$$s$$$ to $$$t$$$ without using this passage. Your friend wants to place as much bosses as possible (because more challenges means more fun, right?), so he asks you to help him determine the maximum possible number of bosses, considering that any location can be chosen as $$$s$$$ or as $$$t$$$.
|
The first line contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n \le 3 \cdot 10^5$$$, $$$n - 1 \le m \le 3 \cdot 10^5$$$) — the number of locations and passages, respectively.
Then $$$m$$$ lines follow, each containing two integers $$$x$$$ and $$$y$$$ ($$$1 \le x, y \le n$$$, $$$x \ne y$$$) describing the endpoints of one of the passages.
It is guaranteed that there is no pair of locations directly connected by two or more passages, and that any location is reachable from any other location.
|
Print one integer — the maximum number of bosses your friend can place, considering all possible choices for $$$s$$$ and $$$t$$$.
| null | null |
[{"input": "5 5\n1 2\n2 3\n3 1\n4 1\n5 2", "output": "2"}, {"input": "4 3\n1 2\n4 3\n3 2", "output": "3"}]
| 2,100 |
["dfs and similar", "graphs", "trees"]
| 55 |
[{"input": "5 5\r\n1 2\r\n2 3\r\n3 1\r\n4 1\r\n5 2\r\n", "output": "2\r\n"}, {"input": "4 3\r\n1 2\r\n4 3\r\n3 2\r\n", "output": "3\r\n"}, {"input": "50 72\r\n35 38\r\n19 46\r\n35 12\r\n27 30\r\n23 41\r\n50 16\r\n31 6\r\n20 33\r\n38 1\r\n10 35\r\n13 43\r\n29 25\r\n25 4\r\n1 13\r\n4 20\r\n36 29\r\n13 47\r\n48 5\r\n30 21\r\n30 38\r\n28 50\r\n41 45\r\n25 43\r\n40 36\r\n19 47\r\n31 32\r\n26 28\r\n8 13\r\n43 24\r\n27 35\r\n14 29\r\n14 38\r\n50 9\r\n34 49\r\n12 34\r\n43 42\r\n41 15\r\n46 29\r\n48 11\r\n48 7\r\n40 29\r\n48 21\r\n18 26\r\n15 11\r\n12 39\r\n18 42\r\n27 12\r\n6 9\r\n19 37\r\n45 39\r\n5 36\r\n37 22\r\n18 49\r\n15 38\r\n24 42\r\n34 45\r\n43 3\r\n2 1\r\n18 48\r\n43 30\r\n26 10\r\n30 13\r\n2 27\r\n8 3\r\n22 42\r\n14 4\r\n14 27\r\n13 3\r\n14 10\r\n41 25\r\n17 50\r\n44 9\r\n", "output": "8\r\n"}, {"input": "5 6\r\n1 5\r\n2 3\r\n3 5\r\n2 1\r\n2 5\r\n2 4\r\n", "output": "1\r\n"}]
| false |
stdio
| null | true |
384/B
|
384
|
B
|
Python 3
|
TESTS
| 0 | 15 | 0 |
162726502
|
n, m, k = map(int, input().split())
trash = [list(map(int, input().split())) for i in range(n)]
ans = []
if k == 0:
for i in range(m):
for j in range(i+1, m):
ans.append([i, j])
if k == 1:
for i in range(m):
for j in range(i+1, m):
ans.append([j, i])
print(len(ans))
for p in ans:
print(p[0], p[1])
# Mon Jul 04 2022 09:26:52 GMT+0000 (Coordinated Universal Time)
| 31 | 78 | 5,632,000 |
229925052
|
n, m, k = [int(i) for i in input().split()]
p = (m - 1) * m // 2
print(p)
if k == 0:
for i in range(m - 1):
for j in range(i + 1, m):
print(i + 1, j + 1)
else:
for i in range(m - 1, 0, -1):
for j in range(i - 1, -1, -1):
print(i + 1, j + 1)# 1698348805.8155658
|
Codeforces Round 225 (Div. 2)
|
CF
| 2,014 | 1 | 256 |
Multitasking
|
Iahub wants to enhance his multitasking abilities. In order to do this, he wants to sort n arrays simultaneously, each array consisting of m integers.
Iahub can choose a pair of distinct indices i and j (1 ≤ i, j ≤ m, i ≠ j). Then in each array the values at positions i and j are swapped only if the value at position i is strictly greater than the value at position j.
Iahub wants to find an array of pairs of distinct indices that, chosen in order, sort all of the n arrays in ascending or descending order (the particular order is given in input). The size of the array can be at most $$\frac{m(m-1)}{2}$$ (at most $$\frac{m(m-1)}{2}$$ pairs). Help Iahub, find any suitable array.
|
The first line contains three integers n (1 ≤ n ≤ 1000), m (1 ≤ m ≤ 100) and k. Integer k is 0 if the arrays must be sorted in ascending order, and 1 if the arrays must be sorted in descending order. Each line i of the next n lines contains m integers separated by a space, representing the i-th array. For each element x of the array i, 1 ≤ x ≤ 106 holds.
|
On the first line of the output print an integer p, the size of the array (p can be at most $$\frac{m(m-1)}{2}$$). Each of the next p lines must contain two distinct integers i and j (1 ≤ i, j ≤ m, i ≠ j), representing the chosen indices.
If there are multiple correct answers, you can print any.
| null |
Consider the first sample. After the first operation, the arrays become [1, 3, 2, 5, 4] and [1, 2, 3, 4, 5]. After the second operation, the arrays become [1, 2, 3, 5, 4] and [1, 2, 3, 4, 5]. After the third operation they become [1, 2, 3, 4, 5] and [1, 2, 3, 4, 5].
|
[{"input": "2 5 0\n1 3 2 5 4\n1 4 3 2 5", "output": "3\n2 4\n2 3\n4 5"}, {"input": "3 2 1\n1 2\n2 3\n3 4", "output": "1\n2 1"}]
| 1,500 |
["greedy", "implementation", "sortings", "two pointers"]
| 31 |
[{"input": "2 5 0\r\n1 3 2 5 4\r\n1 4 3 2 5\r\n", "output": "3\r\n2 4\r\n2 3\r\n4 5\r\n"}, {"input": "3 2 1\r\n1 2\r\n2 3\r\n3 4\r\n", "output": "1\r\n2 1\r\n"}, {"input": "2 5 0\r\n836096 600367 472071 200387 79763\r\n714679 505282 233544 157810 152591\r\n", "output": "10\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n2 3\r\n2 4\r\n2 5\r\n3 4\r\n3 5\r\n4 5\r\n"}, {"input": "2 5 1\r\n331081 525217 574775 753333 840639\r\n225591 347017 538639 620341 994088\r\n", "output": "10\r\n2 1\r\n3 1\r\n4 1\r\n5 1\r\n3 2\r\n4 2\r\n5 2\r\n4 3\r\n5 3\r\n5 4\r\n"}, {"input": "1 1 0\r\n1\r\n", "output": "0\r\n"}, {"input": "1 1 1\r\n1\r\n", "output": "0\r\n"}, {"input": "2 1 0\r\n1\r\n2\r\n", "output": "0\r\n"}, {"input": "1 2 1\r\n2 1\r\n", "output": "1\r\n2 1\r\n"}, {"input": "2 2 0\r\n2 1\r\n3 1\r\n", "output": "1\r\n1 2\r\n"}, {"input": "2 2 0\r\n2 1\r\n1 3\r\n", "output": "1\r\n1 2\r\n"}, {"input": "2 2 1\r\n2 1\r\n3 1\r\n", "output": "1\r\n2 1\r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(input_path) as f:
lines = f.read().splitlines()
n, m, k = map(int, lines[0].split())
arrays = [list(map(int, line.split())) for line in lines[1:n+1]]
try:
with open(submission_path) as f:
sub_lines = f.read().splitlines()
except:
print(0)
return
if not sub_lines:
print(0)
return
try:
p = int(sub_lines[0].strip())
if p < 0 or p > m * (m-1) // 2:
print(0)
return
except:
print(0)
return
swaps = []
for line in sub_lines[1:p+1]:
parts = line.strip().split()
if len(parts) != 2:
print(0)
return
try:
i = int(parts[0])
j = int(parts[1])
except:
print(0)
return
if i < 1 or i > m or j < 1 or j > m or i == j:
print(0)
return
swaps.append( (i-1, j-1) )
for arr in arrays:
current = arr.copy()
for i, j in swaps:
if current[i] > current[j]:
current[i], current[j] = current[j], current[i]
valid = True
if k == 0:
for x in range(m-1):
if current[x] > current[x+1]:
valid = False
break
else:
for x in range(m-1):
if current[x] < current[x+1]:
valid = False
break
if not valid:
print(0)
return
print(1)
if __name__ == "__main__":
main()
| true |
180/A
|
180
|
A
|
PyPy 3-64
|
TESTS
| 2 | 124 | 0 |
209285527
|
import sys
input = sys.stdin.readline
from collections import defaultdict, deque, Counter
from heapq import heappop, heappush
from bisect import bisect_left, bisect_right
from math import gcd
n,m = map(int,input().split())
a = [list(map(int,input().split())) for i in range(m)]
tot = 0
vac = []
use = set()
for i in range(m):
ni, ai = a[i][0], a[i][1:]
tot += ni
for j in range(ni):
use.add(ai[j])
for i in range(1,n+1):
if i not in use:
vac.append(i)
vac = vac[::-1]
ans = []
now = 1
d = defaultdict(int)
for i in range(m):
ni,ai = a[i][0], a[i][1:]
for j in range(ni):
if j > tot:
ai[j] = vac.pop()
ans.append((j,ai[j]))
d[now] = ai[j]
now += 1
v = [0]*(n+1)
for i in range(1,tot+1):
if v[i]: continue
ord = [i]
v[i] = 1
for i in range(tot-1):
if v[d[ord[-1]]]: continue
ord.append(d[ord[-1]])
v[ord[-1]] = 1
ord = ord[::-1]
ans.append((ord[0], tot+1))
for i in range(1, len(ord)):
ans.append((ord[i], ord[i-1]))
ans.append((tot+1, ord[-1]))
print(len(ans))
for i,j in ans:
print(i,j)
| 24 | 278 | 102,400 |
46822069
|
n, m = map(int, input().split())
mem = [-1] * 205
d = []
for i in range(m):
f = list(map(int, input().split()))[1:]
for j in f:
mem[j] = i
d.append(f)
free = -1
for i in range(1, n+1):
if mem[i] == -1:
free = i
break
res, cnt = [], 0
for x in range(m):
for i in range(len(d[x])):
cnt += 1
if d[x][i] == cnt:
continue
y = mem[cnt]
if y == -1:
res.append((d[x][i], cnt))
mem[d[x][i]] = -1
free = d[x][i]
d[x][i] = cnt
mem[cnt] = x
continue
for j in range(len(d[y])):
if d[y][j] == cnt:
res.append((cnt, free))
res.append((d[x][i], cnt))
d[y][j] = free
mem[free] = y
free = d[x][i]
mem[free] = -1
d[x][i] = cnt
mem[cnt] = x
print(len(res))
for (x, y) in res:
print(x, y)
|
Codeforces Round 116 (Div. 2, ACM-ICPC Rules)
|
ICPC
| 2,012 | 1 | 256 |
Defragmentation
|
In this problem you have to implement an algorithm to defragment your hard disk. The hard disk consists of a sequence of clusters, numbered by integers from 1 to n. The disk has m recorded files, the i-th file occupies clusters with numbers ai, 1, ai, 2, ..., ai, ni. These clusters are not necessarily located consecutively on the disk, but the order in which they are given corresponds to their sequence in the file (cluster ai, 1 contains the first fragment of the i-th file, cluster ai, 2 has the second fragment, etc.). Also the disc must have one or several clusters which are free from files.
You are permitted to perform operations of copying the contents of cluster number i to cluster number j (i and j must be different). Moreover, if the cluster number j used to keep some information, it is lost forever. Clusters are not cleaned, but after the defragmentation is complete, some of them are simply declared unusable (although they may possibly still contain some fragments of files).
Your task is to use a sequence of copy operations to ensure that each file occupies a contiguous area of memory. Each file should occupy a consecutive cluster section, the files must follow one after another from the beginning of the hard disk. After defragmentation all free (unused) clusters should be at the end of the hard disk. After defragmenting files can be placed in an arbitrary order. Clusters of each file should go consecutively from first to last. See explanatory examples in the notes.
Print the sequence of operations leading to the disk defragmentation. Note that you do not have to minimize the number of operations, but it should not exceed 2n.
|
The first line contains two integers n and m (1 ≤ n, m ≤ 200) — the number of clusters and the number of files, correspondingly. Next m lines contain descriptions of the files. The first number in the line is ni (ni ≥ 1), the number of clusters occupied by the i-th file. Then follow ni numbers ai, 1, ai, 2, ..., ai, ni (1 ≤ ai, j ≤ n). It is guaranteed that each cluster number occurs not more than once and $$\sum_{i=1}^{m} n_i < n$$, that is, there exists at least one unused cluster. Numbers on each line are separated by spaces.
|
In the first line print a single integer k (0 ≤ k ≤ 2n) — the number of operations needed to defragment the disk. Next k lines should contain the operations' descriptions as "i j" (copy the contents of the cluster number i to the cluster number j).
| null |
Let's say that a disk consists of 8 clusters and contains two files. The first file occupies two clusters and the second file occupies three clusters. Let's look at examples of correct and incorrect positions of files after defragmentation.
$$$$
Example 2: each file must occupy a contiguous area of memory.
Example 3: the order of files to each other is not important, at first the second file can be written, and then — the first one.
Example 4: violating the order of file fragments to each other is not allowed.
Example 5: unused clusters should be located at the end, and in this example the unused clusters are 3, 7, 8.
|
[{"input": "7 2\n2 1 2\n3 3 4 5", "output": "0"}, {"input": "7 2\n2 1 3\n3 2 4 5", "output": "3\n2 6\n3 2\n6 3"}]
| 1,800 |
["implementation"]
| 24 |
[{"input": "7 2\r\n2 1 2\r\n3 3 4 5\r\n", "output": "0\r\n"}, {"input": "7 2\r\n2 1 3\r\n3 2 4 5\r\n", "output": "3\r\n2 6\r\n3 2\r\n6 3\r\n"}, {"input": "2 1\r\n1 2\r\n", "output": "1\r\n2 1\r\n"}, {"input": "3 1\r\n2 3 1\r\n", "output": "2\r\n1 2\r\n3 1\r\n"}, {"input": "3 2\r\n1 3\r\n1 2\r\n", "output": "1\r\n3 1\r\n"}, {"input": "5 3\r\n1 2\r\n1 4\r\n1 5\r\n", "output": "3\r\n2 1\r\n4 2\r\n5 3\r\n"}, {"input": "7 3\r\n1 7\r\n2 6 5\r\n3 4 3 2\r\n", "output": "7\r\n7 1\r\n2 7\r\n6 2\r\n3 6\r\n5 3\r\n6 5\r\n7 6\r\n"}, {"input": "7 2\r\n3 1 3 5\r\n3 2 4 6\r\n", "output": "5\r\n2 7\r\n3 2\r\n5 3\r\n4 5\r\n7 4\r\n"}, {"input": "10 1\r\n5 7 4 6 9 2\r\n", "output": "7\r\n7 1\r\n2 3\r\n4 2\r\n3 4\r\n6 3\r\n4 5\r\n9 4\r\n"}, {"input": "7 2\r\n2 2 1\r\n3 3 4 5\r\n", "output": "3\r\n1 6\r\n2 1\r\n6 2\r\n"}, {"input": "7 2\r\n2 1 2\r\n3 4 5 6\r\n", "output": "3\r\n4 3\r\n5 4\r\n6 5\r\n"}, {"input": "20 5\r\n7 12 16 14 17 20 4 15\r\n2 7 8\r\n1 5\r\n5 3 6 18 11 2\r\n4 9 13 19 1\r\n", "output": "36\r\n1 10\r\n12 1\r\n2 12\r\n16 2\r\n3 16\r\n14 3\r\n4 14\r\n17 4\r\n5 17\r\n20 5\r\n6 20\r\n14 6\r\n7 14\r\n15 7\r\n8 15\r\n14 8\r\n9 14\r\n15 9\r\n10 15\r\n17 10\r\n11 17\r\n16 11\r\n12 16\r\n20 12\r\n13 20\r\n18 13\r\n14 18\r\n17 14\r\n15 17\r\n16 15\r\n18 16\r\n17 18\r\n20 17\r\n18 20\r\n19 18\r\n20 19\r\n"}, {"input": "20 10\r\n1 2\r\n2 14 11\r\n2 9 15\r\n2 16 8\r\n2 3 13\r\n3 17 12 6\r\n1 5\r\n1 7\r\n2 20 19\r\n1 1\r\n", "output": "25\r\n1 4\r\n2 1\r\n14 2\r\n3 10\r\n11 3\r\n4 11\r\n9 4\r\n5 9\r\n15 5\r\n6 14\r\n16 6\r\n7 15\r\n8 7\r\n10 8\r\n9 10\r\n13 9\r\n10 13\r\n17 10\r\n11 16\r\n12 11\r\n14 12\r\n15 14\r\n20 15\r\n16 17\r\n19 16\r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
# Read input
with open(input_path, 'r') as f:
lines = f.readlines()
n, m = map(int, lines[0].split())
files = []
S = set()
for line in lines[1:m+1]:
parts = list(map(int, line.split()))
ni = parts[0]
clusters = parts[1:]
files.append(clusters)
for c in clusters:
S.add(c)
sum_ni = sum(len(f) for f in files)
s = sum_ni
# Read submission's output
with open(submission_path, 'r') as f:
sub_lines = f.readlines()
if not sub_lines:
print(0)
return
k = int(sub_lines[0].strip())
if k > 2 * n or k < 0:
print(0)
return
ops = []
for line in sub_lines[1:k+1]:
try:
i, j = map(int, line.strip().split())
if i == j:
print(0)
return
ops.append((i, j))
except:
print(0)
return
# Simulate operations
arr = [0] * (n + 1) # 1-based
for j in range(1, n+1):
arr[j] = j
for i, j in ops:
if i < 1 or i > n or j < 1 or j > n:
print(0)
return
arr[j] = arr[i]
# Check first s clusters
final_order = arr[1:s+1]
# Check that all elements are in S and each exactly once
if len(final_order) != s:
print(0)
return
if set(final_order) != S:
print(0)
return
if len(set(final_order)) != s:
print(0)
return
# Build cluster info: map from cluster to (file_idx, pos_in_file)
cluster_info = {}
for file_idx, clusters in enumerate(files):
for pos, c in enumerate(clusters):
cluster_info[c] = (file_idx, pos)
# For each file, collect positions in final_order and check
file_sequences = {}
for pos_in_final, c in enumerate(final_order):
file_idx, pos_in_file = cluster_info[c]
if file_idx not in file_sequences:
file_sequences[file_idx] = []
file_sequences[file_idx].append( (pos_in_final, pos_in_file) )
# Check each file
for file_idx, seq in file_sequences.items():
clusters = files[file_idx]
ni = len(clusters)
# Check that all clusters are accounted for
if len(seq) != ni:
print(0)
return
# Compute start for each cluster and check they are the same
starts = [ pos_in_final - pos_in_file for (pos_in_final, pos_in_file) in seq ]
if len(set(starts)) != 1:
print(0)
return
start = starts[0]
# Check that the start is valid
if start < 0 or start + ni > s:
print(0)
return
# Check that the sequence of pos_in_final is start, start+1, ..., start+ni-1
expected_positions = list(range(start, start + ni))
actual_positions = [ pos_in_final for (pos_in_final, _) in seq ]
if actual_positions != expected_positions:
print(0)
return
print(1)
if __name__ == "__main__":
main()
| true |
628/E
|
628
|
E
|
PyPy 3-64
|
TESTS
| 6 | 202 | 9,318,400 |
175847605
|
from sys import stdin
input=lambda :stdin.readline()[:-1]
class segtree():
def __init__(self,init,func,ide):
self.n=len(init)
self.func=func
self.ide=ide
self.size=1<<(self.n-1).bit_length()
self.tree=[self.ide for i in range(2*self.size)]
for i in range(self.n):
self.tree[self.size+i]=init[i]
for i in range(self.size-1,0,-1):
self.tree[i]=self.func(self.tree[2*i], self.tree[2*i|1])
def update(self,k,x):
k+=self.size
self.tree[k]=x
k>>=1
while k:
self.tree[k]=self.func(self.tree[2*k],self.tree[k*2|1])
k>>=1
def get(self,i):
return self.tree[i+self.size]
def query(self,l,r):
l+=self.size
r+=self.size
l_res=self.ide
r_res=self.ide
while l<r:
if l&1:
l_res=self.func(l_res,self.tree[l])
l+=1
if r&1:
r-=1
r_res=self.func(self.tree[r],r_res)
l>>=1
r>>=1
return self.func(l_res,r_res)
def debug(self,s=10):
print([self.get(i) for i in range(min(self.n,s))])
class ordered_set:
def __init__(self,size):
self.inf=10**9
self.size=size
self.seg_cnt=segtree([0]*size,lambda x,y:x+y,0)
self.now=[]
def add(self,x):
self.seg_cnt.update(x,1)
self.now.append(x)
def remove(self,x):
self.seg_cnt.update(x,0)
def query(self,l,r):
return self.seg_cnt.query(l,r)
def remove_all(self):
for x in self.now:
self.seg_cnt.update(x,0)
self.now=[]
def calc(t):
m=len(t)
res=[0]*m
R=0
while R<m:
L=R
while R<m and t[R]=='z':
R+=1
while L<R:
res[L]=R-L
L+=1
R+=1
return res
h,w=map(int,input().split())
s=[]
for _ in range(h):
s.append(input())
right=[]
for i in range(h):
right.append(calc(s[i]))
left=[]
for i in range(h):
left.append(calc(s[i][::-1])[::-1])
ans=0
for i in range(w):
xy=[]
x,y=0,i
while 0<=y<w and 0<=x<h:
xy.append((x,y))
x+=1
y-=1
m=len(xy)
S=ordered_set(m)
rmv=[[] for i in range(m+1)]
for i in range(m):
for j in rmv[i]:
S.remove(j)
x,y=xy[i]
l=left[x][y]
if l!=0:
S.add(i)
rmv[min(m,i+l)].append(i)
r=right[x][y]
ans+=S.query(max(0,i-r+1),i+1)
else:
S.remove_all()
for i in range(1,h):
xy=[]
x,y=i,w-1
while 0<=y<w and 0<=x<h:
xy.append((x,y))
x+=1
y-=1
m=len(xy)
S=ordered_set(m)
rmv=[[] for i in range(m+1)]
for i in range(m):
for j in rmv[i]:
S.remove(j)
x,y=xy[i]
l=left[x][y]
if l!=0:
S.add(i)
rmv[min(m,i+l)].append(i)
r=right[x][y]
ans+=S.query(max(0,i-r),i+1)
else:
S.remove_all()
print(ans)
| 18 | 4,991 | 312,627,200 |
192747542
|
import sys
ni = lambda :int(input())
na = lambda :list(map(int,input().split()))
yes = lambda :print("yes");Yes = lambda :print("Yes");YES = lambda : print("YES")
no = lambda :print("no");No = lambda :print("No");NO = lambda : print("NO")
#######################################################################
# Binary Indexed Tree (Fenwick Tree)
# 0-indexed
class BIT:
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
self.el = [0]*(n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
assert 0 <= i < self.n
i = i+1
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def set(self, i, x):
assert 0 <= i <= self.n
self.add(i,x-self.get(i))
def get(self, i, j=None):# j=Noneのときiを取得, [i, j)の和を取得
if j is None:
return self.el[i+1]
return self.sum(j) - self.sum(i)
from collections import defaultdict
def solve(f):
n = len(f)
if len(f) == 0:
return 0
a,b = zip(*f)
d = defaultdict(list)
bit = BIT(n)
for i in range(n):
d[a[i] + i].append(i)
for i in range(n):
bit.add(i, 1)
res = 0
for i in range(n):
for j in d[i]:
bit.add(j, -1)
#print(n,0,b[i]-i-1)
res += bit.get(i-b[i]+1, i+1)
#print(a,b,res)
return res
h,w = na()
c = [input() for i in range(h)]
"""h = 1000
w = 3000
from random import randint
c = [[["z","."][randint(0,1)]for j in range(w)] for i in range(h)]"""
m = min(h, w)
ans = 0
f = [[w + 1 for i in range(w)]for j in range(h)]
for i in range(h):
if c[i][0] == "z":
f[i][0] = 0
for i in range(h):
for j in range(1, w):
if c[i][j] == "z":
f[i][j] = min(j, f[i][j-1])
g = [[-1 for i in range(w)]for j in range(h)]
for i in range(h):
if c[i][-1] == "z":
g[i][-1] = w-1
for i in range(h):
for j in range(w-2,-1,-1):
if c[i][j] == "z":
g[i][j] = max(j, g[i][j+1])
for t in range(h+w-1):
sy = min(t, w-1)
sx = t-sy
x,y = sx,sy
i = 0
l = 0
ff = []
while sx < h and sy >= 0:
if c[sx][sy] == "z":
ff.append((sy-f[sx][sy]+1, g[sx][sy]-sy+1))
else:
ans += solve(ff)
ff = []
sx += 1
sy -= 1
i += 1
ans += solve(ff)
print(ans)
|
Educational Codeforces Round 8
|
ICPC
| 2,016 | 5 | 512 |
Zbazi in Zeydabad
|
A tourist wants to visit country Zeydabad for Zbazi (a local game in Zeydabad).
The country Zeydabad is a rectangular table consisting of n rows and m columns. Each cell on the country is either 'z' or '.'.
The tourist knows this country is named Zeydabad because there are lots of ''Z-pattern"s in the country. A ''Z-pattern" is a square which anti-diagonal is completely filled with 'z' and its upper and lower rows are also completely filled with 'z'. All other cells of a square can be arbitrary.
Note that a ''Z-pattern" can consist of only one cell (see the examples).
So he wants to count the number of ''Z-pattern"s in the country (a necessary skill for Zbazi).
Now your task is to help tourist with counting number of ''Z-pattern"s.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
|
The first line contains two integers n, m (1 ≤ n, m ≤ 3000) — the number of rows and columns respectively.
Each of the next n lines contains m characters 'z' or '.' — the description of Zeydabad.
|
Print the only integer a — the number of ''Z-pattern"s in Zeydabad.
| null | null |
[{"input": "4 4\nzzzz\nzzz.\n.z..\nzzzz", "output": "16"}, {"input": "1 4\nz.z.", "output": "2"}, {"input": "2 2\nzz\nzz", "output": "5"}]
| 2,300 |
["data structures", "implementation"]
| 18 |
[{"input": "4 4\r\nzzzz\r\nzzz.\r\n.z..\r\nzzzz\r\n", "output": "16\r\n"}, {"input": "1 4\r\nz.z.\r\n", "output": "2\r\n"}, {"input": "2 2\r\nzz\r\nzz\r\n", "output": "5\r\n"}]
| false |
stdio
| null | true |
878/E
|
878
|
E
|
Python 3
|
TESTS
| 3 | 61 | 5,529,600 |
32998344
|
#x+2y on string find max value
n, q = map(int, input().split(" "))
boardm = [int(i) for i in input().split(" ")]
memo = [[0 for _ in range(n)] for i in range(n)]
# x,y,answer
sub = 10**9 + 7
for cases in range(q):
li, lj = map(int, input().split(" "))
li -= 1
lj -= 1
board = boardm[li:lj+1]
dp = [0,0,0]
dp[0] = board[0]
dp[1] = board[1]
dp[2] = dp[0]+ (2*dp[1])
for _ in range(2,len(board)):
if board[_] <0:
dp[2] = dp[2] + 2*board[_]
else:
dp[2] = dp[0] + 2*(dp[1] + 2*board[_])
dp[0], dp[1] = dp[1], board[_]
print(dp[2]%sub)
| 55 | 999 | 80,281,600 |
303302080
|
import sys
MOD = 10**9 + 7
INF = 2 * 10**9 + 5
def upd(a):
a += (a >> 31) & MOD
return a
def init(n):
_2 = [1] * (n + 1)
for i in range(1, n + 1):
_2[i] = (_2[i-1] << 1) % MOD
return _2
def find(x, fa):
if fa[x] != x:
fa[x] = find(fa[x], fa)
return fa[x]
def merge(x, y, fa, L, s, f, _2):
fa[y] = x
if (L[x] > 30 and s[x] > 0) or (s[x] + (s[y] << L[x]) >= INF):
s[x] = INF
else:
s[x] += s[y] << L[x]
f[x] = (f[x] + f[y] * _2[L[x]]) % MOD
L[x] += L[y]
def calc(l, r, pr, _2):
return (pr[l] - pr[r+1] * _2[r-l+1] % MOD + MOD) % MOD
def main():
input = sys.stdin.read
data = input().split()
idx = 0
n = int(data[idx])
m = int(data[idx+1])
idx += 2
a = [0] * (n + 1)
for i in range(1, n+1):
a[i] = int(data[idx])
idx += 1
_2 = init(n)
pr = [0] * (n + 2)
for i in range(n, 0, -1):
pr[i] = ((pr[i+1] << 1) + a[i] + MOD) % MOD
fa = [i for i in range(n+1)]
L = [1] * (n+1)
f = [0] * (n+1)
s = [0] * (n+1)
for i in range(1, n+1):
f[i] = s[i] = a[i]
vec = [[] for _ in range(n+1)]
for i in range(1, m+1):
l = int(data[idx])
r = int(data[idx+1])
idx += 2
vec[r].append((l, i))
ans = [0] * (m+1)
ps = [0] * (n+1)
for i in range(1, n+1):
while find(i, fa) > 1 and s[find(i, fa)] >= 0:
merge(find(find(i, fa)-1, fa), find(i, fa), fa, L, s, f, _2)
ps[find(i, fa)] = (ps[find(find(i, fa)-1, fa)] + f[find(i, fa)]) % MOD
for q in vec[i]:
l, id = q
ans[id] = ((ps[find(i, fa)] - ps[find(l, fa)] + MOD) * 2 + calc(l, find(l, fa) + L[find(l, fa)] - 1, pr, _2) + MOD) % MOD
for i in range(1, m+1):
print(ans[i])
if __name__ == "__main__":
main()
|
Codeforces Round 443 (Div. 1)
|
CF
| 2,017 | 2 | 512 |
Numbers on the blackboard
|
A sequence of n integers is written on a blackboard. Soon Sasha will come to the blackboard and start the following actions: let x and y be two adjacent numbers (x before y), then he can remove them and write x + 2y instead of them. He will perform these operations until one number is left. Sasha likes big numbers and will get the biggest possible number.
Nikita wants to get to the blackboard before Sasha and erase some of the numbers. He has q options, in the option i he erases all numbers to the left of the li-th number and all numbers to the right of ri-th number, i. e. all numbers between the li-th and the ri-th, inclusive, remain on the blackboard. For each of the options he wants to know how big Sasha's final number is going to be. This number can be very big, so output it modulo 109 + 7.
|
The first line contains two integers n and q (1 ≤ n, q ≤ 105) — the number of integers on the blackboard and the number of Nikita's options.
The next line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the sequence on the blackboard.
Each of the next q lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n), describing Nikita's options.
|
For each option output Sasha's result modulo 109 + 7.
| null |
In the second sample Nikita doesn't erase anything. Sasha first erases the numbers 1 and 2 and writes 5. Then he erases 5 and -3 and gets -1. -1 modulo 109 + 7 is 109 + 6.
|
[{"input": "3 3\n1 2 3\n1 3\n1 2\n2 3", "output": "17\n5\n8"}, {"input": "3 1\n1 2 -3\n1 3", "output": "1000000006"}, {"input": "4 2\n1 1 1 -1\n1 4\n3 4", "output": "5\n1000000006"}]
| 3,300 |
["combinatorics", "dp"]
| 55 |
[{"input": "3 3\r\n1 2 3\r\n1 3\r\n1 2\r\n2 3\r\n", "output": "17\r\n5\r\n8\r\n"}, {"input": "3 1\r\n1 2 -3\r\n1 3\r\n", "output": "1000000006\r\n"}, {"input": "4 2\r\n1 1 1 -1\r\n1 4\r\n3 4\r\n", "output": "5\r\n1000000006\r\n"}, {"input": "4 1\r\n1 1 -3 1\r\n1 4\r\n", "output": "1\r\n"}, {"input": "1 1\r\n1000000000\r\n1 1\r\n", "output": "1000000000\r\n"}, {"input": "1 1\r\n-1000000000\r\n1 1\r\n", "output": "7\r\n"}, {"input": "2 3\r\n0 0\r\n1 2\r\n1 1\r\n2 2\r\n", "output": "0\r\n0\r\n0\r\n"}, {"input": "2 3\r\n1000000000 1000000000\r\n1 2\r\n1 1\r\n2 2\r\n", "output": "999999986\r\n1000000000\r\n1000000000\r\n"}, {"input": "10 10\r\n-7 4 4 -5 2 3 -9 7 -4 -2\r\n8 10\r\n8 9\r\n2 3\r\n2 9\r\n2 3\r\n7 8\r\n1 3\r\n2 6\r\n6 8\r\n3 3\r\n", "output": "1000000002\r\n1000000006\r\n12\r\n208\r\n12\r\n5\r\n17\r\n56\r\n13\r\n4\r\n"}, {"input": "10 10\r\n593536087 56559483 -439122178 -126803734 606390399 -809361217 444436245 71742850 -477364598 -818526589\r\n5 9\r\n5 7\r\n5 5\r\n1 9\r\n5 10\r\n2 2\r\n3 10\r\n4 5\r\n2 4\r\n4 4\r\n", "output": "384626549\r\n765412945\r\n606390399\r\n410699067\r\n747573385\r\n56559483\r\n72910946\r\n85977057\r\n924707673\r\n873196273\r\n"}, {"input": "10 10\r\n-616555628 133372392 -749502876 499498544 927177575 -838173566 -139786799 -676011158 155638259 102225904\r\n1 3\r\n3 3\r\n1 2\r\n2 10\r\n5 7\r\n4 5\r\n6 6\r\n8 9\r\n3 5\r\n7 7\r\n", "output": "151183418\r\n250497131\r\n650189163\r\n270536548\r\n971256859\r\n353853680\r\n161826441\r\n635265367\r\n958204491\r\n860213208\r\n"}, {"input": "10 1\r\n-11 81 -4 79 44 -11 -50 26 -38 13\r\n4 10\r\n", "output": "129\r\n"}, {"input": "10 1\r\n-858350203 62991893 757167826 -643742467 -122005341 210910071 973749788 -554405426 91646398 811009699\r\n1 6\r\n", "output": "208079143\r\n"}, {"input": "101 1\r\n-2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 -2 -1 -1 -1 1 1000000000\r\n1 101\r\n", "output": "165401054\r\n"}, {"input": "108 1\r\n-1 -1 -1 -2 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 1 -2 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 1 1000000000\r\n1 108\r\n", "output": "171334758\r\n"}]
| false |
stdio
| null | true |
615/B
|
615
|
B
|
PyPy 3-64
|
TESTS
| 2 | 62 | 0 |
190140323
|
from collections import defaultdict
n, m = map(int, input().split())
adj = defaultdict(list)
for i in range(m):
u, v = map(int, input().split())
adj[u].append(v)
adj[v].append(u)
tested = set()
best = 0
for v in adj:
if v in tested: continue
seen = set()
s = [v]
while s:
node = s.pop()
seen.add(node)
tested.add(node)
start_length = len(s)
for nxt in adj[node]:
if nxt > node and nxt not in seen:
seen.add(nxt)
s.append(nxt)
tested.add(nxt)
if start_length == len(s):
best = max(best, len(seen) * len(adj[node]))
seen.remove(node)
print(best)
| 60 | 1,075 | 15,257,600 |
101015468
|
n, m = map(int, input().split())
G = [[] for i in range(n)]
for i in range(m):
a, b = map(int, input().split())
G[a-1].append(b-1)
G[b-1].append(a-1)
max_dist = 0
dist = [0]*n
for v in range(n):
dist[v] = 1
for u in G[v]:
if (u < v):
dist[v] = max(dist[v], dist[u] + 1);
max_dist = max(max_dist, dist[v] * len(G[v]));
print(max_dist)
|
Codeforces Round 338 (Div. 2)
|
CF
| 2,016 | 3 | 256 |
Longtail Hedgehog
|
This Christmas Santa gave Masha a magic picture and a pencil. The picture consists of n points connected by m segments (they might cross in any way, that doesn't matter). No two segments connect the same pair of points, and no segment connects the point to itself. Masha wants to color some segments in order paint a hedgehog. In Mashas mind every hedgehog consists of a tail and some spines. She wants to paint the tail that satisfies the following conditions:
1. Only segments already presented on the picture can be painted;
2. The tail should be continuous, i.e. consists of some sequence of points, such that every two neighbouring points are connected by a colored segment;
3. The numbers of points from the beginning of the tail to the end should strictly increase.
Masha defines the length of the tail as the number of points in it. Also, she wants to paint some spines. To do so, Masha will paint all the segments, such that one of their ends is the endpoint of the tail. Masha defines the beauty of a hedgehog as the length of the tail multiplied by the number of spines. Masha wants to color the most beautiful hedgehog. Help her calculate what result she may hope to get.
Note that according to Masha's definition of a hedgehog, one segment may simultaneously serve as a spine and a part of the tail (she is a little girl after all). Take a look at the picture for further clarifications.
|
First line of the input contains two integers n and m(2 ≤ n ≤ 100 000, 1 ≤ m ≤ 200 000) — the number of points and the number segments on the picture respectively.
Then follow m lines, each containing two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the numbers of points connected by corresponding segment. It's guaranteed that no two segments connect the same pair of points.
|
Print the maximum possible value of the hedgehog's beauty.
| null |
The picture below corresponds to the first sample. Segments that form the hedgehog are painted red. The tail consists of a sequence of points with numbers 1, 2 and 5. The following segments are spines: (2, 5), (3, 5) and (4, 5). Therefore, the beauty of the hedgehog is equal to 3·3 = 9.
|
[{"input": "8 6\n4 5\n3 5\n2 5\n1 2\n2 8\n6 7", "output": "9"}, {"input": "4 6\n1 2\n1 3\n1 4\n2 3\n2 4\n3 4", "output": "12"}]
| 1,600 |
["dp", "graphs"]
| 60 |
[{"input": "8 6\r\n4 5\r\n3 5\r\n2 5\r\n1 2\r\n2 8\r\n6 7\r\n", "output": "9\r\n"}, {"input": "4 6\r\n1 2\r\n1 3\r\n1 4\r\n2 3\r\n2 4\r\n3 4\r\n", "output": "12\r\n"}, {"input": "5 7\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n", "output": "9\r\n"}, {"input": "5 9\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n1 5\r\n2 5\r\n", "output": "16\r\n"}, {"input": "10 10\r\n6 3\r\n2 9\r\n9 4\r\n4 5\r\n10 3\r\n8 3\r\n10 5\r\n7 6\r\n1 4\r\n6 8\r\n", "output": "8\r\n"}, {"input": "100 50\r\n66 3\r\n92 79\r\n9 44\r\n84 45\r\n30 63\r\n30 20\r\n33 86\r\n8 83\r\n40 75\r\n7 36\r\n91 4\r\n76 88\r\n77 76\r\n28 27\r\n6 52\r\n41 57\r\n8 23\r\n34 75\r\n50 15\r\n86 68\r\n36 98\r\n30 84\r\n37 62\r\n22 4\r\n6 45\r\n72 80\r\n98 74\r\n78 84\r\n1 54\r\n99 27\r\n84 91\r\n78 7\r\n80 61\r\n67 48\r\n51 52\r\n36 72\r\n97 87\r\n25 17\r\n20 80\r\n20 39\r\n72 5\r\n21 77\r\n48 1\r\n63 21\r\n92 45\r\n34 93\r\n28 84\r\n3 91\r\n56 99\r\n7 53\r\n", "output": "15\r\n"}, {"input": "5 8\r\n1 3\r\n2 4\r\n4 5\r\n5 3\r\n2 1\r\n1 4\r\n3 2\r\n1 5\r\n", "output": "12\r\n"}, {"input": "2 1\r\n1 2\r\n", "output": "2\r\n"}, {"input": "10 9\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n1 6\r\n1 7\r\n1 8\r\n1 9\r\n1 10\r\n", "output": "9\r\n"}, {"input": "5 4\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n", "output": "4\r\n"}, {"input": "6 5\r\n1 2\r\n1 3\r\n1 4\r\n1 5\r\n1 6\r\n", "output": "5\r\n"}]
| false |
stdio
| null | true |
30/C
|
30
|
C
|
PyPy 3
|
TESTS
| 3 | 310 | 0 |
61403735
|
if __name__ == '__main__':
n = int(input())
targets = [input() for _ in range(n)]
targets = [line.split() for line in targets]
targets = [(int(x), int(y), int(t), float(p)) for x, y, t, p in targets]
if n == 1:
print(targets[0][3])
else:
targets = sorted(targets, key=lambda target: target[2])
e = 0
mp = targets[0][3]
for i in range(1, n):
if targets[i][2] == targets[i - 1][2]:
mp = max(mp, targets[i][3])
else:
e += mp
mp = targets[i][3]
print(e + mp)
| 50 | 840 | 2,560,000 |
101254345
|
##########################################################
from collections import Counter
def nCk(n, k):
res = 1
for i in range(1, k + 1):
res = res * (n - i + 1) // i
return res
import math
inf=10**20
n=int(input())
c=[]
dp=[0]*(n+1)
for i in range(n):
x,y, t,p = map(float, input().split())
c.append([int(x),int(y),int(t),p])
c.sort(key=lambda x:x[2])
for i in range(n):
dp[i]=c[i][3]
for j in range(i):
if (c[i][0]-c[j][0])**2+(c[i][1]-c[j][1])**2 <= (c[i][2]-c[j][2])**2:
dp[i]=max(dp[i],dp[j]+c[i][-1])
print(max(dp))
|
Codeforces Beta Round 30 (Codeforces format)
|
CF
| 2,010 | 2 | 256 |
Shooting Gallery
|
One warm and sunny day king Copa decided to visit the shooting gallery, located at the Central Park, and try to win the main prize — big pink plush panda. The king is not good at shooting, so he invited you to help him.
The shooting gallery is an infinite vertical plane with Cartesian coordinate system on it. The targets are points on this plane. Each target is described by it's coordinates xi, and yi, by the time of it's appearance ti and by the number pi, which gives the probability that Copa hits this target if he aims at it.
A target appears and disappears instantly, so Copa can hit the target only if at the moment ti his gun sight aimed at (xi, yi). Speed of movement of the gun sight on the plane is equal to 1. Copa knows all the information about the targets beforehand (remember, he is a king!). He wants to play in the optimal way, which maximizes the expected value of the amount of hit targets. He can aim at any target at the moment 0.
|
The first line contains integer n (1 ≤ n ≤ 1000) — amount of targets in the shooting gallery. Then n lines follow, each describing one target. Each description consists of four numbers xi, yi, ti, pi (where xi, yi, ti — integers, - 1000 ≤ xi, yi ≤ 1000, 0 ≤ ti ≤ 109, real number pi is given with no more than 6 digits after the decimal point, 0 ≤ pi ≤ 1). No two targets may be at the same point.
|
Output the maximum expected value of the amount of targets that was shot by the king. Your answer will be accepted if it differs from the correct answer by not more than 10 - 6.
| null | null |
[{"input": "1\n0 0 0 0.5", "output": "0.5000000000"}, {"input": "2\n0 0 0 0.6\n5 0 5 0.7", "output": "1.3000000000"}]
| 1,800 |
["dp", "probabilities"]
| 50 |
[{"input": "1\r\n0 0 0 0.5\r\n", "output": "0.5000000000\r\n"}, {"input": "2\r\n0 0 0 0.6\r\n5 0 5 0.7\r\n", "output": "1.3000000000\r\n"}, {"input": "1\r\n-5 2 3 0.886986\r\n", "output": "0.8869860000\r\n"}, {"input": "4\r\n10 -7 14 0.926305\r\n-7 -8 12 0.121809\r\n-7 7 14 0.413446\r\n3 -8 6 0.859061\r\n", "output": "1.7853660000\r\n"}, {"input": "5\r\n-2 -2 34 0.127276\r\n5 -5 4 0.459998\r\n10 3 15 0.293766\r\n1 -3 7 0.089869\r\n-4 -7 11 0.772515\r\n", "output": "0.8997910000\r\n"}, {"input": "5\r\n2 5 1 0.955925\r\n9 -9 14 0.299977\r\n0 1 97 0.114582\r\n-4 -2 66 0.561033\r\n0 -10 75 0.135937\r\n", "output": "1.7674770000\r\n"}, {"input": "10\r\n-4 7 39 0.921693\r\n3 -1 50 0.111185\r\n-2 -8 27 0.976475\r\n-9 -2 25 0.541029\r\n6 -4 21 0.526054\r\n-7 2 19 0.488637\r\n-6 -5 50 0.819011\r\n-7 3 39 0.987596\r\n-3 -8 16 0.685997\r\n4 10 1 0.246686\r\n", "output": "3.0829590000\r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(output_path, 'r') as f:
correct_line = f.readline().strip()
try:
correct = float(correct_line)
except:
print(0)
return
with open(submission_path, 'r') as f:
sub_line = f.readline().strip()
try:
sub = float(sub_line)
except:
print(0)
return
if abs(correct - sub) <= 1e-6 + 1e-12: # Adding small epsilon for floating point errors
print(1)
else:
print(0)
if __name__ == "__main__":
main()
| true |
30/C
|
30
|
C
|
Python 3
|
TESTS
| 3 | 124 | 7,065,600 |
123911717
|
import math
from copy import deepcopy
n = int(input())
lst = []
for i in range(n):
lst.append(list(map(eval, input().split())))
res = [[0]]
for i in range(1, n):
for j in range(len(res)):
r = deepcopy(res[j])
d = math.sqrt((lst[i][0]-lst[res[j][-1]][0])**2 +
(lst[i][1]-lst[res[j][-1]][1])**2)
t = lst[i][2]-lst[res[j][-1]][2]
if d <= t:
r.append(i)
res.append(r)
max = 0
for i in res:
sum = 0
for j in i:
sum += lst[j][3]
if sum >= max:
max = sum
print(max)
| 50 | 1,746 | 0 |
7284138
|
def is_reachable(from_state, target):
return (from_state[0]-target[0])**2 + (from_state[1]-target[1])**2 <= (target[2] - from_state[2])**2
num_iter = int(input())
targets = sorted([list(map(float, input().strip().split(' '))) for dummy in range(0, num_iter)], key=lambda single_target: single_target[2])
states = []
for i, target in enumerate(targets):
states.append(target[3])
for j in range(i):
if is_reachable(targets[j], target):
score_estimate = states[j] + target[3]
if (states[i] < score_estimate):
states[i] = score_estimate
max_score = max(states)
print(max_score)
|
Codeforces Beta Round 30 (Codeforces format)
|
CF
| 2,010 | 2 | 256 |
Shooting Gallery
|
One warm and sunny day king Copa decided to visit the shooting gallery, located at the Central Park, and try to win the main prize — big pink plush panda. The king is not good at shooting, so he invited you to help him.
The shooting gallery is an infinite vertical plane with Cartesian coordinate system on it. The targets are points on this plane. Each target is described by it's coordinates xi, and yi, by the time of it's appearance ti and by the number pi, which gives the probability that Copa hits this target if he aims at it.
A target appears and disappears instantly, so Copa can hit the target only if at the moment ti his gun sight aimed at (xi, yi). Speed of movement of the gun sight on the plane is equal to 1. Copa knows all the information about the targets beforehand (remember, he is a king!). He wants to play in the optimal way, which maximizes the expected value of the amount of hit targets. He can aim at any target at the moment 0.
|
The first line contains integer n (1 ≤ n ≤ 1000) — amount of targets in the shooting gallery. Then n lines follow, each describing one target. Each description consists of four numbers xi, yi, ti, pi (where xi, yi, ti — integers, - 1000 ≤ xi, yi ≤ 1000, 0 ≤ ti ≤ 109, real number pi is given with no more than 6 digits after the decimal point, 0 ≤ pi ≤ 1). No two targets may be at the same point.
|
Output the maximum expected value of the amount of targets that was shot by the king. Your answer will be accepted if it differs from the correct answer by not more than 10 - 6.
| null | null |
[{"input": "1\n0 0 0 0.5", "output": "0.5000000000"}, {"input": "2\n0 0 0 0.6\n5 0 5 0.7", "output": "1.3000000000"}]
| 1,800 |
["dp", "probabilities"]
| 50 |
[{"input": "1\r\n0 0 0 0.5\r\n", "output": "0.5000000000\r\n"}, {"input": "2\r\n0 0 0 0.6\r\n5 0 5 0.7\r\n", "output": "1.3000000000\r\n"}, {"input": "1\r\n-5 2 3 0.886986\r\n", "output": "0.8869860000\r\n"}, {"input": "4\r\n10 -7 14 0.926305\r\n-7 -8 12 0.121809\r\n-7 7 14 0.413446\r\n3 -8 6 0.859061\r\n", "output": "1.7853660000\r\n"}, {"input": "5\r\n-2 -2 34 0.127276\r\n5 -5 4 0.459998\r\n10 3 15 0.293766\r\n1 -3 7 0.089869\r\n-4 -7 11 0.772515\r\n", "output": "0.8997910000\r\n"}, {"input": "5\r\n2 5 1 0.955925\r\n9 -9 14 0.299977\r\n0 1 97 0.114582\r\n-4 -2 66 0.561033\r\n0 -10 75 0.135937\r\n", "output": "1.7674770000\r\n"}, {"input": "10\r\n-4 7 39 0.921693\r\n3 -1 50 0.111185\r\n-2 -8 27 0.976475\r\n-9 -2 25 0.541029\r\n6 -4 21 0.526054\r\n-7 2 19 0.488637\r\n-6 -5 50 0.819011\r\n-7 3 39 0.987596\r\n-3 -8 16 0.685997\r\n4 10 1 0.246686\r\n", "output": "3.0829590000\r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(output_path, 'r') as f:
correct_line = f.readline().strip()
try:
correct = float(correct_line)
except:
print(0)
return
with open(submission_path, 'r') as f:
sub_line = f.readline().strip()
try:
sub = float(sub_line)
except:
print(0)
return
if abs(correct - sub) <= 1e-6 + 1e-12: # Adding small epsilon for floating point errors
print(1)
else:
print(0)
if __name__ == "__main__":
main()
| true |
877/F
|
877
|
F
|
PyPy 3
|
TESTS
| 2 | 77 | 0 |
198658362
|
import sys
readline=sys.stdin.readline
from collections import defaultdict
def Mo(N,Q,query):
D=max(1,int(N/Q**.5)//4)
mo=[[] for d in range((N+D-1)//D+1)]
for q,(l,r) in enumerate(query):
mo[r//D].append((l,r,q))
retu=[]
for d in range((N+D-1)//D+1):
retu+=sorted(mo[d],reverse=d%2)
return retu
N,K=map(int,readline().split())
T=list(map(int,readline().split()))
A=list(map(int,readline().split()))
for i in range(N):
if T[i]==2:
A[i]=-A[i]
A=[0]+A
for i in range(1,N+1):
A[i]+=A[i-1]
query=[]
Q=int(readline())
for q in range(Q):
l,r=map(int,readline().split())
l-=1
query.append((l,r))
L,R=0,0
ans=0
cnt=defaultdict(int)
cnt[0]=1
ans_lst=[None]*Q
for l,r,q in Mo(N,Q,query):
while l<L:
L-=1
ans+=cnt[A[L]+K]
cnt[A[L]]+=1
while R<r:
R+=1
ans+=cnt[A[R]-K]
cnt[A[R]]+=1
while L<l:
cnt[A[L]]+=1
ans-=cnt[A[L]+K]
L+=1
while r<R:
cnt[A[R]]-=1
ans-=cnt[A[R]]-K
R-=1
ans_lst[q]=ans
print(*ans_lst,sep="\n")
| 78 | 358 | 28,160,000 |
221593503
|
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def f(u, v, w):
return (u * m + v) * m + w
n, k = map(int, input().split())
t = list(map(int, input().split()))
a = list(map(int, input().split()))
u = [0] * (n + 1)
for i in range(n):
x = a[i] if t[i] & 1 else -a[i]
u[i + 1] = u[i] + x
i = 0
d = dict()
v = []
for j in range(n + 1):
if not u[j] in d:
d[u[j]] = len(v)
v.append(u[j])
u[j] = d[u[j]]
z = len(v)
c1, c2 = [z] * z, [z] * z
for i in range(z):
if v[i] + k in d:
c1[i] = d[v[i] + k]
if v[i] - k in d:
c2[i] = d[v[i] - k]
q = int(input())
l0, r0 = [0] * q, [0] * q
m1 = 246
m2 = n // m1 + 1
m = max(n, q)
c = [0] * (m2 + 1)
q0 = [0] * q
for i in range(q):
l, r = map(int, input().split())
l0[i], r0[i] = l - 1, r
x = (l - 1) // m1
c[x + 1] += 1
r1 = r if not x & 1 else n - r - 1
q0[i] = f(x, r1, i)
for i in range(1, m2 + 1):
c[i] += c[i - 1]
q0.sort()
l, r = 0, 0
cnt, ans = [0] * (z + 1), [0] * q
cnt[0] = 1
ans0 = 0
for i in range(m2):
for j in range(c[i], c[i + 1]):
k = q0[j] % q
l1, r1 = l0[k], r0[k]
while l1 < l:
l -= 1
ans0 += cnt[c1[u[l]]]
cnt[u[l]] += 1
while r < r1:
r += 1
ans0 += cnt[c2[u[r]]]
cnt[u[r]] += 1
while l < l1:
cnt[u[l]] -= 1
ans0 -= cnt[c1[u[l]]]
l += 1
while r1 < r:
cnt[u[r]] -= 1
ans0 -= cnt[c2[u[r]]]
r -= 1
ans[k] = ans0
sys.stdout.write("\n".join(map(str, ans)))
|
Codeforces Round 442 (Div. 2)
|
CF
| 2,017 | 2 | 256 |
Ann and Books
|
In Ann's favorite book shop are as many as n books on math and economics. Books are numbered from 1 to n. Each of them contains non-negative number of problems.
Today there is a sale: any subsegment of a segment from l to r can be bought at a fixed price.
Ann decided that she wants to buy such non-empty subsegment that the sale operates on it and the number of math problems is greater than the number of economics problems exactly by k. Note that k may be positive, negative or zero.
Unfortunately, Ann is not sure on which segment the sale operates, but she has q assumptions. For each of them she wants to know the number of options to buy a subsegment satisfying the condition (because the time she spends on choosing depends on that).
Currently Ann is too busy solving other problems, she asks you for help. For each her assumption determine the number of subsegments of the given segment such that the number of math problems is greaten than the number of economics problems on that subsegment exactly by k.
|
The first line contains two integers n and k (1 ≤ n ≤ 100 000, - 109 ≤ k ≤ 109) — the number of books and the needed difference between the number of math problems and the number of economics problems.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 2), where ti is 1 if the i-th book is on math or 2 if the i-th is on economics.
The third line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109), where ai is the number of problems in the i-th book.
The fourth line contains a single integer q (1 ≤ q ≤ 100 000) — the number of assumptions.
Each of the next q lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n) describing the i-th Ann's assumption.
|
Print q lines, in the i-th of them print the number of subsegments for the i-th Ann's assumption.
| null |
In the first sample Ann can buy subsegments [1;1], [2;2], [3;3], [2;4] if they fall into the sales segment, because the number of math problems is greater by 1 on them that the number of economics problems. So we should count for each assumption the number of these subsegments that are subsegments of the given segment.
Segments [1;1] and [2;2] are subsegments of [1;2].
Segments [1;1], [2;2] and [3;3] are subsegments of [1;3].
Segments [1;1], [2;2], [3;3], [2;4] are subsegments of [1;4].
Segment [3;3] is subsegment of [3;4].
|
[{"input": "4 1\n1 1 1 2\n1 1 1 1\n4\n1 2\n1 3\n1 4\n3 4", "output": "2\n3\n4\n1"}, {"input": "4 0\n1 2 1 2\n0 0 0 0\n1\n1 4", "output": "10"}]
| 2,300 |
["data structures", "flows", "hashing"]
| 78 |
[{"input": "4 1\r\n1 1 1 2\r\n1 1 1 1\r\n4\r\n1 2\r\n1 3\r\n1 4\r\n3 4\r\n", "output": "2\r\n3\r\n4\r\n1\r\n"}, {"input": "4 0\r\n1 2 1 2\r\n0 0 0 0\r\n1\r\n1 4\r\n", "output": "10\r\n"}, {"input": "10 10\r\n2 1 1 1 1 1 1 1 1 2\r\n0 10 10 0 0 10 10 10 10 0\r\n10\r\n4 10\r\n3 7\r\n9 9\r\n2 9\r\n10 10\r\n5 5\r\n2 2\r\n6 8\r\n3 4\r\n1 3\r\n", "output": "7\r\n7\r\n1\r\n10\r\n0\r\n0\r\n1\r\n3\r\n2\r\n3\r\n"}, {"input": "10 -10\r\n1 2 1 2 1 1 2 2 2 1\r\n7 7 10 3 7 10 6 8 0 1\r\n10\r\n2 6\r\n10 10\r\n6 9\r\n5 8\r\n7 10\r\n2 7\r\n2 9\r\n2 7\r\n5 6\r\n2 8\r\n", "output": "0\r\n0\r\n0\r\n0\r\n0\r\n0\r\n0\r\n0\r\n0\r\n0\r\n"}, {"input": "10 10\r\n1 1 1 1 1 2 1 2 1 2\r\n7 10 2 5 0 1 8 10 1 8\r\n10\r\n4 5\r\n1 3\r\n6 7\r\n8 10\r\n5 10\r\n1 8\r\n5 6\r\n1 5\r\n2 8\r\n9 10\r\n", "output": "0\r\n1\r\n0\r\n0\r\n0\r\n1\r\n0\r\n1\r\n1\r\n0\r\n"}, {"input": "2 0\r\n1 2\r\n43 43\r\n3\r\n1 2\r\n2 2\r\n1 1\r\n", "output": "1\r\n0\r\n0\r\n"}]
| false |
stdio
| null | true |
856/A
|
856
|
A
|
PyPy 3
|
TESTS
| 3 | 124 | 2,355,200 |
108443168
|
for _ in range(int(input())):
n = int(input())
b = list(map(int, input(). split()))
print('YES')
m = max(b) - min(b)
k = [i for i in range(max(b), n * (m + 1) + max(b), m + 1)]
print(*k)
| 11 | 312 | 4,300,800 |
30833172
|
d = [-1] * 1000001
for t in range(int(input())):
n, a = int(input()), list(map(int, input().split()))
a.sort()
for i in range(n):
for j in range(i + 1, n): d[a[j] - a[i]] = t
i = 1
while any(d[i * j] == t for j in range(1, n)): i += 1
print("YES\n" + ' '.join(str(j * i + 1) for j in range(n)))
|
Russian Code Cup 2017 - Finals [Unofficial Mirror, Div. 1 Only Recommended, Teams Allowed]
|
ICPC
| 2,017 | 1 | 256 |
Set Theory
|
Masha and Grisha like studying sets of positive integers.
One day Grisha has written a set A containing n different integers ai on a blackboard. Now he asks Masha to create a set B containing n different integers bj such that all n2 integers that can be obtained by summing up ai and bj for all possible pairs of i and j are different.
Both Masha and Grisha don't like big numbers, so all numbers in A are from 1 to 106, and all numbers in B must also be in the same range.
Help Masha to create the set B that satisfies Grisha's requirement.
|
Input data contains multiple test cases. The first line contains an integer t — the number of test cases (1 ≤ t ≤ 100).
Each test case is described in the following way: the first line of the description contains one integer n — the number of elements in A (1 ≤ n ≤ 100).
The second line contains n integers ai — the elements of A (1 ≤ ai ≤ 106).
|
For each test first print the answer:
- NO, if Masha's task is impossible to solve, there is no way to create the required set B.
- YES, if there is the way to create the required set. In this case the second line must contain n different positive integers bj — elements of B (1 ≤ bj ≤ 106). If there are several possible sets, output any of them.
| null | null |
[{"input": "3\n3\n1 10 100\n1\n1\n2\n2 4", "output": "YES\n1 2 3\nYES\n1\nYES\n1 2"}]
| 1,600 |
["brute force", "constructive algorithms"]
| 11 |
[{"input": "3\r\n3\r\n1 10 100\r\n1\r\n1\r\n2\r\n2 4\r\n", "output": "YES\r\n1 2 3 \r\nYES\r\n1 \r\nYES\r\n1 2 \r\n"}, {"input": "1\r\n100\r\n74 14 24 45 22 9 49 78 79 20 60 1 31 91 32 39 90 5 42 57 30 58 64 68 12 11 86 8 3 38 76 17 98 26 85 92 56 65 89 66 36 87 23 67 13 48 15 47 81 73 63 50 34 93 82 44 77 69 96 100 41 19 35 16 88 27 99 40 62 95 70 18 46 21 53 59 37 6 61 71 2 4 52 28 97 25 29 51 7 33 80 83 72 10 75 94 43 84 54 55\r\n", "output": "YES\r\n1 101 201 301 401 501 601 701 801 901 1001 1101 1201 1301 1401 1501 1601 1701 1801 1901 2001 2101 2201 2301 2401 2501 2601 2701 2801 2901 3001 3101 3201 3301 3401 3501 3601 3701 3801 3901 4001 4101 4201 4301 4401 4501 4601 4701 4801 4901 5001 5101 5201 5301 5401 5501 5601 5701 5801 5901 6001 6101 6201 6301 6401 6501 6601 6701 6801 6901 7001 7101 7201 7301 7401 7501 7601 7701 7801 7901 8001 8101 8201 8301 8401 8501 8601 8701 8801 8901 9001 9101 9201 9301 9401 9501 9601 9701 9801 9901 \r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(input_path) as f_in, open(submission_path) as f_sub:
input_lines = list(f_in.readlines())
sub_lines = list(f_sub.readlines())
t = int(input_lines[0].strip())
ptr = 1
sub_ptr = 0
for _ in range(t):
n = int(input_lines[ptr].strip())
ptr +=1
a_list = list(map(int, input_lines[ptr].strip().split()))
ptr +=1
if sub_ptr >= len(sub_lines):
print(0)
return
case_line = sub_lines[sub_ptr].strip().upper()
sub_ptr +=1
if case_line not in ['YES', 'NO']:
print(0)
return
if case_line == 'NO':
print(0)
return
else:
if sub_ptr >= len(sub_lines):
print(0)
return
b_line = sub_lines[sub_ptr].strip()
sub_ptr +=1
try:
b_list = list(map(int, b_line.split()))
except:
print(0)
return
if len(b_list) != n:
print(0)
return
if len(set(b_list)) != n:
print(0)
return
if any(b < 1 or b > 10**6 for b in b_list):
print(0)
return
sums = set()
for a in a_list:
for b in b_list:
s = a + b
if s in sums:
print(0)
return
sums.add(s)
print(1)
if __name__ == "__main__":
main()
| true |
856/A
|
856
|
A
|
PyPy 3
|
TESTS
| 3 | 389 | 2,048,000 |
52780981
|
t = int(input())
bound = 10 ** 6
for u in range(t):
n = int(input())
a = list(map(int, input().split()))
a.sort()
ans = [1]
difs = set()
for i in range(n):
for j in range(i + 1, n):
difs.add(a[j] - a[i])
last = 2
for i in range(n - 1):
ok = False
while not ok:
ok = True
for j in ans:
if abs(j - last) in difs:
ok = False
break
if ok:
break
last += 1
ans.append(last)
last += 1
if a[-1] + ans[-1] > bound:
print('NO')
continue
print('YES')
print(*ans)
| 11 | 405 | 2,048,000 |
30365314
|
from random import randint
def solve():
n, aa = int(input()), list(map(int, input().split()))
bb, ab = set(), set()
while True:
b = randint(1, 1000000)
for a in aa:
if a + b in ab:
break
else:
bb.add(b)
if len(bb) == n:
break
for a in aa:
ab.add(a + b)
print("YES")
print(' '.join(map(str, bb)))
def main():
for _ in range(int(input())):
solve()
if __name__ == '__main__':
main()
|
Russian Code Cup 2017 - Finals [Unofficial Mirror, Div. 1 Only Recommended, Teams Allowed]
|
ICPC
| 2,017 | 1 | 256 |
Set Theory
|
Masha and Grisha like studying sets of positive integers.
One day Grisha has written a set A containing n different integers ai on a blackboard. Now he asks Masha to create a set B containing n different integers bj such that all n2 integers that can be obtained by summing up ai and bj for all possible pairs of i and j are different.
Both Masha and Grisha don't like big numbers, so all numbers in A are from 1 to 106, and all numbers in B must also be in the same range.
Help Masha to create the set B that satisfies Grisha's requirement.
|
Input data contains multiple test cases. The first line contains an integer t — the number of test cases (1 ≤ t ≤ 100).
Each test case is described in the following way: the first line of the description contains one integer n — the number of elements in A (1 ≤ n ≤ 100).
The second line contains n integers ai — the elements of A (1 ≤ ai ≤ 106).
|
For each test first print the answer:
- NO, if Masha's task is impossible to solve, there is no way to create the required set B.
- YES, if there is the way to create the required set. In this case the second line must contain n different positive integers bj — elements of B (1 ≤ bj ≤ 106). If there are several possible sets, output any of them.
| null | null |
[{"input": "3\n3\n1 10 100\n1\n1\n2\n2 4", "output": "YES\n1 2 3\nYES\n1\nYES\n1 2"}]
| 1,600 |
["brute force", "constructive algorithms"]
| 11 |
[{"input": "3\r\n3\r\n1 10 100\r\n1\r\n1\r\n2\r\n2 4\r\n", "output": "YES\r\n1 2 3 \r\nYES\r\n1 \r\nYES\r\n1 2 \r\n"}, {"input": "1\r\n100\r\n74 14 24 45 22 9 49 78 79 20 60 1 31 91 32 39 90 5 42 57 30 58 64 68 12 11 86 8 3 38 76 17 98 26 85 92 56 65 89 66 36 87 23 67 13 48 15 47 81 73 63 50 34 93 82 44 77 69 96 100 41 19 35 16 88 27 99 40 62 95 70 18 46 21 53 59 37 6 61 71 2 4 52 28 97 25 29 51 7 33 80 83 72 10 75 94 43 84 54 55\r\n", "output": "YES\r\n1 101 201 301 401 501 601 701 801 901 1001 1101 1201 1301 1401 1501 1601 1701 1801 1901 2001 2101 2201 2301 2401 2501 2601 2701 2801 2901 3001 3101 3201 3301 3401 3501 3601 3701 3801 3901 4001 4101 4201 4301 4401 4501 4601 4701 4801 4901 5001 5101 5201 5301 5401 5501 5601 5701 5801 5901 6001 6101 6201 6301 6401 6501 6601 6701 6801 6901 7001 7101 7201 7301 7401 7501 7601 7701 7801 7901 8001 8101 8201 8301 8401 8501 8601 8701 8801 8901 9001 9101 9201 9301 9401 9501 9601 9701 9801 9901 \r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(input_path) as f_in, open(submission_path) as f_sub:
input_lines = list(f_in.readlines())
sub_lines = list(f_sub.readlines())
t = int(input_lines[0].strip())
ptr = 1
sub_ptr = 0
for _ in range(t):
n = int(input_lines[ptr].strip())
ptr +=1
a_list = list(map(int, input_lines[ptr].strip().split()))
ptr +=1
if sub_ptr >= len(sub_lines):
print(0)
return
case_line = sub_lines[sub_ptr].strip().upper()
sub_ptr +=1
if case_line not in ['YES', 'NO']:
print(0)
return
if case_line == 'NO':
print(0)
return
else:
if sub_ptr >= len(sub_lines):
print(0)
return
b_line = sub_lines[sub_ptr].strip()
sub_ptr +=1
try:
b_list = list(map(int, b_line.split()))
except:
print(0)
return
if len(b_list) != n:
print(0)
return
if len(set(b_list)) != n:
print(0)
return
if any(b < 1 or b > 10**6 for b in b_list):
print(0)
return
sums = set()
for a in a_list:
for b in b_list:
s = a + b
if s in sums:
print(0)
return
sums.add(s)
print(1)
if __name__ == "__main__":
main()
| true |
831/B
|
831
|
B
|
Python 3
|
TESTS
| 0 | 15 | 4,505,600 |
134417529
|
s1=input()
s2=input()
s=input()
res=''
for i in s:
if i.isdigit() and i.isupper():
t=s2[s1.index(i)]
res+=t.upper()
elif i.isdigit() and i.islower():
t=s2[s1.index(i)]
res+=t
else:
res+=i
print(res)
| 19 | 31 | 0 |
147109770
|
x = input()
y = input()
z = input()
output = ''
for i in z:
if(i.isupper()):
letter = y[x.index(i.lower())].upper()
elif(i.islower()): letter = y[x.index(i)]
else: letter = i
output += letter
print(output)
|
Codeforces Round 424 (Div. 2, rated, based on VK Cup Finals)
|
CF
| 2,017 | 1 | 256 |
Keyboard Layouts
|
There are two popular keyboard layouts in Berland, they differ only in letters positions. All the other keys are the same. In Berland they use alphabet with 26 letters which coincides with English alphabet.
You are given two strings consisting of 26 distinct letters each: all keys of the first and the second layouts in the same order.
You are also given some text consisting of small and capital English letters and digits. It is known that it was typed in the first layout, but the writer intended to type it in the second layout. Print the text if the same keys were pressed in the second layout.
Since all keys but letters are the same in both layouts, the capitalization of the letters should remain the same, as well as all other characters.
|
The first line contains a string of length 26 consisting of distinct lowercase English letters. This is the first layout.
The second line contains a string of length 26 consisting of distinct lowercase English letters. This is the second layout.
The third line contains a non-empty string s consisting of lowercase and uppercase English letters and digits. This is the text typed in the first layout. The length of s does not exceed 1000.
|
Print the text if the same keys were pressed in the second layout.
| null | null |
[{"input": "qwertyuiopasdfghjklzxcvbnm\nveamhjsgqocnrbfxdtwkylupzi\nTwccpQZAvb2017", "output": "HelloVKCup2017"}, {"input": "mnbvcxzlkjhgfdsapoiuytrewq\nasdfghjklqwertyuiopzxcvbnm\n7abaCABAABAcaba7", "output": "7uduGUDUUDUgudu7"}]
| 800 |
["implementation", "strings"]
| 19 |
[{"input": "qwertyuiopasdfghjklzxcvbnm\r\nveamhjsgqocnrbfxdtwkylupzi\r\nTwccpQZAvb2017\r\n", "output": "HelloVKCup2017\r\n"}, {"input": "mnbvcxzlkjhgfdsapoiuytrewq\r\nasdfghjklqwertyuiopzxcvbnm\r\n7abaCABAABAcaba7\r\n", "output": "7uduGUDUUDUgudu7\r\n"}, {"input": "ayvguplhjsoiencbkxdrfwmqtz\r\nkhzvtbspcndierqumlojyagfwx\r\n3\r\n", "output": "3\r\n"}, {"input": "oaihbljgekzsxucwnqyrvfdtmp\r\nwznqcfvrthjibokeglmudpayxs\r\ntZ8WI33UZZytE8A99EvJjck228LxUQtL5A8q7O217KrmdhpmdhN7JEdVXc8CRm07TFidlIou9AKW9cCl1c4289rfU87oXoSCwHpZO7ggC2GmmDl0KGuA2IimDco2iKaBKl46H089r2tw16mhzI44d2X6g3cnoD0OU5GvA8l89nhNpzTbY9FtZ2wE3Y2a5EC7zXryudTZhXFr9EEcX8P71fp6694aa02B4T0w1pDaVml8FM3N2qB78DBrS723Vpku105sbTJEdBpZu77b1C47DujdoR7rjm5k2nsaPBqX93EfhW95Mm0sBnFtgo12gS87jegSR5u88tM5l420dkt1l1b18UjatzU7P2i9KNJA528caiEpE3JtRw4m4TJ7M1zchxO53skt3Fqvxk2C51gD8XEY7YJC2xmTUqyEUFmPX581Gow2HWq4jaP8FK87\r\n", "output": "yJ8EN33OJJmyT8Z99TdVvkh228FbOLyF5Z8l7W217HuxaqsxaqG7VTaDBk8KUx07YPnafNwo9ZHE9kKf1k4289upO87wBwIKeQsJW7rrK2RxxAf0HRoZ2NnxAkw2nHzCHf46Q089u2ye16xqjN44a2B6r3kgwA0WO5RdZ8f89gqGsjYcM9PyJ2eT3M2z5TK7jBumoaYJqBPu9TTkB8S71ps6694zz02C4Y0e1sAzDxf8PX3G2lC78ACuI723Dsho105icYVTaCsJo77c1K47AovawU7uvx5h2gizSClB93TpqE95Xx0iCgPyrw12rI87vtrIU5o88yX5f420ahy1f1c18OvzyjO7S2n9HGVZ528kznTsT3VyUe4x4YV7X1jkqbW53ihy3Pldbh2K51rA8BTM7MVK2bxYOlmTOPxSB581Rwe2QEl4vzS8PH87\r\n"}, {"input": "aymrnptzhklcbuxfdvjsgqweio\r\nwzsavqryltmjnfgcedxpiokbuh\r\nB5\r\n", "output": "N5\r\n"}, {"input": "unbclszprgiqjodxeawkymvfth\r\ncxfwbdvuqlotkgparmhsyinjze\r\nk081O\r\n", "output": "s081G\r\n"}, {"input": "evfsnczuiodgbhqmlypkjatxrw\r\nhvsockwjxtgreqmyanlzidpbuf\r\n306QMPpaqZ\r\n", "output": "306MYLldmW\r\n"}, {"input": "pbfjtvryklwmuhxnqsoceiadgz\r\ntaipfdvlzemhjsnkwyocqgrxbu\r\nTm9H66Ux59PuGe3lEG94q18u11Dda6w59q1hAAIvHR1qquKI2Xf5ZFdKAPhcEnqKT6BF6Oh16P48YvrIKWGDlRcx9BZwwEF64o0As\r\n", "output": "Fh9S66Jn59TjBq3eQB94w18j11Xxr6m59w1sRRGdSV1wwjZG2Ni5UIxZRTscQkwZF6AI6Os16T48LdvGZMBXeVcn9AUmmQI64o0Ry\r\n"}, {"input": "rtqgahmkeoldsiynjbuwpvcxfz\r\noxqiuwflvebnapyrmcghtkdjzs\r\nJqNskelr3FNjbDhfKPfPXxlqOw72p9BVBwf0tN8Ucs48Vlfjxqo9V3ruU5205UgTYi3JKFbW91NLQ1683315VJ4RSLFW7s26s6uZKs5cO2wAT4JS8rCytZVlPWXdNXaCTq06F1v1Fj2zq7DeJbBSfM5Eko6vBndR75d46mf5Pq7Ark9NARTtQ176ukljBdaqXRsYxrBYl7hda1V7sy38hfbjz59HYM9U55P9eh1CX7tUE44NFlQu7zSjSBHyS3Tte2XaXD3O470Q8U20p8W5rViIh8lsn2TvmcdFdxrF3Ye26J2ZK0BR3KShN597WSJmHJTl4ZZ88IMhzHi6vFyr7MuGYNFGebTB573e6Crwj8P18h344yd8sR2NPge36Y3QC8Y2uW577CO2w4fz\r\n", "output": "MqRalvbo3ZRmcNwzLTzTJjbqEh72t9CKChz0xR8Gda48Kbzmjqe9K3ogG5205GiXYp3MLZcH91RBQ1683315KM4OABZH7a26a6gSLa5dE2hUX4MA8oDyxSKbTHJnRJuDXq06Z1k1Zm2sq7NvMcCAzF5Vle6kCrnO75n46fz5Tq7Uol9RUOXxQ176glbmCnuqJOaYjoCYb7wnu1K7ay38wzcms59WYF9G55T9vw1DJ7xGV44RZbQg7sAmACWyA3Xxv2JuJN3E470Q8G20t8H5oKpPw8bar2XkfdnZnjoZ3Yv26M2SL0CO3LAwR597HAMfWMXb4SS88PFwsWp6kZyo7FgIYRZIvcXC573v6Dohm8T18w344yn8aO2RTiv36Y3QD8Y2gH577DE2h4zs\r\n"}, {"input": "buneohqdgxjsafrmwtzickvlpy\r\nzblwamjxifyuqtnrgdkchpoves\r\n4RZf8YivG6414X1GdDfcCbc10GA0Wz8514LI9D647XzPb66UNh7lX1rDQv0hQvJ7aqhyh1Z39yABGKn24g185Y85ER5q9UqPFaQ2JeK97wHZ78CMSuU8Zf091mePl2OX61BLe5KdmUWodt4BXPiseOZkZ4SZ27qtBM4hT499mCirjy6nB0ZqjQie4Wr3uhW2mGqBlHyEZbW7A6QnsNX9d3j5aHQN0H6GF8J0365KWuAmcroutnJD6l6HI3kSSq17Sdo2htt9y967y8sc98ZAHbutH1m9MOVT1E9Mb5UIK3qNatk9A0m2i1fQl9A65204Q4z4O4rQf374YEq0s2sfmQNW9K7E1zSbj51sGINJVr5736Gw8aW6u9Cjr0sjffXctLopJ0YQ47xD1yEP6bB3odG7slgiM8hJ9BuwfGUwN8tbAgJU8wMI2L0P446MO\r\n", "output": "4NKt8ScoI6414F1IxXthHzh10IQ0Gk8514VC9X647FkEz66BLm7vF1nXJo0mJoY7qjmsm1K39sQZIPl24i185S85WN5j9BjETqJ2YwP97gMK78HRUbB8Kt091rwEv2AF61ZVw5PxrBGaxd4ZFEcuwAKpK4UK27jdZR4mD499rHcnys6lZ0KjyJcw4Gn3bmG2rIjZvMsWKzG7Q6JluLF9x3y5qMJL0M6IT8Y0365PGbQrhnabdlYX6v6MC3pUUj17Uxa2mdd9s967s8uh98KQMzbdM1r9RAOD1W9Rz5BCP3jLqdp9Q0r2c1tJv9Q65204J4k4A4nJt374SWj0u2utrJLG9P7W1kUzy51uICLYOn5736Ig8qG6b9Hyn0uyttFhdVaeY0SJ47fX1sWE6zZ3axI7uvicR8mY9ZbgtIBgL8dzQiYB8gRC2V0E446RA\r\n"}, {"input": "qwertyuiopasdfghjklzxcvbnm\r\nqwertyuiopasdfghjklzxcvbnm\r\nqwertyuiopasdfghjklzxcvbnmPOIUYTREWQLKJHGFDSAMNBVCXZ12345678900987654321ASDFGHJKLqwertyuiopZXCVBNM\r\n", "output": "qwertyuiopasdfghjklzxcvbnmPOIUYTREWQLKJHGFDSAMNBVCXZ12345678900987654321ASDFGHJKLqwertyuiopZXCVBNM\r\n"}, {"input": "qwertyuiopasdfghjklzxcvbnm\r\nmnbvcxzlkjhgfdsapoiuytrewq\r\nasdfghjklzxcvbnmqwertyuiopASDFGHJKLQWERTYUIOPZXCVBNM12345678900987654321QWSDFGVBNxcvghjkoWQEDFGHNJMzxcfghjkl\r\n", "output": "hgfdsapoiuytrewqmnbvcxzlkjHGFDSAPOIMNBVCXZLKJUYTREWQ12345678900987654321MNGFDSREWytrsapokNMBFDSAWPQuytdsapoi\r\n"}]
| false |
stdio
| null | true |
191/C
|
191
|
C
|
PyPy 3
|
TESTS
| 3 | 764 | 257,228,800 |
97199529
|
import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
from collections import defaultdict
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
sys.setrecursionlimit(3*10**5)
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
MA=10**5+1
level=20
tree=[[] for i in range(MA)]
depth=[0 for i in range(MA)]
parent=[[0 for i in range(level)] for j in range(MA)]
@bootstrap
def dfs(cur,prev):
depth[cur] = depth[prev] + 1
parent[cur][0] = prev
res.append(cur)
for i in range(len(tree[cur])):
if (tree[cur][i] != prev):
yield dfs(tree[cur][i], cur)
res.append(-cur)
yield
def precomputeSparseMatrix(n):
for i in range(1,level):
for node in range(1,n+1):
if (parent[node][i-1] != -1):
parent[node][i] =parent[parent[node][i-1]][i-1]
def lca(u,v):
if (depth[v] < depth[u]):
u,v=v,u
diff = depth[v] - depth[u]
for i in range(level):
if ((diff >> i) & 1):
v = parent[v][i]
if (u == v):
return u
i=level-1
while(i>=0):
if (parent[u][i] != parent[v][i]):
u = parent[u][i]
v = parent[v][i]
i+=-1
return parent[u][0]
def add(a,b):
tree[a].append(b)
tree[b].append(a)
def res(s,t,f):
p=lca(t,f)
q=lca(s,f)
if p==q:
r=depth[lca(s,t)]-depth[p]
return min(depth[p] + depth[f] - 2 * depth[p] + 1+r, depth[q] + depth[f] - 2 * depth[q] + 1+r)
return min(depth[p]+depth[f]-2*depth[p]+1,depth[q]+depth[f]-2*depth[q]+1)
ord=[]
n=int(input())
for j in range(n-1):
u,v=map(int,input().split())
ord.append([u, v])
tree[u].append(v)
tree[v].append(u)
res=[]
dfs(1,0)
precomputeSparseMatrix(n)
d=dict()
l=len(res)
req=[0]*(l)
for j in range(l):
d[res[j]]=j
k=int(input())
for j in range(k):
u,v=map(int,input().split())
lc=lca(u,v)
if u==lc:
indu=d[u]
indv=d[v]
req[indu]+=1
req[indv+1]+=-1
elif v==lc:
indu = d[u]
indv = d[v]
req[indv] += 1
req[indu + 1] += -1
else:
indl=d[lc]
indu = d[u]
indv = d[v]
req[indl]+=1
req[indu+1]+=-1
req[indl+1]+=1
req[indv+1]+=-1
for j in range(1,l):
req[j]+=req[j-1]
ans=[0]*(n+1)
for j in range(1,n+1):
ans[j]=req[d[j]]-req[d[-j]]
for j in ord:
print(min(ans[j[0]],ans[j[1]]),end=" ")
| 136 | 717 | 58,368,000 |
218130480
|
from io import BytesIO, IOBase
import sys
import os
# import time
import bisect
# import functools
import math
import random
# import re
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import cmp_to_key, lru_cache, reduce
from heapq import heapify, heappop, heappush, heappushpop, nlargest, nsmallest
from itertools import accumulate, combinations, permutations, count, product
from operator import add, iand, ior, itemgetter, mul, xor
from string import ascii_lowercase, ascii_uppercase
from typing import *
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
BUFSIZE = 5096
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
sys.stdin = IOWrapper(sys.stdin)
sys.stdout = IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def I():
return input()
def II():
return int(input())
def MII():
return map(int, input().split())
def LI():
return list(input().split())
def LII():
return list(map(int, input().split()))
def GMI():
return map(lambda x: int(x) - 1, input().split())
def LGMI():
return list(map(lambda x: int(x) - 1, input().split()))
inf = float('inf')
# from types import GeneratorType
# def bootstrap(f, stack=[]):
# def wrappedfunc(*args, **kwargs):
# if stack:
# return f(*args, **kwargs)
# else:
# to = f(*args, **kwargs)
# while True:
# if type(to) is GeneratorType:
# stack.append(to)
# to = next(to)
# else:
# stack.pop()
# if not stack:
# break
# to = stack[-1].send(to)
# return to
# return wrappedfunc
# RANDOM = random.getrandbits(32)
# class Wrapper_str(str):
# def __init__(self, x):
# str.__init__(x)
# def __hash__(self):
# return super(Wrapper_str, self).__hash__() ^ RANDOM
# class Wrapper_tuple(tuple):
# def __init__(self, x):
# tuple.__init__(x)
# def __hash__(self):
# return super(Wrapper_tuple, self).__hash__() ^ RANDOM
# class Wrapper_int(int):
# def __init__(self, x):
# int.__init__(x)
# def __hash__(self):
# return super(Wrapper_int, self).__hash__() ^ RANDOM
class LCA:
def __init__(self, g, root, f=max, ide_ele=0):
# g[v]: (cost, u)
self.n = len(g)
self.root = root
self.f = f
self.ide_ele = ide_ele
self.num = (self.n).bit_length()
self.depth = [0]*self.n
self.parent = [[-1]*self.n for i in range(self.num)]
self.size = [1]*n
s = [root]
while s:
v = s.pop()
order.append(v)
for u in g[v]:
if u == self.parent[0][v]:
continue
self.parent[0][u] = v
self.depth[u] = self.depth[v]+1
s.append(u)
order.reverse()
for v in order:
p = self.parent[0][v]
if p != -1:
self.size[p] += self.size[v]
# doubling
for k in range(self.num-1):
for v in range(self.n):
if self.parent[k][v] == -1:
self.parent[k+1][v] = -1
else:
self.parent[k+1][v] = self.parent[k][self.parent[k][v]]
def getLCA(self, u, v):
if self.depth[u] > self.depth[v]:
u, v = v, u
for k in range(self.num):
if ((self.depth[v]-self.depth[u]) >> k) & 1:
v = self.parent[k][v]
if u == v:
return u
for k in reversed(range(self.num)):
if self.parent[k][u] != self.parent[k][v]:
u = self.parent[k][u]
v = self.parent[k][v]
return self.parent[0][u]
def getParent(self, u):
return self.parent[0][u]
def search(self, v, x):
for k in reversed(range(self.num)):
if (x>>k)&1:
v = self.parent[k][v]
return v
order = []
n = II()
edges = []
path = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = GMI()
edges.append((u, v))
path[u].append(v)
path[v].append(u)
lca = LCA(path, 0)
diff = [0] * (n + 1)
q = II()
for _ in range(q):
u, v = GMI()
diff[u] += 1
diff[v] += 1
l = lca.getLCA(u, v)
diff[l] -= 2
for i in order:
diff[lca.getParent(i)] += diff[i]
ans = []
for u, v in edges:
if lca.depth[u] > lca.depth[v]:
ans.append(diff[u])
else:
ans.append(diff[v])
print(*ans)
|
Codeforces Round 121 (Div. 1)
|
CF
| 2,012 | 2 | 256 |
Fools and Roads
|
They say that Berland has exactly two problems, fools and roads. Besides, Berland has n cities, populated by the fools and connected by the roads. All Berland roads are bidirectional. As there are many fools in Berland, between each pair of cities there is a path (or else the fools would get upset). Also, between each pair of cities there is no more than one simple path (or else the fools would get lost).
But that is not the end of Berland's special features. In this country fools sometimes visit each other and thus spoil the roads. The fools aren't very smart, so they always use only the simple paths.
A simple path is the path which goes through every Berland city not more than once.
The Berland government knows the paths which the fools use. Help the government count for each road, how many distinct fools can go on it.
Note how the fools' paths are given in the input.
|
The first line contains a single integer n (2 ≤ n ≤ 105) — the number of cities.
Each of the next n - 1 lines contains two space-separated integers ui, vi (1 ≤ ui, vi ≤ n, ui ≠ vi), that means that there is a road connecting cities ui and vi.
The next line contains integer k (0 ≤ k ≤ 105) — the number of pairs of fools who visit each other.
Next k lines contain two space-separated numbers. The i-th line (i > 0) contains numbers ai, bi (1 ≤ ai, bi ≤ n). That means that the fool number 2i - 1 lives in city ai and visits the fool number 2i, who lives in city bi. The given pairs describe simple paths, because between every pair of cities there is only one simple path.
|
Print n - 1 integer. The integers should be separated by spaces. The i-th number should equal the number of fools who can go on the i-th road. The roads are numbered starting from one in the order, in which they occur in the input.
| null |
In the first sample the fool number one goes on the first and third road and the fool number 3 goes on the second, first and fourth ones.
In the second sample, the fools number 1, 3 and 5 go on the first road, the fool number 5 will go on the second road, on the third road goes the fool number 3, and on the fourth one goes fool number 1.
|
[{"input": "5\n1 2\n1 3\n2 4\n2 5\n2\n1 4\n3 5", "output": "2 1 1 1"}, {"input": "5\n3 4\n4 5\n1 4\n2 4\n3\n2 3\n1 3\n3 5", "output": "3 1 1 1"}]
| 1,900 |
["data structures", "dfs and similar", "trees"]
| 136 |
[{"input": "5\r\n1 2\r\n1 3\r\n2 4\r\n2 5\r\n2\r\n1 4\r\n3 5\r\n", "output": "2 1 1 1 \r\n"}, {"input": "5\r\n3 4\r\n4 5\r\n1 4\r\n2 4\r\n3\r\n2 3\r\n1 3\r\n3 5\r\n", "output": "3 1 1 1 \r\n"}]
| false |
stdio
| null | true |
832/D
|
832
|
D
|
PyPy 3-64
|
TESTS
| 2 | 108 | 15,769,600 |
139293891
|
from sys import stdin, stdout
def dfs(v, p):
global timer
timer += 1
IN[v] = timer
up[0][v] = p
for i in range(1, LG):
up[i][v] = up[i - 1][up[i - 1][v]]
for q in G[v]:
if q[0] != p:
dep[q[0]] = dep[v] + q[1]
dfs(q[0], v)
out[v] = timer
def upper(u, v):
return IN[u] <= IN[v] and out[v] <= out[u]
def lca(u, v):
if IN[u] > IN[v]:
u, v = v, u
if upper(u, v):
return u
for i in range(LG-1, -1, -1):
if not upper(up[i][u], v):
u = up[i][u]
return up[0][u]
n, q = stdin.readline().split()
n = int(n)
q = int(q)
stations = list(map(int, input().split()))
w = 1
LG = 18
N = 10**5
G = [] # [[] for i in range(n)]
IN = [] # [0 for i in range(n)]
out = [] # [0 for i in range(n)]
dep = [] # [0 for i in range(n)]
for i in range(n + 1):
G.append([])
IN.append(0)
out.append(0)
dep.append(0)
timer = 0
up = [[0 for i in range(N)] for j in range(LG)]
for i in range(2, n+1):
G[i].append([stations[i - 2], w])
G[stations[i - 2]].append([i, w])
dfs(1, 0)
#print(f'G: {G}')
#print(f'IN: {IN}')
#print(f'out: {out}')
#print(f'dep: {dep}')
for i in range(q):
a, b, c = stdin.readline().split()
a = int(a)
b = int(b)
c = int(c)
ab = lca(a, b)
ac = lca(a, c)
bc = lca(b, c)
cb = lca(c, b)
ba = lca(b, a)
ca = lca(c, a)
#print(f'ab: {ab}, ac: {ac}, bc: {bc} \n cb: {cb}, ba: {ba}, ca: {ca}')
distant_1 = dep[a] + dep[b] - 2 * dep[ab]
distant_2 = dep[a] + dep[c] - 2 * dep[ac]
distant_3 = dep[b] + dep[c] - 2 * dep[bc]
distant_4 = dep[c] + dep[b] - 2 * dep[cb]
distant_5 = dep[b] + dep[a] - 2 * dep[ba]
distant_6 = dep[c] + dep[a] - 2 * dep[ca]
#print(distant_1, distant_2, distant_3, distant_4, distant_5, distant_6)
stdout.write(str(max(ab, ac, bc, cb, ba, ca, distant_1, distant_2, distant_3, distant_4, distant_5, distant_6)) + '\n')
| 94 | 1,325 | 40,550,400 |
110042385
|
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def pre(n,path,lim):
# lim = n.bit_length()
up = [[-1]*(lim+1) for _ in range(n)]
st,visi,height = [0],[1]+[0]*(n-1),[0]*n
start,finish,time = [0]*n,[0]*n,0
while len(st):
x = st[-1]
y,j = up[x][0],0
while y != -1:
up[x][j] = y
y = up[y][j]
j += 1
while len(path[x]) and visi[path[x][-1]]:
path[x].pop()
if not len(path[x]):
time += 1
finish[x] = time
st.pop()
else:
i = path[x].pop()
st.append(i)
time += 1
visi[i],start[i],up[i][0],height[i] = 1,time,x,height[x]+1
return start,finish,up,height
def is_ancestor(u,v,start,finish):
return start[u] <= start[v] and finish[u] >= finish[v]
def lca(u,v,up,start,finish,lim):
if is_ancestor(u,v,start,finish):
return u
if is_ancestor(v,u,start,finish):
return v
for i in range(lim,-1,-1):
if up[u][i] != -1 and not is_ancestor(up[u][i],v,start,finish):
u = up[u][i]
return up[u][0]
def solve(s,f,t,up,start,finish,lim,height):
a = lca(s,f,up,start,finish,lim)
b = lca(t,f,up,start,finish,lim)
ans = height[f]-max(height[a],height[b])+1
if a == b:
x = lca(s,t,up,start,finish,lim)
ans += height[x]-height[a]
return ans
def main():
n,q = map(int,input().split())
path = [[] for _ in range(n)]
for ind,i in enumerate(map(int,input().split())):
path[ind+1].append(i-1)
path[i-1].append(ind+1)
lim = n.bit_length()
start,finish,up,height = pre(n,path,lim)
for _ in range(q):
a,b,c = map(lambda xx:int(xx)-1,input().split())
print(max(solve(a,b,c,up,start,finish,lim,height),
solve(a,c,b,up,start,finish,lim,height),
solve(b,a,c,up,start,finish,lim,height)))
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
|
Codeforces Round 425 (Div. 2)
|
CF
| 2,017 | 2 | 256 |
Misha, Grisha and Underground
|
Misha and Grisha are funny boys, so they like to use new underground. The underground has n stations connected with n - 1 routes so that each route connects two stations, and it is possible to reach every station from any other.
The boys decided to have fun and came up with a plan. Namely, in some day in the morning Misha will ride the underground from station s to station f by the shortest path, and will draw with aerosol an ugly text "Misha was here" on every station he will pass through (including s and f). After that on the same day at evening Grisha will ride from station t to station f by the shortest path and will count stations with Misha's text. After that at night the underground workers will wash the texts out, because the underground should be clean.
The boys have already chosen three stations a, b and c for each of several following days, one of them should be station s on that day, another should be station f, and the remaining should be station t. They became interested how they should choose these stations s, f, t so that the number Grisha will count is as large as possible. They asked you for help.
|
The first line contains two integers n and q (2 ≤ n ≤ 105, 1 ≤ q ≤ 105) — the number of stations and the number of days.
The second line contains n - 1 integers p2, p3, ..., pn (1 ≤ pi ≤ n). The integer pi means that there is a route between stations pi and i. It is guaranteed that it's possible to reach every station from any other.
The next q lines contains three integers a, b and c each (1 ≤ a, b, c ≤ n) — the ids of stations chosen by boys for some day. Note that some of these ids could be same.
|
Print q lines. In the i-th of these lines print the maximum possible number Grisha can get counting when the stations s, t and f are chosen optimally from the three stations on the i-th day.
| null |
In the first example on the first day if s = 1, f = 2, t = 3, Misha would go on the route 1 $$\rightarrow$$ 2, and Grisha would go on the route 3 $$\rightarrow$$ 1 $$\rightarrow$$ 2. He would see the text at the stations 1 and 2. On the second day, if s = 3, f = 2, t = 3, both boys would go on the route 3 $$\rightarrow$$ 1 $$\rightarrow$$ 2. Grisha would see the text at 3 stations.
In the second examle if s = 1, f = 3, t = 2, Misha would go on the route 1 $$\rightarrow$$ 2 $$\rightarrow$$ 3, and Grisha would go on the route 2 $$\rightarrow$$ 3 and would see the text at both stations.
|
[{"input": "3 2\n1 1\n1 2 3\n2 3 3", "output": "2\n3"}, {"input": "4 1\n1 2 3\n1 2 3", "output": "2"}]
| 1,900 |
["dfs and similar", "graphs", "trees"]
| 94 |
[{"input": "3 2\r\n1 1\r\n1 2 3\r\n2 3 3\r\n", "output": "2\r\n3\r\n"}, {"input": "4 1\r\n1 2 3\r\n1 2 3\r\n", "output": "2\r\n"}, {"input": "2 4\r\n1\r\n1 1 1\r\n1 1 2\r\n1 2 2\r\n2 2 2\r\n", "output": "1\r\n2\r\n2\r\n1\r\n"}, {"input": "5 20\r\n4 1 1 4\r\n2 2 5\r\n3 2 5\r\n2 3 4\r\n4 2 5\r\n4 1 2\r\n5 3 1\r\n2 1 2\r\n4 3 2\r\n1 3 3\r\n4 2 5\r\n5 1 4\r\n4 5 4\r\n1 2 4\r\n3 3 1\r\n5 4 5\r\n1 1 1\r\n1 4 4\r\n5 3 2\r\n4 2 1\r\n3 1 4\r\n", "output": "3\r\n3\r\n3\r\n2\r\n2\r\n3\r\n3\r\n3\r\n2\r\n2\r\n2\r\n2\r\n2\r\n2\r\n2\r\n1\r\n2\r\n3\r\n2\r\n2\r\n"}, {"input": "5 20\r\n5 5 1 4\r\n1 4 3\r\n2 4 1\r\n1 5 5\r\n5 1 4\r\n5 1 5\r\n1 5 5\r\n5 4 4\r\n2 3 3\r\n4 4 1\r\n1 4 1\r\n4 5 4\r\n1 4 5\r\n4 1 5\r\n2 4 2\r\n4 3 3\r\n2 5 5\r\n1 5 4\r\n3 3 4\r\n5 5 1\r\n3 4 1\r\n", "output": "3\r\n3\r\n3\r\n2\r\n3\r\n3\r\n2\r\n3\r\n2\r\n2\r\n2\r\n2\r\n2\r\n3\r\n3\r\n2\r\n2\r\n3\r\n3\r\n3\r\n"}]
| false |
stdio
| null | true |
270/A
|
270
|
A
|
Python 3
|
TESTS
| 2 | 62 | 0 |
227651361
|
tests = int(input())
while tests > 0:
angle = int(input())
tests -= 1
if angle < 60:
print("NO")
else:
print("YES")
| 3 | 30 | 0 |
130331529
|
t=int(input())
li=[]
for i in range(t):
a=int(input())
n=360/(180-a)
li.append(n)
for i in range(t):
b=li[i]
if b==int(b) and int(b)>2:
print('YES')
else: print('NO')
|
Codeforces Round 165 (Div. 2)
|
CF
| 2,013 | 2 | 256 |
Fancy Fence
|
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?
|
The first line of input contains an integer t (0 < t < 180) — the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) — the angle the robot can make corners at measured in degrees.
|
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
| null |
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle $$30^\circ$$.
In the second test case, the fence is a regular triangle, and in the last test case — a square.
|
[{"input": "3\n30\n60\n90", "output": "NO\nYES\nYES"}]
| 1,100 |
["geometry", "implementation", "math"]
| 3 |
[{"input": "3\r\n30\r\n60\r\n90\r\n", "output": "NO\r\nYES\r\nYES\r\n"}, {"input": "6\r\n1\r\n2\r\n3\r\n170\r\n179\r\n25\r\n", "output": "NO\r\nNO\r\nNO\r\nYES\r\nYES\r\nNO\r\n"}]
| false |
stdio
| null | true |
111/B
|
111
|
B
|
Python 3
|
TESTS
| 2 | 778 | 9,932,800 |
121490375
|
maxn=100000
div=[0]*(maxn+1)
last=[-maxn]*(maxn+1)
for i in range(maxn+1):
div[i]=list()
for i in range(2,int(maxn/2)):
for j in range(i,maxn+1,i):
div[j].append(i)
t=int(input())
for k in range(0,t):
x_i,y_i = input().split(" ")
x_i=int(x_i)
y_i=int(y_i)
if y_i==0:
print(len(div[x_i])+1)
else:
print(sum(1 for v in div[x_i] if last[v]<k-y_i))
for d in div[x_i]:
last[d]=k
| 44 | 2,214 | 9,932,800 |
209312632
|
def calculate_smallest_factor(n):
from math import sqrt
for prime in range(2,int(sqrt(n+1))+1):
if smallest_factor[prime]==prime:
for factor in range(prime*prime,n+1,prime):
if smallest_factor[factor] == factor:
smallest_factor[factor] = prime
return smallest_factor
def calculate_freq_of_prime_factors(n):
factors = {}
while n!=1:
factor = smallest_factor[n]
factors[factor] = factors.get(factor,0)+1
n//=factor
return factors
def calculate_all_divisiors(freq):
ans = [1]
for prime_factor in freq:
count = freq[prime_factor]
curr = prime_factor
new = []
for j in range(count):
for divisor in ans:
new.append(divisor*curr)
curr*=prime_factor
ans.extend(new)
return ans
n = int(input())
N = 10**5
smallest_factor = [i for i in range(N+1)]
calculate_smallest_factor(N)
last_index_with_divisor = [-1 for i in range(N+1)]
for i in range(n):
x,y = [int(i) for i in input().strip().split()]
divisors = calculate_all_divisiors(calculate_freq_of_prime_factors(x))
count = 0
for divisor in divisors:
if i-last_index_with_divisor[divisor]>y:
count+=1
last_index_with_divisor[divisor] = i
print(count)
|
Codeforces Beta Round 85 (Div. 1 Only)
|
CF
| 2,011 | 5 | 256 |
Petya and Divisors
|
Little Petya loves looking for numbers' divisors. One day Petya came across the following problem:
You are given n queries in the form "xi yi". For each query Petya should count how many divisors of number xi divide none of the numbers xi - yi, xi - yi + 1, ..., xi - 1. Help him.
|
The first line contains an integer n (1 ≤ n ≤ 105). Each of the following n lines contain two space-separated integers xi and yi (1 ≤ xi ≤ 105, 0 ≤ yi ≤ i - 1, where i is the query's ordinal number; the numeration starts with 1).
If yi = 0 for the query, then the answer to the query will be the number of divisors of the number xi. In this case you do not need to take the previous numbers x into consideration.
|
For each query print the answer on a single line: the number of positive integers k such that $${ x _ { i } \bmod k = 0 \& ( \forall j : i - y _ { i } \leq j < i ) x _ { j } \bmod k \neq 0 }$$
| null |
Let's write out the divisors that give answers for the first 5 queries:
1) 1, 2, 4
2) 3
3) 5
4) 2, 6
5) 9, 18
|
[{"input": "6\n4 0\n3 1\n5 2\n6 2\n18 4\n10000 3", "output": "3\n1\n1\n2\n2\n22"}]
| 1,900 |
["binary search", "data structures", "number theory"]
| 44 |
[{"input": "6\r\n4 0\r\n3 1\r\n5 2\r\n6 2\r\n18 4\r\n10000 3\r\n", "output": "3\r\n1\r\n1\r\n2\r\n2\r\n22\r\n"}, {"input": "5\r\n10 0\r\n10 0\r\n10 0\r\n10 0\r\n10 0\r\n", "output": "4\r\n4\r\n4\r\n4\r\n4\r\n"}, {"input": "12\r\n41684 0\r\n95210 1\r\n60053 1\r\n32438 3\r\n97956 1\r\n21785 2\r\n14594 6\r\n17170 4\r\n93937 6\r\n70764 5\r\n13695 4\r\n14552 6\r\n", "output": "12\r\n6\r\n7\r\n9\r\n22\r\n3\r\n2\r\n13\r\n1\r\n6\r\n13\r\n11\r\n"}, {"input": "10\r\n54972 0\r\n48015 1\r\n7114 1\r\n68273 2\r\n53650 4\r\n1716 1\r\n16165 2\r\n96062 5\r\n57750 1\r\n21071 5\r\n", "output": "24\r\n21\r\n3\r\n3\r\n21\r\n22\r\n6\r\n6\r\n62\r\n3\r\n"}, {"input": "20\r\n68260 0\r\n819 1\r\n54174 1\r\n20460 1\r\n25696 2\r\n81647 4\r\n17736 4\r\n91307 5\r\n5210 4\r\n87730 2\r\n4653 8\r\n11044 6\r\n15776 4\r\n17068 7\r\n73738 7\r\n36004 12\r\n83183 7\r\n75700 12\r\n84270 14\r\n16120 5\r\n", "output": "12\r\n11\r\n6\r\n44\r\n18\r\n1\r\n9\r\n7\r\n6\r\n12\r\n8\r\n8\r\n21\r\n3\r\n14\r\n3\r\n3\r\n13\r\n18\r\n26\r\n"}, {"input": "17\r\n81548 0\r\n69975 1\r\n1234 0\r\n72647 0\r\n81389 4\r\n77930 1\r\n19308 0\r\n86551 6\r\n69023 8\r\n38037 1\r\n133 9\r\n59290 8\r\n1106 11\r\n95012 10\r\n57693 11\r\n8467 6\r\n93732 13\r\n", "output": "24\r\n17\r\n4\r\n2\r\n11\r\n7\r\n12\r\n3\r\n3\r\n7\r\n2\r\n27\r\n4\r\n3\r\n2\r\n1\r\n18\r\n"}, {"input": "15\r\n94836 0\r\n22780 1\r\n48294 0\r\n24834 3\r\n37083 2\r\n57862 0\r\n37231 1\r\n81795 7\r\n32835 2\r\n4696 8\r\n95612 0\r\n7536 6\r\n70084 5\r\n72956 10\r\n41647 7\r\n", "output": "24\r\n21\r\n12\r\n4\r\n6\r\n8\r\n3\r\n27\r\n12\r\n5\r\n24\r\n15\r\n8\r\n21\r\n1\r\n"}, {"input": "12\r\n91771 0\r\n75584 1\r\n95355 1\r\n60669 1\r\n92776 0\r\n37793 3\r\n38802 4\r\n60688 0\r\n80296 5\r\n55003 8\r\n91092 3\r\n55782 8\r\n", "output": "2\r\n13\r\n23\r\n17\r\n8\r\n2\r\n13\r\n10\r\n4\r\n2\r\n9\r\n10\r\n"}, {"input": "11\r\n5059 0\r\n28388 1\r\n42415 2\r\n12856 0\r\n48470 3\r\n34076 2\r\n40374 6\r\n55932 1\r\n44108 2\r\n5310 5\r\n86571 4\r\n", "output": "2\r\n11\r\n7\r\n8\r\n13\r\n9\r\n10\r\n20\r\n3\r\n12\r\n3\r\n"}, {"input": "10\r\n18347 0\r\n81193 1\r\n89475 2\r\n65043 3\r\n4164 0\r\n14007 5\r\n41945 0\r\n51177 1\r\n91569 5\r\n71969 4\r\n", "output": "4\r\n4\r\n11\r\n18\r\n12\r\n13\r\n4\r\n7\r\n6\r\n3\r\n"}]
| false |
stdio
| null | true |
379/C
|
379
|
C
|
Python 3
|
TESTS
| 0 | 15 | 0 |
150994681
|
n=(int(input()))
arr=list(map(int,input().rstrip().split()))
s=""
t=1
for e in range(n):
o= max(t,arr[e])
s=s+""+str(o)+" "
t+=1
print(s)
| 41 | 748 | 24,576,000 |
200592146
|
n = int(input())
arr = list(map(int,input().split()))
sort = sorted(range(n), key=lambda i: arr[i])
curr = 0
for i in sort:
if arr[i]<=curr:
curr+=1
arr[i]=curr
else:
curr=arr[i]
# sort[i]=curr
# print(curr)
print(*arr)
|
Good Bye 2013
|
CF
| 2,013 | 1 | 256 |
New Year Ratings Change
|
One very well-known internet resource site (let's call it X) has come up with a New Year adventure. Specifically, they decided to give ratings to all visitors.
There are n users on the site, for each user we know the rating value he wants to get as a New Year Present. We know that user i wants to get at least ai rating units as a present.
The X site is administered by very creative and thrifty people. On the one hand, they want to give distinct ratings and on the other hand, the total sum of the ratings in the present must be as small as possible.
Help site X cope with the challenging task of rating distribution. Find the optimal distribution.
|
The first line contains integer n (1 ≤ n ≤ 3·105) — the number of users on the site. The next line contains integer sequence a1, a2, ..., an (1 ≤ ai ≤ 109).
|
Print a sequence of integers b1, b2, ..., bn. Number bi means that user i gets bi of rating as a present. The printed sequence must meet the problem conditions.
If there are multiple optimal solutions, print any of them.
| null | null |
[{"input": "3\n5 1 1", "output": "5 1 2"}, {"input": "1\n1000000000", "output": "1000000000"}]
| 1,400 |
["greedy", "sortings"]
| 41 |
[{"input": "3\r\n5 1 1\r\n", "output": "5 1 2\r\n"}, {"input": "1\r\n1000000000\r\n", "output": "1000000000\r\n"}, {"input": "10\r\n1 1 1 1 1 1 1 1 1 1\r\n", "output": "1 2 3 4 5 6 7 8 9 10\r\n"}, {"input": "10\r\n1 10 1 10 1 1 7 8 6 7\r\n", "output": "1 10 2 11 3 4 7 9 6 8\r\n"}, {"input": "10\r\n20 19 12 1 12 15 2 12 6 10\r\n", "output": "20 19 12 1 13 15 2 14 6 10\r\n"}, {"input": "10\r\n4 5 10 5 2 14 15 6 10 6\r\n", "output": "4 5 10 6 2 14 15 7 11 8\r\n"}]
| false |
stdio
| null | true |
379/C
|
379
|
C
|
Python 3
|
TESTS
| 0 | 30 | 0 |
200590713
|
n = int(input())
arr = list(map(int,input().split()))
if n==1:
print(*arr)
else:
ans = []
for i in range(n):
ans.append(arr[i]+i)
print(*ans)
| 41 | 998 | 47,001,600 |
197560118
|
n=int(input())
lst=[*map(int,input().split())]
ind=sorted(range(n),key=lst.__getitem__)
elem=0
for i,x in enumerate(ind):
elem=max(elem+1,lst[x])
lst[x]=elem
print(''.join(map(lambda x:str(x)+' ',lst)))
|
Good Bye 2013
|
CF
| 2,013 | 1 | 256 |
New Year Ratings Change
|
One very well-known internet resource site (let's call it X) has come up with a New Year adventure. Specifically, they decided to give ratings to all visitors.
There are n users on the site, for each user we know the rating value he wants to get as a New Year Present. We know that user i wants to get at least ai rating units as a present.
The X site is administered by very creative and thrifty people. On the one hand, they want to give distinct ratings and on the other hand, the total sum of the ratings in the present must be as small as possible.
Help site X cope with the challenging task of rating distribution. Find the optimal distribution.
|
The first line contains integer n (1 ≤ n ≤ 3·105) — the number of users on the site. The next line contains integer sequence a1, a2, ..., an (1 ≤ ai ≤ 109).
|
Print a sequence of integers b1, b2, ..., bn. Number bi means that user i gets bi of rating as a present. The printed sequence must meet the problem conditions.
If there are multiple optimal solutions, print any of them.
| null | null |
[{"input": "3\n5 1 1", "output": "5 1 2"}, {"input": "1\n1000000000", "output": "1000000000"}]
| 1,400 |
["greedy", "sortings"]
| 41 |
[{"input": "3\r\n5 1 1\r\n", "output": "5 1 2\r\n"}, {"input": "1\r\n1000000000\r\n", "output": "1000000000\r\n"}, {"input": "10\r\n1 1 1 1 1 1 1 1 1 1\r\n", "output": "1 2 3 4 5 6 7 8 9 10\r\n"}, {"input": "10\r\n1 10 1 10 1 1 7 8 6 7\r\n", "output": "1 10 2 11 3 4 7 9 6 8\r\n"}, {"input": "10\r\n20 19 12 1 12 15 2 12 6 10\r\n", "output": "20 19 12 1 13 15 2 14 6 10\r\n"}, {"input": "10\r\n4 5 10 5 2 14 15 6 10 6\r\n", "output": "4 5 10 6 2 14 15 7 11 8\r\n"}]
| false |
stdio
| null | true |
856/A
|
856
|
A
|
Python 3
|
TESTS
| 3 | 61 | 0 |
30961666
|
t = int(input())
for i in range(t):
n = int(input())
list = [int(x) for x in input().split()]
s = set(list)
if (len(s) != n):
print("NO")
else:
gap = max(set(list)) + 1
ans = [i*gap for i in range(1, n+1)]
print ("YES")
print (*ans, sep = ' ')
| 11 | 452 | 819,200 |
198737758
|
from random import randint
def solve():
n, aa = int(input()), list(map(int, input().split()))
bb, ab = set(), set()
while True:
b = randint(1, 1000000)
for a in aa:
if a + b in ab:
break
else:
bb.add(b)
if len(bb) == n:
break
for a in aa:
ab.add(a + b)
print("YES")
print(' '.join(map(str, bb)))
t = int(input())
for i in range(t):
solve()
|
Russian Code Cup 2017 - Finals [Unofficial Mirror, Div. 1 Only Recommended, Teams Allowed]
|
ICPC
| 2,017 | 1 | 256 |
Set Theory
|
Masha and Grisha like studying sets of positive integers.
One day Grisha has written a set A containing n different integers ai on a blackboard. Now he asks Masha to create a set B containing n different integers bj such that all n2 integers that can be obtained by summing up ai and bj for all possible pairs of i and j are different.
Both Masha and Grisha don't like big numbers, so all numbers in A are from 1 to 106, and all numbers in B must also be in the same range.
Help Masha to create the set B that satisfies Grisha's requirement.
|
Input data contains multiple test cases. The first line contains an integer t — the number of test cases (1 ≤ t ≤ 100).
Each test case is described in the following way: the first line of the description contains one integer n — the number of elements in A (1 ≤ n ≤ 100).
The second line contains n integers ai — the elements of A (1 ≤ ai ≤ 106).
|
For each test first print the answer:
- NO, if Masha's task is impossible to solve, there is no way to create the required set B.
- YES, if there is the way to create the required set. In this case the second line must contain n different positive integers bj — elements of B (1 ≤ bj ≤ 106). If there are several possible sets, output any of them.
| null | null |
[{"input": "3\n3\n1 10 100\n1\n1\n2\n2 4", "output": "YES\n1 2 3\nYES\n1\nYES\n1 2"}]
| 1,600 |
["brute force", "constructive algorithms"]
| 11 |
[{"input": "3\r\n3\r\n1 10 100\r\n1\r\n1\r\n2\r\n2 4\r\n", "output": "YES\r\n1 2 3 \r\nYES\r\n1 \r\nYES\r\n1 2 \r\n"}, {"input": "1\r\n100\r\n74 14 24 45 22 9 49 78 79 20 60 1 31 91 32 39 90 5 42 57 30 58 64 68 12 11 86 8 3 38 76 17 98 26 85 92 56 65 89 66 36 87 23 67 13 48 15 47 81 73 63 50 34 93 82 44 77 69 96 100 41 19 35 16 88 27 99 40 62 95 70 18 46 21 53 59 37 6 61 71 2 4 52 28 97 25 29 51 7 33 80 83 72 10 75 94 43 84 54 55\r\n", "output": "YES\r\n1 101 201 301 401 501 601 701 801 901 1001 1101 1201 1301 1401 1501 1601 1701 1801 1901 2001 2101 2201 2301 2401 2501 2601 2701 2801 2901 3001 3101 3201 3301 3401 3501 3601 3701 3801 3901 4001 4101 4201 4301 4401 4501 4601 4701 4801 4901 5001 5101 5201 5301 5401 5501 5601 5701 5801 5901 6001 6101 6201 6301 6401 6501 6601 6701 6801 6901 7001 7101 7201 7301 7401 7501 7601 7701 7801 7901 8001 8101 8201 8301 8401 8501 8601 8701 8801 8901 9001 9101 9201 9301 9401 9501 9601 9701 9801 9901 \r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(input_path) as f_in, open(submission_path) as f_sub:
input_lines = list(f_in.readlines())
sub_lines = list(f_sub.readlines())
t = int(input_lines[0].strip())
ptr = 1
sub_ptr = 0
for _ in range(t):
n = int(input_lines[ptr].strip())
ptr +=1
a_list = list(map(int, input_lines[ptr].strip().split()))
ptr +=1
if sub_ptr >= len(sub_lines):
print(0)
return
case_line = sub_lines[sub_ptr].strip().upper()
sub_ptr +=1
if case_line not in ['YES', 'NO']:
print(0)
return
if case_line == 'NO':
print(0)
return
else:
if sub_ptr >= len(sub_lines):
print(0)
return
b_line = sub_lines[sub_ptr].strip()
sub_ptr +=1
try:
b_list = list(map(int, b_line.split()))
except:
print(0)
return
if len(b_list) != n:
print(0)
return
if len(set(b_list)) != n:
print(0)
return
if any(b < 1 or b > 10**6 for b in b_list):
print(0)
return
sums = set()
for a in a_list:
for b in b_list:
s = a + b
if s in sums:
print(0)
return
sums.add(s)
print(1)
if __name__ == "__main__":
main()
| true |
856/A
|
856
|
A
|
Python 3
|
TESTS
| 3 | 77 | 102,400 |
30763377
|
test_number = int(input())
for _ in range(test_number):
a_size = int(input())
a = [int(i) for i in input().split()]
if sorted(set(a)) != sorted(a):
print("NO")
else:
b = []
for i in range(a_size):
b.append(max(a)*i + 1)
if max(b) < 10**6:
print("YES")
print(*[str(b_i) for b_i in b], sep=' ')
else:
print("NO")
| 11 | 499 | 10,240,000 |
77382547
|
visited = [-1] * (2 * 10 ** 6 + 1)
t = int(input())
for i in range(t):
n, A = int(input()), list(map(int, input().split()))
A.sort()
res = []
v = 1
while len(res) < n:
flag = True
for a in A:
if visited[a + v] == i:
flag = False
break
if not flag:
v += 1
continue
for a in A:
visited[a + v] = i
res.append(v)
v += 1
print("YES\n" + ' '.join(map(str,res)))
|
Russian Code Cup 2017 - Finals [Unofficial Mirror, Div. 1 Only Recommended, Teams Allowed]
|
ICPC
| 2,017 | 1 | 256 |
Set Theory
|
Masha and Grisha like studying sets of positive integers.
One day Grisha has written a set A containing n different integers ai on a blackboard. Now he asks Masha to create a set B containing n different integers bj such that all n2 integers that can be obtained by summing up ai and bj for all possible pairs of i and j are different.
Both Masha and Grisha don't like big numbers, so all numbers in A are from 1 to 106, and all numbers in B must also be in the same range.
Help Masha to create the set B that satisfies Grisha's requirement.
|
Input data contains multiple test cases. The first line contains an integer t — the number of test cases (1 ≤ t ≤ 100).
Each test case is described in the following way: the first line of the description contains one integer n — the number of elements in A (1 ≤ n ≤ 100).
The second line contains n integers ai — the elements of A (1 ≤ ai ≤ 106).
|
For each test first print the answer:
- NO, if Masha's task is impossible to solve, there is no way to create the required set B.
- YES, if there is the way to create the required set. In this case the second line must contain n different positive integers bj — elements of B (1 ≤ bj ≤ 106). If there are several possible sets, output any of them.
| null | null |
[{"input": "3\n3\n1 10 100\n1\n1\n2\n2 4", "output": "YES\n1 2 3\nYES\n1\nYES\n1 2"}]
| 1,600 |
["brute force", "constructive algorithms"]
| 11 |
[{"input": "3\r\n3\r\n1 10 100\r\n1\r\n1\r\n2\r\n2 4\r\n", "output": "YES\r\n1 2 3 \r\nYES\r\n1 \r\nYES\r\n1 2 \r\n"}, {"input": "1\r\n100\r\n74 14 24 45 22 9 49 78 79 20 60 1 31 91 32 39 90 5 42 57 30 58 64 68 12 11 86 8 3 38 76 17 98 26 85 92 56 65 89 66 36 87 23 67 13 48 15 47 81 73 63 50 34 93 82 44 77 69 96 100 41 19 35 16 88 27 99 40 62 95 70 18 46 21 53 59 37 6 61 71 2 4 52 28 97 25 29 51 7 33 80 83 72 10 75 94 43 84 54 55\r\n", "output": "YES\r\n1 101 201 301 401 501 601 701 801 901 1001 1101 1201 1301 1401 1501 1601 1701 1801 1901 2001 2101 2201 2301 2401 2501 2601 2701 2801 2901 3001 3101 3201 3301 3401 3501 3601 3701 3801 3901 4001 4101 4201 4301 4401 4501 4601 4701 4801 4901 5001 5101 5201 5301 5401 5501 5601 5701 5801 5901 6001 6101 6201 6301 6401 6501 6601 6701 6801 6901 7001 7101 7201 7301 7401 7501 7601 7701 7801 7901 8001 8101 8201 8301 8401 8501 8601 8701 8801 8901 9001 9101 9201 9301 9401 9501 9601 9701 9801 9901 \r\n"}]
| false |
stdio
|
import sys
def main():
input_path = sys.argv[1]
output_path = sys.argv[2]
submission_path = sys.argv[3]
with open(input_path) as f_in, open(submission_path) as f_sub:
input_lines = list(f_in.readlines())
sub_lines = list(f_sub.readlines())
t = int(input_lines[0].strip())
ptr = 1
sub_ptr = 0
for _ in range(t):
n = int(input_lines[ptr].strip())
ptr +=1
a_list = list(map(int, input_lines[ptr].strip().split()))
ptr +=1
if sub_ptr >= len(sub_lines):
print(0)
return
case_line = sub_lines[sub_ptr].strip().upper()
sub_ptr +=1
if case_line not in ['YES', 'NO']:
print(0)
return
if case_line == 'NO':
print(0)
return
else:
if sub_ptr >= len(sub_lines):
print(0)
return
b_line = sub_lines[sub_ptr].strip()
sub_ptr +=1
try:
b_list = list(map(int, b_line.split()))
except:
print(0)
return
if len(b_list) != n:
print(0)
return
if len(set(b_list)) != n:
print(0)
return
if any(b < 1 or b > 10**6 for b in b_list):
print(0)
return
sums = set()
for a in a_list:
for b in b_list:
s = a + b
if s in sums:
print(0)
return
sums.add(s)
print(1)
if __name__ == "__main__":
main()
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.