node_ids
sequencelengths 4
1.4k
| edge_index
sequencelengths 1
2.22k
| text
sequencelengths 4
1.4k
| source
stringlengths 14
427k
|
|---|---|---|---|
[
7,
15,
15,
15,
13,
15,
13,
15,
13,
15,
13,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
4,
13,
13,
12,
13,
12,
13,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
4,
13,
13,
12,
13,
12,
13,
0,
13,
4,
13,
4,
18,
18,
13,
13,
13,
14,
2,
18,
13,
17,
17,
29,
18,
13,
39,
17,
29,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
29,
13,
23,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
29,
13,
23,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
29,
13,
23,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
29,
13,
23,
13,
4,
18,
13,
13,
17,
0,
13,
17,
12,
13,
29,
12,
13,
0,
13,
4,
13,
13,
0,
13,
2,
39,
17,
13,
0,
13,
2,
39,
17,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
0,
13,
17,
14,
18,
13,
13,
0,
18,
13,
13,
17,
0,
18,
13,
13,
17,
0,
18,
13,
13,
17,
14,
2,
18,
13,
13,
17,
0,
18,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
18,
13,
13,
0,
13,
17,
4,
13,
13,
29,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
3,
4,
13,
17,
29,
0,
13,
2,
2,
4,
13,
4,
13,
17,
2,
13,
17,
18,
4,
13,
4,
13,
2,
13,
17,
13,
39,
17,
39,
2,
13,
17,
4,
13,
17,
28,
13,
13,
4,
13,
13,
29,
12,
13,
29,
12,
13,
29,
12,
13,
29,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
17,
13
] | [
[
14,
13
],
[
13,
26
],
[
34,
33
],
[
33,
46
],
[
53,
52
],
[
52,
64
],
[
52,
69
],
[
52,
73
],
[
79,
78
],
[
88,
81
],
[
332,
84
],
[
88,
88
],
[
94,
93
],
[
103,
96
],
[
350,
99
],
[
103,
103
],
[
109,
108
],
[
118,
111
],
[
356,
114
],
[
118,
118
],
[
124,
123
],
[
133,
126
],
[
323,
129
],
[
133,
133
],
[
364,
140
],
[
149,
148
],
[
350,
150
],
[
149,
151
],
[
154,
153
],
[
148,
157
],
[
160,
159
],
[
148,
163
],
[
168,
165
],
[
159,
166
],
[
171,
170
],
[
151,
173
],
[
176,
175
],
[
350,
177
],
[
176,
178
],
[
181,
180
],
[
184,
183
],
[
159,
187
],
[
180,
188
],
[
175,
188
],
[
193,
190
],
[
159,
191
],
[
183,
192
],
[
178,
192
],
[
198,
195
],
[
153,
196
],
[
180,
197
],
[
175,
197
],
[
203,
200
],
[
153,
201
],
[
183,
202
],
[
178,
202
],
[
195,
206
],
[
153,
207
],
[
180,
208
],
[
175,
208
],
[
214,
211
],
[
159,
212
],
[
180,
213
],
[
175,
213
],
[
217,
216
],
[
220,
219
],
[
148,
222
],
[
159,
225
],
[
219,
226
],
[
229,
228
],
[
228,
232
],
[
216,
232
],
[
238,
237
],
[
350,
239
],
[
238,
240
],
[
243,
242
],
[
350,
244
],
[
247,
246
],
[
237,
250
],
[
242,
256
],
[
246,
257
],
[
242,
259
],
[
246,
261
],
[
240,
263
],
[
271,
270
],
[
237,
289
],
[
301,
300
],
[
270,
300
],
[
300,
304
],
[
326,
320
],
[
364,
365
]
] | [
"#!usr/bin/env python3\nfrom collections import defaultdict,deque\nfrom heapq import heappush, heappop\nimport sys\nimport math\nimport bisect\nimport random\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef I(): return int(sys.stdin.readline())\ndef LS():return [list(x) for x in sys.stdin.readline().split()]\ndef S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res\ndef IR(n):\n return [I() for i in range(n)]\ndef LIR(n):\n return [LI() for i in range(n)]\ndef SR(n):\n return [S() for i in range(n)]\ndef LSR(n):\n return [LS() for i in range(n)]\n\nsys.setrecursionlimit(1000000)\nmod = 1000000007\n\n#A\ndef A():\n\n return\n\n#B\ndef B():\n n,m = LI()\n f = [1]*n\n l = [0]*n\n l[0] = 1\n for i in range(m):\n x,y = LI()\n x -= 1\n y -= 1\n if l[x]:\n l[y] = 1\n f[x] -= 1\n f[y] += 1\n if f[x] == 0:\n l[x] = 0\n ans = 0\n for i in range(n):\n if l[i]:\n ans += 1\n print(ans)\n return\n\n#C\ndef C():\n n,l = LI()\n a = LI()\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n break\n else:\n print(\"Impossible\")\n return\n ans = list(range(1,i+1))+list(range(i+2,n))[::-1]+[i+1]\n print(\"Possible\")\n for i in ans:\n print(i)\n return\n\n#D\ndef D():\n\n return\n\n#E\ndef E():\n\n return\n\n#F\ndef F():\n\n return\n\n#Solve\nif __name__ == \"__main__\":\n C()",
"from collections import defaultdict,deque",
"from heapq import heappush, heappop",
"import sys",
"sys",
"import math",
"math",
"import bisect",
"bisect",
"import random",
"random",
"int(x) for x in sys.stdin.readline().split()",
"for x in sys.stdin.readline().split()",
"x",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"for x in sys.stdin.readline().split()",
"int(x)",
"int",
"x",
"def LI(): return [int(x) for x in sys.stdin.readline().split()]",
"LI",
"def I(): return int(sys.stdin.readline())",
"I",
"list(x) for x in sys.stdin.readline().split()",
"for x in sys.stdin.readline().split()",
"x",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"for x in sys.stdin.readline().split()",
"list(x)",
"list",
"x",
"def LS():return [list(x) for x in sys.stdin.readline().split()]",
"LS",
"def S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res",
"S",
"res = list(sys.stdin.readline())",
"res",
"list(sys.stdin.readline())",
"list",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"if res[-1] == \"\\n\":\n return res[:-1]\n ",
"res[-1] == \"\\n\"",
"res[-1]",
"res",
"-1",
"\"\\n\"",
"return res[:-1]",
"res[:-1]",
"res",
":-1",
"-1",
"return res",
"res",
"def IR(n):\n return [I() for i in range(n)]",
"IR",
"I() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"I()",
"I",
"return [I() for i in range(n)]",
"[I() for i in range(n)]",
"n",
"n",
"def LIR(n):\n return [LI() for i in range(n)]",
"LIR",
"LI() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"LI()",
"LI",
"return [LI() for i in range(n)]",
"[LI() for i in range(n)]",
"n",
"n",
"def SR(n):\n return [S() for i in range(n)]",
"SR",
"S() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"S()",
"S",
"return [S() for i in range(n)]",
"[S() for i in range(n)]",
"n",
"n",
"def LSR(n):\n return [LS() for i in range(n)]",
"LSR",
"LS() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"LS()",
"LS",
"return [LS() for i in range(n)]",
"[LS() for i in range(n)]",
"n",
"n",
"sys.setrecursionlimit(1000000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"1000000",
"mod = 1000000007",
"mod",
"1000000007",
"def A():\n\n return\n\n#B",
"A",
"return",
"def B():\n n,m = LI()\n f = [1]*n\n l = [0]*n\n l[0] = 1\n for i in range(m):\n x,y = LI()\n x -= 1\n y -= 1\n if l[x]:\n l[y] = 1\n f[x] -= 1\n f[y] += 1\n if f[x] == 0:\n l[x] = 0\n ans = 0\n for i in range(n):\n if l[i]:\n ans += 1\n print(ans)\n return\n\n#C",
"B",
"n,m = LI()",
"n",
"LI()",
"LI",
"m",
"f = [1]*n",
"f",
"[1]*n",
"[1]",
"1",
"n",
"l = [0]*n",
"l",
"[0]*n",
"[0]",
"0",
"n",
"l[0] = 1",
"l[0]",
"l",
"0",
"1",
"for i in range(m):\n x,y = LI()\n x -= 1\n y -= 1\n if l[x]:\n l[y] = 1\n f[x] -= 1\n f[y] += 1\n if f[x] == 0:\n l[x] = 0\n ",
"i",
"range(m)",
"range",
"m",
"x,y = LI()",
"x",
"LI()",
"LI",
"y",
"x -= 1",
"x",
"1",
"y -= 1",
"y",
"1",
"if l[x]:\n l[y] = 1\n ",
"l[x]",
"l",
"x",
"l[y] = 1",
"l[y]",
"l",
"y",
"1",
"f[x] -= 1",
"f[x]",
"f",
"x",
"1",
"f[y] += 1",
"f[y]",
"f",
"y",
"1",
"if f[x] == 0:\n l[x] = 0\n ",
"f[x] == 0",
"f[x]",
"f",
"x",
"0",
"l[x] = 0",
"l[x]",
"l",
"x",
"0",
"ans = 0",
"ans",
"0",
"for i in range(n):\n if l[i]:\n ans += 1\n ",
"i",
"range(n)",
"range",
"n",
"if l[i]:\n ans += 1\n ",
"l[i]",
"l",
"i",
"ans += 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"return",
"def C():\n n,l = LI()\n a = LI()\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n break\n else:\n print(\"Impossible\")\n return\n ans = list(range(1,i+1))+list(range(i+2,n))[::-1]+[i+1]\n print(\"Possible\")\n for i in ans:\n print(i)\n return\n\n#D",
"C",
"n,l = LI()",
"n",
"LI()",
"LI",
"l",
"a = LI()",
"a",
"LI()",
"LI",
"for i in range(n-1):\n if a[i]+a[i+1] >= l:\n break\n else:\n print(\"Impossible\")\n return\n ",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1] >= l:\n break\n ",
"a[i]+a[i+1] >= l",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"return",
"ans = list(range(1,i+1))+list(range(i+2,n))[::-1]+[i+1]",
"ans",
"list(range(1,i+1))+list(range(i+2,n))[::-1]+[i+1]",
"list(range(1,i+1))+list(range(i+2,n))[::-1]",
"list(range(1,i+1))",
"list",
"range(1,i+1)",
"range",
"1",
"i+1",
"i",
"1",
"list(range(i+2,n))[::-1]",
"(range(i+2,n))",
"list",
"range(i+2,n)",
"range",
"i+2",
"i",
"2",
"n",
"::-1",
"-1",
"[i+1]",
"i+1",
"i",
"1",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in ans:\n print(i)\n ",
"i",
"ans",
"print(i)",
"print",
"i",
"return",
"def D():\n\n return\n\n#E",
"D",
"return",
"def E():\n\n return\n\n#F",
"E",
"return",
"def F():\n\n return\n\n#Solve",
"F",
"return",
"if __name__ == \"__main__\":\n C()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"C()",
"C",
"def LS():return [list(x) for x in sys.stdin.readline().split()]",
"def LS():return [list(x) for x in sys.stdin.readline().split()]",
"LS",
"def C():\n n,l = LI()\n a = LI()\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n break\n else:\n print(\"Impossible\")\n return\n ans = list(range(1,i+1))+list(range(i+2,n))[::-1]+[i+1]\n print(\"Possible\")\n for i in ans:\n print(i)\n return\n\n#D",
"def C():\n n,l = LI()\n a = LI()\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n break\n else:\n print(\"Impossible\")\n return\n ans = list(range(1,i+1))+list(range(i+2,n))[::-1]+[i+1]\n print(\"Possible\")\n for i in ans:\n print(i)\n return\n\n#D",
"C",
"def E():\n\n return\n\n#F",
"def E():\n\n return\n\n#F",
"E",
"def I(): return int(sys.stdin.readline())",
"def I(): return int(sys.stdin.readline())",
"I",
"def IR(n):\n return [I() for i in range(n)]",
"def IR(n):\n return [I() for i in range(n)]",
"IR",
"def B():\n n,m = LI()\n f = [1]*n\n l = [0]*n\n l[0] = 1\n for i in range(m):\n x,y = LI()\n x -= 1\n y -= 1\n if l[x]:\n l[y] = 1\n f[x] -= 1\n f[y] += 1\n if f[x] == 0:\n l[x] = 0\n ans = 0\n for i in range(n):\n if l[i]:\n ans += 1\n print(ans)\n return\n\n#C",
"def B():\n n,m = LI()\n f = [1]*n\n l = [0]*n\n l[0] = 1\n for i in range(m):\n x,y = LI()\n x -= 1\n y -= 1\n if l[x]:\n l[y] = 1\n f[x] -= 1\n f[y] += 1\n if f[x] == 0:\n l[x] = 0\n ans = 0\n for i in range(n):\n if l[i]:\n ans += 1\n print(ans)\n return\n\n#C",
"B",
"def F():\n\n return\n\n#Solve",
"def F():\n\n return\n\n#Solve",
"F",
"def LSR(n):\n return [LS() for i in range(n)]",
"def LSR(n):\n return [LS() for i in range(n)]",
"LSR",
"def D():\n\n return\n\n#E",
"def D():\n\n return\n\n#E",
"D",
"def LI(): return [int(x) for x in sys.stdin.readline().split()]",
"def LI(): return [int(x) for x in sys.stdin.readline().split()]",
"LI",
"def A():\n\n return\n\n#B",
"def A():\n\n return\n\n#B",
"A",
"def S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res",
"def S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res",
"S",
"def LIR(n):\n return [LI() for i in range(n)]",
"def LIR(n):\n return [LI() for i in range(n)]",
"LIR",
"def SR(n):\n return [S() for i in range(n)]",
"def SR(n):\n return [S() for i in range(n)]",
"SR",
"mod = 1000000007",
"1000000007",
"mod"
] | #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
return
#B
def B():
n,m = LI()
f = [1]*n
l = [0]*n
l[0] = 1
for i in range(m):
x,y = LI()
x -= 1
y -= 1
if l[x]:
l[y] = 1
f[x] -= 1
f[y] += 1
if f[x] == 0:
l[x] = 0
ans = 0
for i in range(n):
if l[i]:
ans += 1
print(ans)
return
#C
def C():
n,l = LI()
a = LI()
for i in range(n-1):
if a[i]+a[i+1] >= l:
break
else:
print("Impossible")
return
ans = list(range(1,i+1))+list(range(i+2,n))[::-1]+[i+1]
print("Possible")
for i in ans:
print(i)
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#Solve
if __name__ == "__main__":
C()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
17,
4,
13,
13,
14,
2,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
2,
4,
13,
13,
13,
17,
4,
13,
2,
2,
4,
13,
13,
17,
13,
4,
13,
13,
4,
13,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
91,
2
],
[
91,
11
],
[
88,
13
],
[
26,
25
],
[
89,
31
],
[
89,
36
],
[
25,
37
],
[
89,
39
],
[
25,
41
],
[
92,
43
],
[
49,
48
],
[
25,
52
],
[
48,
55
],
[
58,
57
],
[
89,
64
],
[
25,
65
],
[
89,
73
],
[
57,
75
],
[
25,
78
],
[
91,
86
],
[
88,
89
],
[
91,
92
]
] | [
"N,L=map(int,input().split())\n\na=list(map(int,input().split()))\n\n\nfor i in range(1,len(a)):\n if a[i]+a[i-1]<L:\n pass\n else:\n print(\"Possible\")\n for j in range(1,i):\n print(j)\n for k in range(len(a)-i-1):\n print(len(a)-1-k)\n print(i)\n exit()\nprint(\"Impossible\")",
"N,L=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(1,len(a)):\n if a[i]+a[i-1]<L:\n pass\n else:\n print(\"Possible\")\n for j in range(1,i):\n print(j)\n for k in range(len(a)-i-1):\n print(len(a)-1-k)\n print(i)\n exit()",
"i",
"range(1,len(a))",
"range",
"1",
"len(a)",
"len",
"a",
"if a[i]+a[i-1]<L:\n pass\n else:\n print(\"Possible\")\n for j in range(1,i):\n print(j)\n for k in range(len(a)-i-1):\n print(len(a)-1-k)\n print(i)\n exit()",
"a[i]+a[i-1]<L",
"a[i]+a[i-1]",
"a[i]",
"a",
"i",
"a[i-1]",
"a",
"i-1",
"i",
"1",
"L",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for j in range(1,i):\n print(j)\n ",
"j",
"range(1,i)",
"range",
"1",
"i",
"print(j)",
"print",
"j",
"for k in range(len(a)-i-1):\n print(len(a)-1-k)\n ",
"k",
"range(len(a)-i-1)",
"range",
"len(a)-i-1",
"len(a)-i",
"len(a)",
"len",
"a",
"i",
"1",
"print(len(a)-1-k)",
"print",
"len(a)-1-k",
"len(a)-1",
"len(a)",
"len",
"a",
"1",
"k",
"print(i)",
"print",
"i",
"exit()",
"exit",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"N,L=map(int,input().split())",
"map(int,input().split())",
"N",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"L=map(int,input().split())",
"map(int,input().split())",
"L"
] | N,L=map(int,input().split())
a=list(map(int,input().split()))
for i in range(1,len(a)):
if a[i]+a[i-1]<L:
pass
else:
print("Possible")
for j in range(1,i):
print(j)
for k in range(len(a)-i-1):
print(len(a)-1-k)
print(i)
exit()
print("Impossible") |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
13,
28,
13,
4,
13,
17,
13,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
14,
2,
13,
13,
4,
13,
17,
4,
13,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
90,
2
],
[
90,
11
],
[
93,
13
],
[
96,
25
],
[
88,
26
],
[
29,
28
],
[
88,
32
],
[
94,
37
],
[
28,
38
],
[
94,
40
],
[
28,
42
],
[
91,
44
],
[
84,
46
],
[
28,
47
],
[
85,
50
],
[
97,
50
],
[
88,
51
],
[
62,
61
],
[
85,
65
],
[
97,
65
],
[
61,
68
],
[
71,
70
],
[
88,
74
],
[
85,
77
],
[
97,
77
],
[
70,
82
],
[
28,
84
],
[
84,
85
],
[
90,
88
],
[
90,
91
],
[
93,
94
],
[
88,
96
],
[
96,
97
]
] | [
"N,L = map(int,input().split())\na = list(map(int,input().split()))\nx = N\nfor i in range(1,N):\n if a[i] + a[i-1] >= L:\n x = i\nif x == N:\n print('Impossible')\n exit()\nprint('Possible')\nfor i in range(1,x):\n print(i)\nfor i in range(N-1,x-1,-1):\n print(i)",
"N,L = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x = N",
"x",
"N",
"for i in range(1,N):\n if a[i] + a[i-1] >= L:\n x = i",
"i",
"range(1,N)",
"range",
"1",
"N",
"if a[i] + a[i-1] >= L:\n x = i",
"a[i] + a[i-1] >= L",
"a[i] + a[i-1]",
"a[i]",
"a",
"i",
"a[i-1]",
"a",
"i-1",
"i",
"1",
"L",
"x = i",
"x",
"i",
"if x == N:\n print('Impossible')\n exit()",
"x == N",
"x",
"N",
"print('Impossible')",
"print",
"'Impossible'",
"exit()",
"exit",
"print('Possible')",
"print",
"'Possible'",
"for i in range(1,x):\n print(i)",
"i",
"range(1,x)",
"range",
"1",
"x",
"print(i)",
"print",
"i",
"for i in range(N-1,x-1,-1):\n print(i)",
"i",
"range(N-1,x-1,-1)",
"range",
"N-1",
"N",
"1",
"x-1",
"x",
"1",
"-1",
"print(i)",
"print",
"i",
"x = i",
"i",
"x",
"N,L = map(int,input().split())",
"map(int,input().split())",
"N",
"L = map(int,input().split())",
"map(int,input().split())",
"L",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"x = N",
"N",
"x"
] | N,L = map(int,input().split())
a = list(map(int,input().split()))
x = N
for i in range(1,N):
if a[i] + a[i-1] >= L:
x = i
if x == N:
print('Impossible')
exit()
print('Possible')
for i in range(1,x):
print(i)
for i in range(N-1,x-1,-1):
print(i)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
39,
13,
13,
4,
13,
4,
13,
13,
18,
13,
39,
17,
14,
40,
2,
13,
13,
13,
4,
13,
17,
3,
4,
13,
17,
4,
13,
0,
13,
39,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
13,
13,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
18,
13,
13,
13,
4,
18,
13,
13,
2,
13,
17,
4,
13,
31,
13,
0,
13,
17,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13
] | [
[
103,
2
],
[
103,
11
],
[
109,
13
],
[
110,
33
],
[
110,
35
],
[
104,
43
],
[
106,
54
],
[
58,
57
],
[
107,
66
],
[
57,
68
],
[
71,
70
],
[
101,
74
],
[
107,
82
],
[
70,
84
],
[
107,
87
],
[
107,
95
],
[
98,
97
],
[
103,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
]
] | [
"N,L = map(int,input().split())\nA = list(map(int,input().split()))\n\nfor i,(a,b) in enumerate(zip(A,A[1:])):\n if a+b >= L:\n print('Possible')\n break\nelse:\n print('Impossible')\n exit()\nans = []\nfor j in range(1,i+1):\n ans.append(j)\nfor j in range(N-1,i+1,-1):\n ans.append(j)\nans.append(i+1)\nprint(*ans, sep='\\n')",
"N,L = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i,(a,b) in enumerate(zip(A,A[1:])):\n if a+b >= L:\n print('Possible')\n break\nelse:\n print('Impossible')\n exit()",
"i",
"(a,b)",
"a",
"b",
"enumerate(zip(A,A[1:]))",
"enumerate",
"zip(A,A[1:])",
"zip",
"A",
"A[1:]",
"A",
"1:",
"1",
"if a+b >= L:\n print('Possible')\n break",
"a+b >= L",
"a+b",
"a",
"b",
"L",
"print('Possible')",
"print",
"'Possible'",
"break",
"print('Impossible')",
"print",
"'Impossible'",
"exit()",
"exit",
"ans = []",
"ans",
"[]",
"for j in range(1,i+1):\n ans.append(j)",
"j",
"range(1,i+1)",
"range",
"1",
"i+1",
"i",
"1",
"ans.append(j)",
"ans.append",
"ans",
"append",
"j",
"for j in range(N-1,i+1,-1):\n ans.append(j)",
"j",
"range(N-1,i+1,-1)",
"range",
"N-1",
"N",
"1",
"i+1",
"i",
"1",
"-1",
"ans.append(j)",
"ans.append",
"ans",
"append",
"j",
"ans.append(i+1)",
"ans.append",
"ans",
"append",
"i+1",
"i",
"1",
"print(*ans, sep='\\n')",
"print",
"*ans",
"ans",
"sep='\\n'",
"sep",
"'\\n'",
"N,L = map(int,input().split())",
"map(int,input().split())",
"N",
"L = map(int,input().split())",
"map(int,input().split())",
"L",
"ans = []",
"[]",
"ans",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A"
] | N,L = map(int,input().split())
A = list(map(int,input().split()))
for i,(a,b) in enumerate(zip(A,A[1:])):
if a+b >= L:
print('Possible')
break
else:
print('Impossible')
exit()
ans = []
for j in range(1,i+1):
ans.append(j)
for j in range(N-1,i+1,-1):
ans.append(j)
ans.append(i+1)
print(*ans, sep='\n') |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
31,
13,
0,
13,
17,
28,
13,
39,
13,
13,
4,
13,
4,
13,
13,
18,
13,
39,
17,
14,
40,
2,
13,
13,
13,
0,
13,
2,
13,
17,
4,
13,
17,
3,
4,
13,
17,
4,
13,
0,
13,
2,
2,
4,
13,
4,
13,
17,
13,
18,
4,
13,
4,
13,
2,
13,
17,
13,
39,
17,
39,
13,
4,
13,
4,
18,
17,
13,
4,
13,
13,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
2,
13
] | [
[
113,
4
],
[
107,
11
],
[
110,
18
],
[
114,
25
],
[
110,
27
],
[
110,
28
],
[
116,
31
],
[
105,
52
],
[
119,
54
],
[
101,
68
],
[
120,
76
],
[
117,
76
],
[
120,
83
],
[
117,
83
],
[
111,
85
],
[
102,
99
],
[
101,
102
],
[
110,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
]
] | [
"import sys\n\nread = sys.stdin.read\nreadline = sys.stdin.readline\n\nN, L, *a = map(int, read().split())\nknot = -1\nfor idx, (i, j) in enumerate(zip(a, a[1:])):\n if i + j >= L:\n knot = idx + 1\n print('Possible')\n break\nelse:\n print('Impossible')\n exit()\n\nanswer = list(range(1, knot)) + list(range(knot + 1, N))[::-1] + [knot]\nprint('\\n'.join(map(str, answer)))",
"import sys",
"sys",
"read = sys.stdin.read",
"read",
"sys.stdin.read",
"sys.stdin",
"sys",
"stdin",
"read",
"readline = sys.stdin.readline",
"readline",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"N, L, *a = map(int, read().split())",
"N",
"map(int, read().split())",
"map",
"int",
"read().split()",
"().split",
"()",
"read",
"split",
"L",
"*a",
"a",
"knot = -1",
"knot",
"-1",
"for idx, (i, j) in enumerate(zip(a, a[1:])):\n if i + j >= L:\n knot = idx + 1\n print('Possible')\n break\nelse:\n print('Impossible')\n exit()",
"idx",
"(i, j)",
"i",
"j",
"enumerate(zip(a, a[1:]))",
"enumerate",
"zip(a, a[1:])",
"zip",
"a",
"a[1:]",
"a",
"1:",
"1",
"if i + j >= L:\n knot = idx + 1\n print('Possible')\n break",
"i + j >= L",
"i + j",
"i",
"j",
"L",
"knot = idx + 1",
"knot",
"idx + 1",
"idx",
"1",
"print('Possible')",
"print",
"'Possible'",
"break",
"print('Impossible')",
"print",
"'Impossible'",
"exit()",
"exit",
"answer = list(range(1, knot)) + list(range(knot + 1, N))[::-1] + [knot]",
"answer",
"list(range(1, knot)) + list(range(knot + 1, N))[::-1] + [knot]",
"list(range(1, knot)) + list(range(knot + 1, N))[::-1]",
"list(range(1, knot))",
"list",
"range(1, knot)",
"range",
"1",
"knot",
"list(range(knot + 1, N))[::-1]",
"(range(knot + 1, N))",
"list",
"range(knot + 1, N)",
"range",
"knot + 1",
"knot",
"1",
"N",
"::-1",
"-1",
"[knot]",
"knot",
"print('\\n'.join(map(str, answer)))",
"print",
"'\\n'.join(map(str, answer))",
"'\\n'.join",
"'\\n'",
"join",
"map(str, answer)",
"map",
"str",
"answer",
"answer = list(range(1, knot)) + list(range(knot + 1, N))[::-1] + [knot]",
"list(range(1, knot)) + list(range(knot + 1, N))[::-1] + [knot]",
"answer",
"L, *a = map(int, read().split())",
"map(int, read().split())",
"L",
"readline = sys.stdin.readline",
"sys.stdin.readline",
"readline",
"N, L, *a = map(int, read().split())",
"map(int, read().split())",
"N",
"read = sys.stdin.read",
"sys.stdin.read",
"read",
"knot = -1",
"-1",
"knot",
"knot = idx + 1",
"idx + 1",
"knot"
] | import sys
read = sys.stdin.read
readline = sys.stdin.readline
N, L, *a = map(int, read().split())
knot = -1
for idx, (i, j) in enumerate(zip(a, a[1:])):
if i + j >= L:
knot = idx + 1
print('Possible')
break
else:
print('Impossible')
exit()
answer = list(range(1, knot)) + list(range(knot + 1, N))[::-1] + [knot]
print('\n'.join(map(str, answer)))
|
[
7,
41,
28,
13,
4,
18,
4,
13,
13,
17,
4,
4,
13,
13,
0,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
17,
4,
4,
13,
13,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
4,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
14,
40,
13,
13,
0,
13,
2,
13,
17,
3,
14,
2,
13,
17,
13,
13,
28,
13,
4,
13,
2,
4,
13,
13,
17,
2,
13,
17,
17,
13,
28,
13,
4,
13,
17,
13,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13
] | [
[
4,
3
],
[
3,
13
],
[
106,
15
],
[
106,
17
],
[
21,
20
],
[
20,
30
],
[
109,
32
],
[
97,
35
],
[
39,
38
],
[
110,
44
],
[
94,
46
],
[
110,
49
],
[
38,
50
],
[
110,
52
],
[
38,
54
],
[
101,
58
],
[
95,
59
],
[
103,
61
],
[
38,
63
],
[
104,
68
],
[
98,
68
],
[
74,
73
],
[
110,
79
],
[
104,
82
],
[
98,
82
],
[
88,
87
],
[
104,
91
],
[
98,
91
],
[
94,
95
],
[
97,
98
],
[
106,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
]
] | [
"N, L = [int(_) for _ in raw_input().split(\" \")]\nret = [int(_) for _ in raw_input().split(\" \")]\nindex = 0\nfor i in range(1, len(ret)):\n s = ret[i] + ret[i-1]\n if L <= s:\n index = i+1\n break\n\nif index == 0:\n print \"Impossible\"\nelse:\n print \"Possible\"\n for i in range(len(ret)-1, index-1, -1):\n print i\n for i in range(1, index):\n print i",
"int(_) for _ in raw_input().split(\" \")",
"for _ in raw_input().split(\" \")",
"_",
"raw_input().split(\" \")",
"().split",
"()",
"raw_input",
"split",
"\" \"",
"for _ in raw_input().split(\" \")",
"int(_)",
"int",
"_",
"N, L = [int(_) for _ in raw_input().split(\" \")]",
"N",
"[int(_) for _ in raw_input().split(\" \")]",
"L",
"int(_) for _ in raw_input().split(\" \")",
"for _ in raw_input().split(\" \")",
"_",
"raw_input().split(\" \")",
"().split",
"()",
"raw_input",
"split",
"\" \"",
"for _ in raw_input().split(\" \")",
"int(_)",
"int",
"_",
"ret = [int(_) for _ in raw_input().split(\" \")]",
"ret",
"[int(_) for _ in raw_input().split(\" \")]",
"index = 0",
"index",
"0",
"for i in range(1, len(ret)):\n s = ret[i] + ret[i-1]\n if L <= s:\n index = i+1\n break",
"i",
"range(1, len(ret))",
"range",
"1",
"len(ret)",
"len",
"ret",
"s = ret[i] + ret[i-1]",
"s",
"ret[i] + ret[i-1]",
"ret[i]",
"ret",
"i",
"ret[i-1]",
"ret",
"i-1",
"i",
"1",
"if L <= s:\n index = i+1\n break",
"L <= s",
"L",
"s",
"index = i+1",
"index",
"i+1",
"i",
"1",
"break",
"if index == 0:\n print \"Impossible\"\nelse:\n print \"Possible\"\n for i in range(len(ret)-1, index-1, -1):\n print i\n for i in range(1, index):\n print i",
"index == 0",
"index",
"0",
"print",
"print",
"for i in range(len(ret)-1, index-1, -1):\n print i\n ",
"i",
"range(len(ret)-1, index-1, -1)",
"range",
"len(ret)-1",
"len(ret)",
"len",
"ret",
"1",
"index-1",
"index",
"1",
"-1",
"print",
"for i in range(1, index):\n print i",
"i",
"range(1, index)",
"range",
"1",
"index",
"print",
"s = ret[i] + ret[i-1]",
"ret[i] + ret[i-1]",
"s",
"index = 0",
"0",
"index",
"L = [int(_) for _ in raw_input().split(\" \")]",
"[int(_) for _ in raw_input().split(\" \")]",
"L",
"index = i+1",
"i+1",
"index",
"N, L = [int(_) for _ in raw_input().split(\" \")]",
"[int(_) for _ in raw_input().split(\" \")]",
"N",
"ret = [int(_) for _ in raw_input().split(\" \")]",
"[int(_) for _ in raw_input().split(\" \")]",
"ret"
] | N, L = [int(_) for _ in raw_input().split(" ")]
ret = [int(_) for _ in raw_input().split(" ")]
index = 0
for i in range(1, len(ret)):
s = ret[i] + ret[i-1]
if L <= s:
index = i+1
break
if index == 0:
print "Impossible"
else:
print "Possible"
for i in range(len(ret)-1, index-1, -1):
print i
for i in range(1, index):
print i
|
[
7,
15,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
12,
4,
18,
4,
18,
18,
13,
13,
13,
13,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
3,
4,
13,
17,
29,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13
] | [
[
110,
9
],
[
119,
14
],
[
116,
21
],
[
36,
35
],
[
117,
42
],
[
36,
44
],
[
47,
46
],
[
117,
55
],
[
59,
58
],
[
35,
62
],
[
46,
68
],
[
58,
69
],
[
46,
71
],
[
58,
73
],
[
44,
75
],
[
86,
85
],
[
85,
94
],
[
97,
96
],
[
35,
100
],
[
96,
106
],
[
114,
108
],
[
110,
111
],
[
116,
117
],
[
119,
120
]
] | [
"import sys\nsys.setrecursionlimit(2147483647)\nINF=float(\"inf\")\nMOD=10**9+7\ninput=lambda:sys.stdin.readline().rstrip()\ndef resolve():\n n,L=map(int,input().split())\n A=list(map(int,input().split()))\n\n for i in range(n-1):\n if(A[i]+A[i+1]>=L):\n print(\"Possible\")\n break\n else:\n print(\"Impossible\")\n return\n\n for j in range(1,i+1):\n print(j)\n for j in range(n-1,i,-1):\n print(j)\nresolve()",
"import sys",
"sys",
"sys.setrecursionlimit(2147483647)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"2147483647",
"INF=float(\"inf\")",
"INF",
"float(\"inf\")",
"float",
"\"inf\"",
"MOD=10**9+7",
"MOD",
"10**9+7",
"10**9",
"10",
"9",
"7",
"input=lambda:sys.stdin.readline().rstrip()",
"input",
"lambda:sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"def resolve():\n n,L=map(int,input().split())\n A=list(map(int,input().split()))\n\n for i in range(n-1):\n if(A[i]+A[i+1]>=L):\n print(\"Possible\")\n break\n else:\n print(\"Impossible\")\n return\n\n for j in range(1,i+1):\n print(j)\n for j in range(n-1,i,-1):\n print(j)",
"resolve",
"n,L=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(n-1):\n if(A[i]+A[i+1]>=L):\n print(\"Possible\")\n break\n else:\n print(\"Impossible\")\n return\n\n ",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if(A[i]+A[i+1]>=L):\n print(\"Possible\")\n break\n ",
"A[i]+A[i+1]>=L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"print(\"Possible\")",
"print",
"\"Possible\"",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"return",
"for j in range(1,i+1):\n print(j)\n ",
"j",
"range(1,i+1)",
"range",
"1",
"i+1",
"i",
"1",
"print(j)",
"print",
"j",
"for j in range(n-1,i,-1):\n print(j)",
"j",
"range(n-1,i,-1)",
"range",
"n-1",
"n",
"1",
"i",
"-1",
"print(j)",
"print",
"j",
"resolve()",
"resolve",
"INF=float(\"inf\")",
"float(\"inf\")",
"INF",
"def resolve():\n n,L=map(int,input().split())\n A=list(map(int,input().split()))\n\n for i in range(n-1):\n if(A[i]+A[i+1]>=L):\n print(\"Possible\")\n break\n else:\n print(\"Impossible\")\n return\n\n for j in range(1,i+1):\n print(j)\n for j in range(n-1,i,-1):\n print(j)",
"def resolve():\n n,L=map(int,input().split())\n A=list(map(int,input().split()))\n\n for i in range(n-1):\n if(A[i]+A[i+1]>=L):\n print(\"Possible\")\n break\n else:\n print(\"Impossible\")\n return\n\n for j in range(1,i+1):\n print(j)\n for j in range(n-1,i,-1):\n print(j)",
"resolve",
"input=lambda:sys.stdin.readline().rstrip()",
"lambda:sys.stdin.readline().rstrip()",
"input",
"MOD=10**9+7",
"10**9+7",
"MOD"
] | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n,L=map(int,input().split())
A=list(map(int,input().split()))
for i in range(n-1):
if(A[i]+A[i+1]>=L):
print("Possible")
break
else:
print("Impossible")
return
for j in range(1,i+1):
print(j)
for j in range(n-1,i,-1):
print(j)
resolve() |
[
7,
12,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
17,
29,
39,
17,
39,
41,
28,
13,
4,
13,
13,
4,
2,
13,
17,
0,
13,
13,
4,
18,
13,
13,
2,
13,
17,
4,
18,
13,
13,
2,
13,
17,
29,
39,
17,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
13,
13,
13,
14,
40,
13,
4,
13,
17,
29,
4,
13,
17,
28,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
5,
4
],
[
8,
7
],
[
69,
11
],
[
73,
17
],
[
7,
18
],
[
73,
20
],
[
7,
22
],
[
71,
24
],
[
27,
26
],
[
7,
27
],
[
26,
31
],
[
4,
31
],
[
40,
39
],
[
26,
42
],
[
4,
42
],
[
39,
45
],
[
49,
48
],
[
48,
52
],
[
48,
59
],
[
26,
62
],
[
4,
62
],
[
69,
69
],
[
71,
71
],
[
73,
73
],
[
78,
77
],
[
78,
86
],
[
89,
88
],
[
101,
100
],
[
131,
102
],
[
77,
103
],
[
86,
104
],
[
88,
105
],
[
101,
106
],
[
100,
109
],
[
119,
118
],
[
106,
118
],
[
118,
122
],
[
134,
128
]
] | [
"#!/usr/bin/env python3\n\n\ndef solve(n, l, xs):\n pair_idx = None\n for i in range(n - 1):\n if xs[i] + xs[i + 1] >= l:\n pair_idx = i\n break\n if pair_idx is None:\n return (False, [])\n ans = [x + 1 for x in range(pair_idx)]\n ans.extend(x + 1 for x in range(pair_idx + 1, n - 1)[::-1])\n ans.append(pair_idx + 1)\n return (True, ans)\n\n\ndef main():\n n, l = map(int, input().split())\n xs = list(map(int, input().split()))\n judge, ans = solve(n, l, xs)\n if not judge:\n print(\"Impossible\")\n return\n print(\"Possible\")\n for a in ans:\n print(a)\n\n\nif __name__ == '__main__':\n main()",
"def solve(n, l, xs):\n pair_idx = None\n for i in range(n - 1):\n if xs[i] + xs[i + 1] >= l:\n pair_idx = i\n break\n if pair_idx is None:\n return (False, [])\n ans = [x + 1 for x in range(pair_idx)]\n ans.extend(x + 1 for x in range(pair_idx + 1, n - 1)[::-1])\n ans.append(pair_idx + 1)\n return (True, ans)",
"solve",
"pair_idx = None",
"pair_idx",
"None",
"for i in range(n - 1):\n if xs[i] + xs[i + 1] >= l:\n pair_idx = i\n break\n ",
"i",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"if xs[i] + xs[i + 1] >= l:\n pair_idx = i\n break\n ",
"xs[i] + xs[i + 1] >= l",
"xs[i] + xs[i + 1]",
"xs[i]",
"xs",
"i",
"xs[i + 1]",
"xs",
"i + 1",
"i",
"1",
"l",
"pair_idx = i",
"pair_idx",
"i",
"break",
"if pair_idx is None:\n return (False, [])\n ",
"pair_idx is None",
"pair_idx",
"None",
"return (False, [])",
"(False, [])",
"False",
"[]",
"x + 1 for x in range(pair_idx)",
"for x in range(pair_idx)",
"x",
"range(pair_idx)",
"range",
"pair_idx",
"for x in range(pair_idx)",
"x + 1",
"x",
"1",
"ans = [x + 1 for x in range(pair_idx)]",
"ans",
"[x + 1 for x in range(pair_idx)]",
"ans.extend(x + 1 for x in range(pair_idx + 1, n - 1)[::-1])",
"ans.extend",
"ans",
"extend",
"x + 1",
"x",
"1",
"ans.append(pair_idx + 1)",
"ans.append",
"ans",
"append",
"pair_idx + 1",
"pair_idx",
"1",
"return (True, ans)",
"(True, ans)",
"True",
"ans",
"n",
"n",
"l",
"l",
"xs",
"xs",
"def main():\n n, l = map(int, input().split())\n xs = list(map(int, input().split()))\n judge, ans = solve(n, l, xs)\n if not judge:\n print(\"Impossible\")\n return\n print(\"Possible\")\n for a in ans:\n print(a)",
"main",
"n, l = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"xs = list(map(int, input().split()))",
"xs",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"judge, ans = solve(n, l, xs)",
"judge",
"solve(n, l, xs)",
"solve",
"n",
"l",
"xs",
"ans",
"if not judge:\n print(\"Impossible\")\n return\n ",
"not judge",
"judge",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"return",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for a in ans:\n print(a)",
"a",
"ans",
"print(a)",
"print",
"a",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def solve(n, l, xs):\n pair_idx = None\n for i in range(n - 1):\n if xs[i] + xs[i + 1] >= l:\n pair_idx = i\n break\n if pair_idx is None:\n return (False, [])\n ans = [x + 1 for x in range(pair_idx)]\n ans.extend(x + 1 for x in range(pair_idx + 1, n - 1)[::-1])\n ans.append(pair_idx + 1)\n return (True, ans)",
"def solve(n, l, xs):\n pair_idx = None\n for i in range(n - 1):\n if xs[i] + xs[i + 1] >= l:\n pair_idx = i\n break\n if pair_idx is None:\n return (False, [])\n ans = [x + 1 for x in range(pair_idx)]\n ans.extend(x + 1 for x in range(pair_idx + 1, n - 1)[::-1])\n ans.append(pair_idx + 1)\n return (True, ans)",
"solve",
"def main():\n n, l = map(int, input().split())\n xs = list(map(int, input().split()))\n judge, ans = solve(n, l, xs)\n if not judge:\n print(\"Impossible\")\n return\n print(\"Possible\")\n for a in ans:\n print(a)",
"def main():\n n, l = map(int, input().split())\n xs = list(map(int, input().split()))\n judge, ans = solve(n, l, xs)\n if not judge:\n print(\"Impossible\")\n return\n print(\"Possible\")\n for a in ans:\n print(a)",
"main"
] | #!/usr/bin/env python3
def solve(n, l, xs):
pair_idx = None
for i in range(n - 1):
if xs[i] + xs[i + 1] >= l:
pair_idx = i
break
if pair_idx is None:
return (False, [])
ans = [x + 1 for x in range(pair_idx)]
ans.extend(x + 1 for x in range(pair_idx + 1, n - 1)[::-1])
ans.append(pair_idx + 1)
return (True, ans)
def main():
n, l = map(int, input().split())
xs = list(map(int, input().split()))
judge, ans = solve(n, l, xs)
if not judge:
print("Impossible")
return
print("Possible")
for a in ans:
print(a)
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
0,
13,
13,
14,
13,
4,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
13,
13,
4,
13,
2,
13,
17,
14,
2,
13,
13,
3,
28,
13,
4,
13,
2,
13,
17,
17,
17,
14,
2,
13,
13,
4,
13,
2,
13,
17,
14,
2,
13,
13,
3,
4,
13,
2,
13,
17,
4,
13,
17,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
125,
2
],
[
125,
11
],
[
119,
13
],
[
110,
25
],
[
29,
28
],
[
117,
32
],
[
120,
38
],
[
28,
39
],
[
120,
41
],
[
28,
43
],
[
126,
45
],
[
122,
47
],
[
113,
50
],
[
28,
51
],
[
59,
58
],
[
117,
62
],
[
58,
66
],
[
114,
67
],
[
58,
71
],
[
58,
75
],
[
114,
76
],
[
80,
79
],
[
117,
83
],
[
79,
89
],
[
114,
90
],
[
79,
94
],
[
79,
98
],
[
114,
99
],
[
114,
104
],
[
110,
111
],
[
28,
113
],
[
113,
114
],
[
125,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
]
] | [
"#%%\nn, l = map(int, input().split())\na = list(map(int, input().split()))\n\nflag = False\nfor i in range(n-1):\n if a[i] + a[i+1] >= l:\n flag = True\n pos = i\nif flag:\n print('Possible')\n for i in range(n-1):\n if i < pos:\n print(i+1)\n elif i == pos :\n break\n for i in range(n-2, -1, -1):\n if i > pos :\n print(i+1)\n elif i == pos :\n break\n print(pos+1)\nelse:\n print('Impossible')\n\n\n#%%",
"n, l = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"flag = False",
"flag",
"False",
"for i in range(n-1):\n if a[i] + a[i+1] >= l:\n flag = True\n pos = i",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i] + a[i+1] >= l:\n flag = True\n pos = i",
"a[i] + a[i+1] >= l",
"a[i] + a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"flag = True",
"flag",
"True",
"pos = i",
"pos",
"i",
"if flag:\n print('Possible')\n for i in range(n-1):\n if i < pos:\n print(i+1)\n elif i == pos :\n break\n for i in range(n-2, -1, -1):\n if i > pos :\n print(i+1)\n elif i == pos :\n break\n print(pos+1)\nelse:\n print('Impossible')\n\n\n#%%",
"flag",
"print('Possible')",
"print",
"'Possible'",
"for i in range(n-1):\n if i < pos:\n print(i+1)\n elif i == pos :\n break\n ",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if i < pos:\n print(i+1)\n elif i == pos :\n break\n ",
"i < pos",
"i",
"pos",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"elif i == pos :\n break\n ",
"i == pos",
"i",
"pos",
"break",
"for i in range(n-2, -1, -1):\n if i > pos :\n print(i+1)\n elif i == pos :\n break\n ",
"i",
"range(n-2, -1, -1)",
"range",
"n-2",
"n",
"2",
"-1",
"-1",
"if i > pos :\n print(i+1)\n elif i == pos :\n break\n ",
"i > pos",
"i",
"pos",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"elif i == pos :\n break\n ",
"i == pos",
"i",
"pos",
"break",
"print(pos+1)",
"print",
"pos+1",
"pos",
"1",
"print('Impossible')",
"print",
"'Impossible'",
"flag = False",
"False",
"flag",
"pos = i",
"i",
"pos",
"n, l = map(int, input().split())",
"map(int, input().split())",
"n",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"flag = True",
"True",
"flag",
"l = map(int, input().split())",
"map(int, input().split())",
"l"
] | #%%
n, l = map(int, input().split())
a = list(map(int, input().split()))
flag = False
for i in range(n-1):
if a[i] + a[i+1] >= l:
flag = True
pos = i
if flag:
print('Possible')
for i in range(n-1):
if i < pos:
print(i+1)
elif i == pos :
break
for i in range(n-2, -1, -1):
if i > pos :
print(i+1)
elif i == pos :
break
print(pos+1)
else:
print('Impossible')
#%%
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
31,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
18,
13,
17,
2,
13,
17,
0,
13,
4,
13,
18,
4,
13,
17,
2,
13,
17,
39,
17,
0,
13,
4,
13,
4,
13,
2,
13,
17,
13,
4,
13,
17,
4,
13,
31,
18,
13,
39,
17,
0,
13,
17,
3,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] | [
[
97,
2
],
[
97,
11
],
[
15,
13
],
[
106,
24
],
[
29,
28
],
[
98,
32
],
[
28,
39
],
[
28,
43
],
[
95,
45
],
[
50,
47
],
[
107,
48
],
[
101,
48
],
[
104,
48
],
[
28,
51
],
[
103,
54
],
[
28,
62
],
[
100,
67
],
[
28,
73
],
[
98,
75
],
[
101,
83
],
[
104,
83
],
[
107,
83
],
[
88,
87
],
[
97,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
]
] | [
"n,l=map(int,input().split())\n*a,=map(int,input().split())\nv=[0]\n\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n v[0]=i+1\n v+=list(range(1,i+1)[::-1])\n v+=list(range(i+2,n))\n print(\"Possible\")\n print(*v[::-1],sep=\"\\n\")\n break\nelse:\n print(\"Impossible\")",
"n,l=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"*a,=map(int,input().split())",
"*a",
"a",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"v=[0]",
"v",
"[0]",
"0",
"for i in range(n-1):\n if a[i]+a[i+1]>=l:\n v[0]=i+1\n v+=list(range(1,i+1)[::-1])\n v+=list(range(i+2,n))\n print(\"Possible\")\n print(*v[::-1],sep=\"\\n\")\n break\nelse:\n print(\"Impossible\")",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1]>=l:\n v[0]=i+1\n v+=list(range(1,i+1)[::-1])\n v+=list(range(i+2,n))\n print(\"Possible\")\n print(*v[::-1],sep=\"\\n\")\n break",
"a[i]+a[i+1]>=l",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"v[0]=i+1",
"v[0]",
"v",
"0",
"i+1",
"i",
"1",
"v+=list(range(1,i+1)[::-1])",
"v",
"list(range(1,i+1)[::-1])",
"list",
"range(1,i+1)[::-1]",
"(1,i+1)",
"range",
"1",
"i+1",
"i",
"1",
"::-1",
"-1",
"v+=list(range(i+2,n))",
"v",
"list(range(i+2,n))",
"list",
"range(i+2,n)",
"range",
"i+2",
"i",
"2",
"n",
"print(\"Possible\")",
"print",
"\"Possible\"",
"print(*v[::-1],sep=\"\\n\")",
"print",
"*v[::-1]",
"v[::-1]",
"v",
"::-1",
"-1",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"l=map(int,input().split())",
"map(int,input().split())",
"l",
"n,l=map(int,input().split())",
"map(int,input().split())",
"n",
"v+=list(range(i+2,n))",
"list(range(i+2,n))",
"v",
"v+=list(range(1,i+1)[::-1])",
"list(range(1,i+1)[::-1])",
"v",
"v=[0]",
"[0]",
"v"
] | n,l=map(int,input().split())
*a,=map(int,input().split())
v=[0]
for i in range(n-1):
if a[i]+a[i+1]>=l:
v[0]=i+1
v+=list(range(1,i+1)[::-1])
v+=list(range(i+2,n))
print("Possible")
print(*v[::-1],sep="\n")
break
else:
print("Impossible") |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
0,
13,
13,
3,
4,
13,
13,
14,
2,
13,
17,
4,
13,
28,
13,
4,
13,
17,
13,
4,
13,
2,
13,
17,
28,
13,
18,
4,
13,
2,
13,
17,
13,
39,
17,
4,
13,
13,
4,
13,
2,
13,
17,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13
] | [
[
105,
2
],
[
105,
11
],
[
111,
13
],
[
96,
25
],
[
114,
28
],
[
32,
31
],
[
100,
35
],
[
112,
41
],
[
31,
42
],
[
112,
44
],
[
31,
46
],
[
106,
48
],
[
102,
50
],
[
108,
53
],
[
31,
54
],
[
103,
58
],
[
97,
58
],
[
103,
61
],
[
97,
61
],
[
67,
66
],
[
109,
70
],
[
115,
70
],
[
66,
74
],
[
78,
77
],
[
109,
82
],
[
115,
82
],
[
100,
84
],
[
77,
89
],
[
109,
93
],
[
115,
93
],
[
96,
97
],
[
105,
100
],
[
102,
103
],
[
105,
106
],
[
31,
108
],
[
108,
109
],
[
111,
112
],
[
114,
115
]
] | [
"# coding: utf-8\n# Your code here!\nN,L=map(int,input().split())\nl=list(map(int,input().split()))\njudge=\"Impossible\"\nindex=0\n\nfor i in range(N-1):\n if (l[i]+l[i+1])>=L:\n judge=\"Possible\"\n index=i\n break\n\nprint(judge)\nif judge==\"Impossible\":\n exit()\n\nfor i in range(0,index):\n print(i+1)\n\nfor i in range(index+2,N)[::-1]:\n print(i)\n\nprint(index+1)\n\n",
"N,L=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"l=list(map(int,input().split()))",
"l",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"judge=\"Impossible\"",
"judge",
"\"Impossible\"",
"index=0",
"index",
"0",
"for i in range(N-1):\n if (l[i]+l[i+1])>=L:\n judge=\"Possible\"\n index=i\n break",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if (l[i]+l[i+1])>=L:\n judge=\"Possible\"\n index=i\n break",
"(l[i]+l[i+1])>=L",
"l[i]+l[i+1]",
"l[i]",
"l",
"i",
"l[i+1]",
"l",
"i+1",
"i",
"1",
"L",
"judge=\"Possible\"",
"judge",
"\"Possible\"",
"index=i",
"index",
"i",
"break",
"print(judge)",
"print",
"judge",
"if judge==\"Impossible\":\n exit()",
"judge==\"Impossible\"",
"judge",
"\"Impossible\"",
"exit()",
"exit",
"for i in range(0,index):\n print(i+1)",
"i",
"range(0,index)",
"range",
"0",
"index",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for i in range(index+2,N)[::-1]:\n print(i)",
"i",
"range(index+2,N)[::-1]",
"(index+2,N)",
"range",
"index+2",
"index",
"2",
"N",
"::-1",
"-1",
"print(i)",
"print",
"i",
"print(index+1)",
"print",
"index+1",
"index",
"1",
"judge=\"Impossible\"",
"\"Impossible\"",
"judge",
"N,L=map(int,input().split())",
"map(int,input().split())",
"N",
"judge=\"Possible\"",
"\"Possible\"",
"judge",
"L=map(int,input().split())",
"map(int,input().split())",
"L",
"index=i",
"i",
"index",
"l=list(map(int,input().split()))",
"list(map(int,input().split()))",
"l",
"index=0",
"0",
"index"
] | # coding: utf-8
# Your code here!
N,L=map(int,input().split())
l=list(map(int,input().split()))
judge="Impossible"
index=0
for i in range(N-1):
if (l[i]+l[i+1])>=L:
judge="Possible"
index=i
break
print(judge)
if judge=="Impossible":
exit()
for i in range(0,index):
print(i+1)
for i in range(index+2,N)[::-1]:
print(i)
print(index+1)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
14,
2,
13,
17,
14,
40,
4,
13,
13,
13,
4,
13,
17,
4,
13,
17,
4,
13,
17,
4,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
13,
17,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13
] | [
[
120,
2
],
[
120,
11
],
[
108,
13
],
[
121,
26
],
[
109,
32
],
[
112,
33
],
[
117,
47
],
[
51,
50
],
[
121,
54
],
[
109,
60
],
[
50,
61
],
[
109,
63
],
[
50,
65
],
[
112,
67
],
[
114,
69
],
[
50,
71
],
[
115,
76
],
[
118,
76
],
[
86,
85
],
[
115,
89
],
[
118,
89
],
[
85,
92
],
[
95,
94
],
[
121,
98
],
[
115,
101
],
[
118,
101
],
[
94,
106
],
[
108,
109
],
[
120,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
]
] | [
"N,L=map(int,input().split())\nA=list(map(int,input().split()))\nif N==2:\n if sum(A)>=L:\n print('Possible')\n print(1)\n else:\n print('Impossible')\n exit(0)\nlasti=-1\nfor i in range(N-1):\n if A[i]+A[i+1]>=L:\n lasti=i+1\n break\nif lasti==-1:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,lasti):\n print(i)\n for i in range(N-1,lasti-1,-1):\n print(i)",
"N,L=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"if N==2:\n if sum(A)>=L:\n print('Possible')\n print(1)\n else:\n print('Impossible')\n exit(0)",
"N==2",
"N",
"2",
"if sum(A)>=L:\n print('Possible')\n print(1)\n else:\n print('Impossible')\n ",
"sum(A)>=L",
"sum(A)",
"sum",
"A",
"L",
"print('Possible')",
"print",
"'Possible'",
"print(1)",
"print",
"1",
"print('Impossible')",
"print",
"'Impossible'",
"exit(0)",
"exit",
"0",
"lasti=-1",
"lasti",
"-1",
"for i in range(N-1):\n if A[i]+A[i+1]>=L:\n lasti=i+1\n break",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i]+A[i+1]>=L:\n lasti=i+1\n break",
"A[i]+A[i+1]>=L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"lasti=i+1",
"lasti",
"i+1",
"i",
"1",
"break",
"if lasti==-1:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,lasti):\n print(i)\n for i in range(N-1,lasti-1,-1):\n print(i)",
"lasti==-1",
"lasti",
"-1",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"for i in range(1,lasti):\n print(i)\n ",
"i",
"range(1,lasti)",
"range",
"1",
"lasti",
"print(i)",
"print",
"i",
"for i in range(N-1,lasti-1,-1):\n print(i)",
"i",
"range(N-1,lasti-1,-1)",
"range",
"N-1",
"N",
"1",
"lasti-1",
"lasti",
"1",
"-1",
"print(i)",
"print",
"i",
"A=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"L=map(int,input().split())",
"map(int,input().split())",
"L",
"lasti=i+1",
"i+1",
"lasti",
"lasti=-1",
"-1",
"lasti",
"N,L=map(int,input().split())",
"map(int,input().split())",
"N"
] | N,L=map(int,input().split())
A=list(map(int,input().split()))
if N==2:
if sum(A)>=L:
print('Possible')
print(1)
else:
print('Impossible')
exit(0)
lasti=-1
for i in range(N-1):
if A[i]+A[i+1]>=L:
lasti=i+1
break
if lasti==-1:
print('Impossible')
else:
print('Possible')
for i in range(1,lasti):
print(i)
for i in range(N-1,lasti-1,-1):
print(i) |
[
7,
0,
13,
17,
0,
13,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
2,
39,
17,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
14,
2,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
13,
14,
2,
13,
13,
4,
13,
13,
4,
13,
13,
28,
13,
4,
13,
17,
13,
14,
40,
13,
13,
4,
13,
13,
3,
28,
13,
4,
13,
4,
13,
17,
13,
14,
40,
13,
13,
4,
13,
13,
3,
4,
13,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13
] | [
[
118,
2
],
[
133,
5
],
[
139,
8
],
[
139,
17
],
[
127,
19
],
[
136,
34
],
[
142,
37
],
[
41,
40
],
[
140,
44
],
[
137,
47
],
[
131,
47
],
[
128,
50
],
[
40,
51
],
[
128,
53
],
[
40,
55
],
[
130,
58
],
[
137,
61
],
[
131,
61
],
[
128,
64
],
[
40,
65
],
[
128,
67
],
[
40,
69
],
[
121,
72
],
[
40,
73
],
[
131,
76
],
[
137,
76
],
[
125,
77
],
[
134,
80
],
[
119,
83
],
[
86,
85
],
[
140,
89
],
[
85,
92
],
[
122,
93
],
[
143,
93
],
[
85,
96
],
[
100,
99
],
[
140,
105
],
[
99,
108
],
[
122,
109
],
[
143,
109
],
[
99,
112
],
[
122,
116
],
[
143,
116
],
[
118,
119
],
[
40,
121
],
[
121,
122
],
[
139,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
]
] | [
"# def makelist(n, m):\n# \treturn [[0 for i in range(m)] for j in range(n)]\n\nyes = \"Possible\"\nno = \"Impossible\"\n\nN, L = map(int, input().split())\na = [0] + list(map(int, input().split()))\n\nc = 0\nMi = -1\nfor i in range(1, N):\n\tif c < a[i] + a[i+1]:\n\t\tc = max(c, a[i] + a[i+1])\n\t\tMi = i\n\nif c < L:\n\tprint(no)\nelse:\n\tprint(yes)\n\tfor i in range(1, N):\n\t\tif i != Mi:\n\t\t\tprint(i)\n\t\telse:\n\t\t\tbreak\n\tfor i in reversed(range(1, N)):\n\t\tif i != Mi:\n\t\t\tprint(i)\n\t\telse:\n\t\t\tbreak\n\tprint(Mi)",
"yes = \"Possible\"",
"yes",
"\"Possible\"",
"no = \"Impossible\"",
"no",
"\"Impossible\"",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"a = [0] + list(map(int, input().split()))",
"a",
"[0] + list(map(int, input().split()))",
"[0]",
"0",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"c = 0",
"c",
"0",
"Mi = -1",
"Mi",
"-1",
"for i in range(1, N):\n\tif c < a[i] + a[i+1]:\n\t\tc = max(c, a[i] + a[i+1])\n\t\tMi = i",
"i",
"range(1, N)",
"range",
"1",
"N",
"if c < a[i] + a[i+1]:\n\t\tc = max(c, a[i] + a[i+1])\n\t\tMi = i",
"c < a[i] + a[i+1]",
"c",
"a[i] + a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"c = max(c, a[i] + a[i+1])",
"c",
"max(c, a[i] + a[i+1])",
"max",
"c",
"a[i] + a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"Mi = i",
"Mi",
"i",
"if c < L:\n\tprint(no)\nelse:\n\tprint(yes)\n\tfor i in range(1, N):\n\t\tif i != Mi:\n\t\t\tprint(i)\n\t\telse:\n\t\t\tbreak\n\tfor i in reversed(range(1, N)):\n\t\tif i != Mi:\n\t\t\tprint(i)\n\t\telse:\n\t\t\tbreak\n\tprint(Mi)",
"c < L",
"c",
"L",
"print(no)",
"print",
"no",
"print(yes)",
"print",
"yes",
"for i in range(1, N):\n\t\tif i != Mi:\n\t\t\tprint(i)\n\t\telse:\n\t\t\tbreak\n\t",
"i",
"range(1, N)",
"range",
"1",
"N",
"if i != Mi:\n\t\t\tprint(i)\n\t\telse:\n\t\t\tbreak\n\t",
"i != Mi",
"i",
"Mi",
"print(i)",
"print",
"i",
"break",
"for i in reversed(range(1, N)):\n\t\tif i != Mi:\n\t\t\tprint(i)\n\t\telse:\n\t\t\tbreak\n\t",
"i",
"reversed(range(1, N))",
"reversed",
"range(1, N)",
"range",
"1",
"N",
"if i != Mi:\n\t\t\tprint(i)\n\t\telse:\n\t\t\tbreak\n\t",
"i != Mi",
"i",
"Mi",
"print(i)",
"print",
"i",
"break",
"print(Mi)",
"print",
"Mi",
"yes = \"Possible\"",
"\"Possible\"",
"yes",
"Mi = i",
"i",
"Mi",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"a = [0] + list(map(int, input().split()))",
"[0] + list(map(int, input().split()))",
"a",
"c = max(c, a[i] + a[i+1])",
"max(c, a[i] + a[i+1])",
"c",
"no = \"Impossible\"",
"\"Impossible\"",
"no",
"c = 0",
"0",
"c",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"Mi = -1",
"-1",
"Mi"
] | # def makelist(n, m):
# return [[0 for i in range(m)] for j in range(n)]
yes = "Possible"
no = "Impossible"
N, L = map(int, input().split())
a = [0] + list(map(int, input().split()))
c = 0
Mi = -1
for i in range(1, N):
if c < a[i] + a[i+1]:
c = max(c, a[i] + a[i+1])
Mi = i
if c < L:
print(no)
else:
print(yes)
for i in range(1, N):
if i != Mi:
print(i)
else:
break
for i in reversed(range(1, N)):
if i != Mi:
print(i)
else:
break
print(Mi)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
28,
13,
4,
13,
17,
13,
14,
40,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
13,
3,
4,
13,
17,
10,
13,
13,
10,
4,
13,
10,
4,
13
] | [
[
83,
2
],
[
83,
11
],
[
15,
14
],
[
14,
23
],
[
77,
25
],
[
29,
28
],
[
81,
32
],
[
78,
37
],
[
28,
39
],
[
78,
42
],
[
28,
43
],
[
84,
44
],
[
50,
49
],
[
28,
53
],
[
49,
56
],
[
59,
58
],
[
81,
62
],
[
28,
64
],
[
58,
68
],
[
28,
71
],
[
77,
78
],
[
83,
81
],
[
83,
84
]
] | [
"N, L = map(int, input().split())\nA = [int(a) for a in input().split()]\n\nfor i in range(1, N):\n if A[i-1] + A[i] >= L:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(N-1, i, -1):\n print(j)\n print(i)\n break\nelse:\n print(\"Impossible\")",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"int(a) for a in input().split()",
"for a in input().split()",
"a",
"input().split()",
"().split",
"()",
"input",
"split",
"for a in input().split()",
"int(a)",
"int",
"a",
"A = [int(a) for a in input().split()]",
"A",
"[int(a) for a in input().split()]",
"for i in range(1, N):\n if A[i-1] + A[i] >= L:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(N-1, i, -1):\n print(j)\n print(i)\n break\nelse:\n print(\"Impossible\")",
"i",
"range(1, N)",
"range",
"1",
"N",
"if A[i-1] + A[i] >= L:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(N-1, i, -1):\n print(j)\n print(i)\n break",
"A[i-1] + A[i] >= L",
"A[i-1] + A[i]",
"A[i-1]",
"A",
"i-1",
"i",
"1",
"A[i]",
"A",
"i",
"L",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for j in range(1, i):\n print(j)\n ",
"j",
"range(1, i)",
"range",
"1",
"i",
"print(j)",
"print",
"j",
"for j in range(N-1, i, -1):\n print(j)\n ",
"j",
"range(N-1, i, -1)",
"range",
"N-1",
"N",
"1",
"i",
"-1",
"print(j)",
"print",
"j",
"print(i)",
"print",
"i",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"A = [int(a) for a in input().split()]",
"[int(a) for a in input().split()]",
"A",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"L = map(int, input().split())",
"map(int, input().split())",
"L"
] | N, L = map(int, input().split())
A = [int(a) for a in input().split()]
for i in range(1, N):
if A[i-1] + A[i] >= L:
print("Possible")
for j in range(1, i):
print(j)
for j in range(N-1, i, -1):
print(j)
print(i)
break
else:
print("Impossible") |
[
7,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
2,
13,
17,
4,
13,
17,
4,
18,
13,
13,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13
] | [
[
110,
4
],
[
110,
13
],
[
98,
15
],
[
101,
27
],
[
31,
30
],
[
105,
34
],
[
99,
40
],
[
30,
41
],
[
99,
43
],
[
30,
45
],
[
111,
47
],
[
107,
49
],
[
30,
50
],
[
30,
54
],
[
105,
56
],
[
70,
69
],
[
108,
72
],
[
102,
72
],
[
69,
76
],
[
80,
79
],
[
105,
83
],
[
108,
85
],
[
102,
85
],
[
79,
90
],
[
108,
95
],
[
102,
95
],
[
98,
99
],
[
101,
102
],
[
110,
105
],
[
30,
107
],
[
107,
108
],
[
110,
111
]
] | [
"import sys\nn,x=map(int,input().split())\na=list(map(int,input().split()))\nk=-1\nfor i in range(n-1):\n if a[i]+a[i+1]>=x:\n k=i\n break\n if i==n-2:\n print('Impossible')\n sys.exit()\nprint('Possible')\nfor i in range(k):\n print(i+1)\nfor i in range(n-2,k,-1):\n print(i+1)\nprint(k+1)",
"import sys",
"sys",
"n,x=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"k=-1",
"k",
"-1",
"for i in range(n-1):\n if a[i]+a[i+1]>=x:\n k=i\n break\n if i==n-2:\n print('Impossible')\n sys.exit()",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1]>=x:\n k=i\n break\n ",
"a[i]+a[i+1]>=x",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"x",
"k=i",
"k",
"i",
"break",
"if i==n-2:\n print('Impossible')\n sys.exit()",
"i==n-2",
"i",
"n-2",
"n",
"2",
"print('Impossible')",
"print",
"'Impossible'",
"sys.exit()",
"sys.exit",
"sys",
"exit",
"print('Possible')",
"print",
"'Possible'",
"for i in range(k):\n print(i+1)",
"i",
"range(k)",
"range",
"k",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for i in range(n-2,k,-1):\n print(i+1)",
"i",
"range(n-2,k,-1)",
"range",
"n-2",
"n",
"2",
"k",
"-1",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"print(k+1)",
"print",
"k+1",
"k",
"1",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"k=-1",
"-1",
"k",
"n,x=map(int,input().split())",
"map(int,input().split())",
"n",
"k=i",
"i",
"k",
"x=map(int,input().split())",
"map(int,input().split())",
"x"
] | import sys
n,x=map(int,input().split())
a=list(map(int,input().split()))
k=-1
for i in range(n-1):
if a[i]+a[i+1]>=x:
k=i
break
if i==n-2:
print('Impossible')
sys.exit()
print('Possible')
for i in range(k):
print(i+1)
for i in range(n-2,k,-1):
print(i+1)
print(k+1) |
[
7,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
29,
17,
4,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
13
],
[
16,
15
],
[
28,
27
],
[
4,
31
],
[
15,
37
],
[
27,
38
],
[
15,
40
],
[
27,
42
],
[
13,
44
],
[
50,
49
],
[
27,
52
],
[
49,
56
],
[
60,
59
],
[
4,
63
],
[
27,
65
],
[
59,
69
],
[
83,
80
]
] | [
"def resolve():\n n, l = map(int, input().split())\n a = list(map(int, input().split()))\n for i in range(n - 1):\n if a[i] + a[i + 1] >= l:\n print(\"Possible\")\n for j in range(i):\n print(j + 1)\n for j in range(n - 1, i, -1):\n print(j)\n return 0\n print(\"Impossible\")\n\n\nif __name__ == \"__main__\":\n resolve()",
"def resolve():\n n, l = map(int, input().split())\n a = list(map(int, input().split()))\n for i in range(n - 1):\n if a[i] + a[i + 1] >= l:\n print(\"Possible\")\n for j in range(i):\n print(j + 1)\n for j in range(n - 1, i, -1):\n print(j)\n return 0\n print(\"Impossible\")",
"resolve",
"n, l = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(n - 1):\n if a[i] + a[i + 1] >= l:\n print(\"Possible\")\n for j in range(i):\n print(j + 1)\n for j in range(n - 1, i, -1):\n print(j)\n return 0\n ",
"i",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"if a[i] + a[i + 1] >= l:\n print(\"Possible\")\n for j in range(i):\n print(j + 1)\n for j in range(n - 1, i, -1):\n print(j)\n return 0\n ",
"a[i] + a[i + 1] >= l",
"a[i] + a[i + 1]",
"a[i]",
"a",
"i",
"a[i + 1]",
"a",
"i + 1",
"i",
"1",
"l",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for j in range(i):\n print(j + 1)\n ",
"j",
"range(i)",
"range",
"i",
"print(j + 1)",
"print",
"j + 1",
"j",
"1",
"for j in range(n - 1, i, -1):\n print(j)\n ",
"j",
"range(n - 1, i, -1)",
"range",
"n - 1",
"n",
"1",
"i",
"-1",
"print(j)",
"print",
"j",
"return 0",
"0",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"if __name__ == \"__main__\":\n resolve()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"resolve()",
"resolve",
"def resolve():\n n, l = map(int, input().split())\n a = list(map(int, input().split()))\n for i in range(n - 1):\n if a[i] + a[i + 1] >= l:\n print(\"Possible\")\n for j in range(i):\n print(j + 1)\n for j in range(n - 1, i, -1):\n print(j)\n return 0\n print(\"Impossible\")",
"def resolve():\n n, l = map(int, input().split())\n a = list(map(int, input().split()))\n for i in range(n - 1):\n if a[i] + a[i + 1] >= l:\n print(\"Possible\")\n for j in range(i):\n print(j + 1)\n for j in range(n - 1, i, -1):\n print(j)\n return 0\n print(\"Impossible\")",
"resolve"
] | def resolve():
n, l = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n - 1):
if a[i] + a[i + 1] >= l:
print("Possible")
for j in range(i):
print(j + 1)
for j in range(n - 1, i, -1):
print(j)
return 0
print("Impossible")
if __name__ == "__main__":
resolve()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
18,
4,
13,
2,
13,
17,
2,
13,
17,
39,
17,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13
] | [
[
106,
2
],
[
106,
11
],
[
15,
14
],
[
14,
23
],
[
103,
25
],
[
100,
28
],
[
32,
31
],
[
98,
35
],
[
104,
41
],
[
31,
42
],
[
104,
44
],
[
31,
46
],
[
107,
48
],
[
109,
50
],
[
31,
51
],
[
110,
55
],
[
101,
55
],
[
65,
64
],
[
110,
67
],
[
101,
67
],
[
64,
71
],
[
75,
74
],
[
110,
79
],
[
101,
79
],
[
98,
82
],
[
74,
89
],
[
110,
94
],
[
101,
94
],
[
106,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
31,
109
],
[
109,
110
]
] | [
"N,L=map(int,input().split())\na=[int(i) for i in input().split()]\nj=-1\nfor i in range(N-1):\n if a[i]+a[i+1]>=L:\n j=i\n break\nif j==-1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(j):\n print(i+1)\n for i in range(j+1,N-1)[::-1]:\n print(i+1)\n print(j+1)",
"N,L=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"a=[int(i) for i in input().split()]",
"a",
"[int(i) for i in input().split()]",
"j=-1",
"j",
"-1",
"for i in range(N-1):\n if a[i]+a[i+1]>=L:\n j=i\n break",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if a[i]+a[i+1]>=L:\n j=i\n break",
"a[i]+a[i+1]>=L",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"L",
"j=i",
"j",
"i",
"break",
"if j==-1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(j):\n print(i+1)\n for i in range(j+1,N-1)[::-1]:\n print(i+1)\n print(j+1)",
"j==-1",
"j",
"-1",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(j):\n print(i+1)\n ",
"i",
"range(j)",
"range",
"j",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for i in range(j+1,N-1)[::-1]:\n print(i+1)\n ",
"i",
"range(j+1,N-1)[::-1]",
"(j+1,N-1)",
"range",
"j+1",
"j",
"1",
"N-1",
"N",
"1",
"::-1",
"-1",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"print(j+1)",
"print",
"j+1",
"j",
"1",
"N,L=map(int,input().split())",
"map(int,input().split())",
"N",
"j=-1",
"-1",
"j",
"a=[int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"a",
"L=map(int,input().split())",
"map(int,input().split())",
"L",
"j=i",
"i",
"j"
] | N,L=map(int,input().split())
a=[int(i) for i in input().split()]
j=-1
for i in range(N-1):
if a[i]+a[i+1]>=L:
j=i
break
if j==-1:
print("Impossible")
else:
print("Possible")
for i in range(j):
print(i+1)
for i in range(j+1,N-1)[::-1]:
print(i+1)
print(j+1)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
31,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
4,
13,
31,
18,
4,
13,
2,
13,
17,
13,
39,
17,
0,
13,
17,
4,
13,
31,
4,
13,
17,
2,
13,
17,
0,
13,
17,
3,
4,
13,
17,
10,
4,
13,
10,
4,
13
] | [
[
80,
2
],
[
80,
11
],
[
15,
13
],
[
25,
24
],
[
81,
28
],
[
24,
35
],
[
24,
39
],
[
78,
41
],
[
24,
52
],
[
81,
54
],
[
59,
58
],
[
24,
67
],
[
71,
70
],
[
80,
78
],
[
80,
81
]
] | [
"n,l=map(int,input().split())\n*a,=map(int,input().split())\n\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n print(\"Possible\")\n print(*range(i+2,n)[::-1],sep=\"\\n\")\n print(*range(1,i+2),sep=\"\\n\")\n break\nelse:\n print(\"Impossible\")",
"n,l=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"*a,=map(int,input().split())",
"*a",
"a",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(n-1):\n if a[i]+a[i+1]>=l:\n print(\"Possible\")\n print(*range(i+2,n)[::-1],sep=\"\\n\")\n print(*range(1,i+2),sep=\"\\n\")\n break\nelse:\n print(\"Impossible\")",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1]>=l:\n print(\"Possible\")\n print(*range(i+2,n)[::-1],sep=\"\\n\")\n print(*range(1,i+2),sep=\"\\n\")\n break",
"a[i]+a[i+1]>=l",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"print(\"Possible\")",
"print",
"\"Possible\"",
"print(*range(i+2,n)[::-1],sep=\"\\n\")",
"print",
"*range(i+2,n)[::-1]",
"range(i+2,n)[::-1]",
"(i+2,n)",
"range",
"i+2",
"i",
"2",
"n",
"::-1",
"-1",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"print(*range(1,i+2),sep=\"\\n\")",
"print",
"*range(1,i+2)",
"range(1,i+2)",
"range",
"1",
"i+2",
"i",
"2",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"l=map(int,input().split())",
"map(int,input().split())",
"l",
"n,l=map(int,input().split())",
"map(int,input().split())",
"n"
] | n,l=map(int,input().split())
*a,=map(int,input().split())
for i in range(n-1):
if a[i]+a[i+1]>=l:
print("Possible")
print(*range(i+2,n)[::-1],sep="\n")
print(*range(1,i+2),sep="\n")
break
else:
print("Impossible") |
[
7,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
12,
4,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
0,
13,
12,
4,
13,
13,
4,
18,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
0,
13,
12,
4,
13,
4,
13,
13,
4,
18,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
0,
13,
12,
4,
13,
4,
13,
12,
2,
4,
13,
13,
17,
23,
4,
18,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
14,
40,
13,
13,
0,
13,
4,
13,
13,
13,
0,
13,
2,
13,
17,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
13,
39,
0,
13,
18,
13,
39,
13,
0,
13,
18,
13,
39,
2,
13,
17,
4,
18,
13,
13,
0,
13,
2,
13,
13,
4,
13,
17,
28,
13,
13,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13
] | [
[
238,
19
],
[
241,
24
],
[
229,
31
],
[
232,
45
],
[
235,
63
],
[
244,
83
],
[
112,
111
],
[
236,
113
],
[
112,
114
],
[
117,
116
],
[
236,
118
],
[
121,
120
],
[
124,
123
],
[
127,
126
],
[
111,
130
],
[
133,
132
],
[
116,
135
],
[
126,
136
],
[
116,
138
],
[
126,
140
],
[
132,
144
],
[
114,
145
],
[
148,
147
],
[
120,
150
],
[
147,
150
],
[
132,
151
],
[
154,
153
],
[
126,
155
],
[
147,
159
],
[
120,
159
],
[
170,
169
],
[
111,
173
],
[
169,
176
],
[
179,
178
],
[
182,
181
],
[
185,
184
],
[
178,
186
],
[
132,
186
],
[
191,
190
],
[
178,
192
],
[
132,
192
],
[
153,
195
],
[
123,
195
],
[
190,
199
],
[
203,
202
],
[
184,
204
],
[
190,
205
],
[
211,
210
],
[
202,
210
],
[
181,
210
],
[
210,
215
],
[
153,
220
],
[
123,
220
],
[
248,
227
],
[
229,
230
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
241,
242
],
[
244,
245
]
] | [
"import sys\nimport math\nimport collections\nimport bisect\nimport itertools\n\n# import numpy as np\n\nsys.setrecursionlimit(10 ** 7)\nINF = 10 ** 20\nMOD = 10 ** 9 + 7\n# MOD = 998244353\n\nni = lambda: int(sys.stdin.readline().rstrip())\nns = lambda: map(int, sys.stdin.readline().rstrip().split())\nna = lambda: list(map(int, sys.stdin.readline().rstrip().split()))\nna1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))\n\n\n# ===CODE===\n\ndef main():\n n, l = na()\n a = na()\n\n max_point = -1\n max_idx = -1\n for i in range(1, n):\n tmp = a[i] + a[i - 1]\n if tmp >= l:\n max_point = max(max_point, tmp)\n max_idx = i - 1\n\n if max_point == -1:\n print(\"Impossible\")\n exit(0)\n\n tmp = [i for i in range(n - 1)]\n\n ans = []\n x = tmp[:max_idx]\n y = tmp[max_idx + 1:]\n y.reverse()\n\n ans = x + y\n\n print(\"Possible\")\n for ansi in ans:\n print(ansi + 1)\n print(max_idx + 1)\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"import math",
"math",
"import collections",
"collections",
"import bisect",
"bisect",
"import itertools",
"itertools",
"sys.setrecursionlimit(10 ** 7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 7",
"10",
"7",
"INF = 10 ** 20",
"INF",
"10 ** 20",
"10",
"20",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"ni = lambda: int(sys.stdin.readline().rstrip())",
"ni",
"lambda: int(sys.stdin.readline().rstrip())",
"int(sys.stdin.readline().rstrip())",
"int",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"ns = lambda: map(int, sys.stdin.readline().rstrip().split())",
"ns",
"lambda: map(int, sys.stdin.readline().rstrip().split())",
"map(int, sys.stdin.readline().rstrip().split())",
"map",
"int",
"sys.stdin.readline().rstrip().split()",
"sys.stdin.readline().rstrip().split",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"split",
"na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))",
"na",
"lambda: list(map(int, sys.stdin.readline().rstrip().split()))",
"list(map(int, sys.stdin.readline().rstrip().split()))",
"list",
"map(int, sys.stdin.readline().rstrip().split())",
"map",
"int",
"sys.stdin.readline().rstrip().split()",
"sys.stdin.readline().rstrip().split",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"split",
"na1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))",
"na1",
"lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))",
"list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))",
"list",
"map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split())",
"map",
"lambda x: int(x) - 1",
"int(x) - 1",
"int(x)",
"int",
"x",
"1",
"x",
"sys.stdin.readline().rstrip().split()",
"sys.stdin.readline().rstrip().split",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"split",
"def main():\n n, l = na()\n a = na()\n\n max_point = -1\n max_idx = -1\n for i in range(1, n):\n tmp = a[i] + a[i - 1]\n if tmp >= l:\n max_point = max(max_point, tmp)\n max_idx = i - 1\n\n if max_point == -1:\n print(\"Impossible\")\n exit(0)\n\n tmp = [i for i in range(n - 1)]\n\n ans = []\n x = tmp[:max_idx]\n y = tmp[max_idx + 1:]\n y.reverse()\n\n ans = x + y\n\n print(\"Possible\")\n for ansi in ans:\n print(ansi + 1)\n print(max_idx + 1)",
"main",
"n, l = na()",
"n",
"na()",
"na",
"l",
"a = na()",
"a",
"na()",
"na",
"max_point = -1",
"max_point",
"-1",
"max_idx = -1",
"max_idx",
"-1",
"for i in range(1, n):\n tmp = a[i] + a[i - 1]\n if tmp >= l:\n max_point = max(max_point, tmp)\n max_idx = i - 1\n\n ",
"i",
"range(1, n)",
"range",
"1",
"n",
"tmp = a[i] + a[i - 1]",
"tmp",
"a[i] + a[i - 1]",
"a[i]",
"a",
"i",
"a[i - 1]",
"a",
"i - 1",
"i",
"1",
"if tmp >= l:\n max_point = max(max_point, tmp)\n max_idx = i - 1\n\n ",
"tmp >= l",
"tmp",
"l",
"max_point = max(max_point, tmp)",
"max_point",
"max(max_point, tmp)",
"max",
"max_point",
"tmp",
"max_idx = i - 1",
"max_idx",
"i - 1",
"i",
"1",
"if max_point == -1:\n print(\"Impossible\")\n exit(0)\n\n ",
"max_point == -1",
"max_point",
"-1",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit(0)",
"exit",
"0",
"i for i in range(n - 1)",
"for i in range(n - 1)",
"i",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"for i in range(n - 1)",
"i",
"tmp = [i for i in range(n - 1)]",
"tmp",
"[i for i in range(n - 1)]",
"ans = []",
"ans",
"[]",
"x = tmp[:max_idx]",
"x",
"tmp[:max_idx]",
"tmp",
":max_idx",
"max_idx",
"y = tmp[max_idx + 1:]",
"y",
"tmp[max_idx + 1:]",
"tmp",
"max_idx + 1:",
"max_idx + 1",
"max_idx",
"1",
"y.reverse()",
"y.reverse",
"y",
"reverse",
"ans = x + y",
"ans",
"x + y",
"x",
"y",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for ansi in ans:\n print(ansi + 1)\n ",
"ansi",
"ans",
"print(ansi + 1)",
"print",
"ansi + 1",
"ansi",
"1",
"print(max_idx + 1)",
"print",
"max_idx + 1",
"max_idx",
"1",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"ni = lambda: int(sys.stdin.readline().rstrip())",
"lambda: int(sys.stdin.readline().rstrip())",
"ni",
"ns = lambda: map(int, sys.stdin.readline().rstrip().split())",
"lambda: map(int, sys.stdin.readline().rstrip().split())",
"ns",
"na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))",
"lambda: list(map(int, sys.stdin.readline().rstrip().split()))",
"na",
"INF = 10 ** 20",
"10 ** 20",
"INF",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"na1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))",
"lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))",
"na1",
"def main():\n n, l = na()\n a = na()\n\n max_point = -1\n max_idx = -1\n for i in range(1, n):\n tmp = a[i] + a[i - 1]\n if tmp >= l:\n max_point = max(max_point, tmp)\n max_idx = i - 1\n\n if max_point == -1:\n print(\"Impossible\")\n exit(0)\n\n tmp = [i for i in range(n - 1)]\n\n ans = []\n x = tmp[:max_idx]\n y = tmp[max_idx + 1:]\n y.reverse()\n\n ans = x + y\n\n print(\"Possible\")\n for ansi in ans:\n print(ansi + 1)\n print(max_idx + 1)",
"def main():\n n, l = na()\n a = na()\n\n max_point = -1\n max_idx = -1\n for i in range(1, n):\n tmp = a[i] + a[i - 1]\n if tmp >= l:\n max_point = max(max_point, tmp)\n max_idx = i - 1\n\n if max_point == -1:\n print(\"Impossible\")\n exit(0)\n\n tmp = [i for i in range(n - 1)]\n\n ans = []\n x = tmp[:max_idx]\n y = tmp[max_idx + 1:]\n y.reverse()\n\n ans = x + y\n\n print(\"Possible\")\n for ansi in ans:\n print(ansi + 1)\n print(max_idx + 1)",
"main"
] | import sys
import math
import collections
import bisect
import itertools
# import numpy as np
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline().rstrip())
ns = lambda: map(int, sys.stdin.readline().rstrip().split())
na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))
# ===CODE===
def main():
n, l = na()
a = na()
max_point = -1
max_idx = -1
for i in range(1, n):
tmp = a[i] + a[i - 1]
if tmp >= l:
max_point = max(max_point, tmp)
max_idx = i - 1
if max_point == -1:
print("Impossible")
exit(0)
tmp = [i for i in range(n - 1)]
ans = []
x = tmp[:max_idx]
y = tmp[max_idx + 1:]
y.reverse()
ans = x + y
print("Possible")
for ansi in ans:
print(ansi + 1)
print(max_idx + 1)
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
13,
14,
2,
13,
13,
13,
4,
13,
13,
28,
13,
4,
13,
13,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
17,
13,
2,
13,
17,
13,
2,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13
] | [
[
99,
2
],
[
99,
11
],
[
93,
13
],
[
25,
24
],
[
97,
28
],
[
94,
33
],
[
24,
34
],
[
94,
36
],
[
24,
38
],
[
102,
41
],
[
105,
44
],
[
103,
47
],
[
90,
49
],
[
103,
52
],
[
106,
54
],
[
106,
57
],
[
100,
58
],
[
65,
64
],
[
91,
67
],
[
64,
70
],
[
74,
73
],
[
97,
77
],
[
91,
79
],
[
73,
83
],
[
91,
87
],
[
90,
91
],
[
93,
94
],
[
99,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
]
] | [
"N, L = map(int, raw_input().split())\na = map(int, raw_input().split())\nb = [a[i]+a[i+1] for i in xrange(N-1)]\nmaxb = max(b)\nmaxbi = b.index(maxb)\nif maxb < L:\n print 'Impossible'\n exit()\nprint 'Possible'\nfor i in xrange(maxbi):\n print i+1\nfor i in xrange(N-2, maxbi, -1):\n print i+1\nprint maxbi+1",
"N, L = map(int, raw_input().split())",
"N",
"map(int, raw_input().split())",
"map",
"int",
"raw_input().split()",
"().split",
"()",
"raw_input",
"split",
"L",
"a = map(int, raw_input().split())",
"a",
"map(int, raw_input().split())",
"map",
"int",
"raw_input().split()",
"().split",
"()",
"raw_input",
"split",
"a[i]+a[i+1] for i in xrange(N-1)",
"for i in xrange(N-1)",
"i",
"xrange(N-1)",
"xrange",
"N-1",
"N",
"1",
"for i in xrange(N-1)",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"b = [a[i]+a[i+1] for i in xrange(N-1)]",
"b",
"[a[i]+a[i+1] for i in xrange(N-1)]",
"maxb = max(b)",
"maxb",
"max(b)",
"max",
"b",
"maxbi = b.index(maxb)",
"maxbi",
"b.index(maxb)",
"b.index",
"b",
"index",
"maxb",
"if maxb < L:\n print 'Impossible'\n exit()",
"maxb < L",
"maxb",
"L",
"print",
"exit()",
"exit",
"print",
"for i in xrange(maxbi):\n print i+1",
"i",
"xrange(maxbi)",
"xrange",
"maxbi",
"print",
"i+1",
"i",
"1",
"for i in xrange(N-2, maxbi, -1):\n print i+1",
"i",
"xrange(N-2, maxbi, -1)",
"xrange",
"N-2",
"N",
"2",
"maxbi",
"-1",
"print",
"i+1",
"i",
"1",
"print",
"maxbi+1",
"maxbi",
"1",
"maxbi = b.index(maxb)",
"b.index(maxb)",
"maxbi",
"a = map(int, raw_input().split())",
"map(int, raw_input().split())",
"a",
"N, L = map(int, raw_input().split())",
"map(int, raw_input().split())",
"N",
"L = map(int, raw_input().split())",
"map(int, raw_input().split())",
"L",
"b = [a[i]+a[i+1] for i in xrange(N-1)]",
"[a[i]+a[i+1] for i in xrange(N-1)]",
"b",
"maxb = max(b)",
"max(b)",
"maxb"
] | N, L = map(int, raw_input().split())
a = map(int, raw_input().split())
b = [a[i]+a[i+1] for i in xrange(N-1)]
maxb = max(b)
maxbi = b.index(maxb)
if maxb < L:
print 'Impossible'
exit()
print 'Possible'
for i in xrange(maxbi):
print i+1
for i in xrange(N-2, maxbi, -1):
print i+1
print maxbi+1
|
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
4,
18,
13,
13,
2,
17,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
41,
28,
13,
13,
4,
13,
13,
18,
13,
39,
17,
4,
2,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
13,
14,
2,
13,
13,
0,
13,
39,
17,
0,
13,
39,
17,
0,
13,
17,
41,
28,
13,
4,
13,
17,
13,
4,
4,
13,
13,
0,
13,
2,
2,
13,
13,
39,
4,
13,
13,
4,
13,
4,
18,
17,
13,
13,
10,
2,
13,
10,
39,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
133,
4
],
[
148,
19
],
[
134,
26
],
[
148,
28
],
[
32,
31
],
[
134,
35
],
[
31,
40
],
[
124,
42
],
[
125,
50
],
[
125,
52
],
[
127,
60
],
[
145,
63
],
[
128,
66
],
[
130,
68
],
[
128,
71
],
[
146,
73
],
[
146,
76
],
[
149,
77
],
[
121,
79
],
[
139,
83
],
[
136,
87
],
[
92,
91
],
[
137,
95
],
[
131,
95
],
[
91,
99
],
[
118,
101
],
[
137,
109
],
[
131,
109
],
[
119,
116
],
[
122,
116
],
[
140,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
],
[
148,
143
],
[
145,
146
],
[
148,
149
]
] | [
"import sys\ninput = sys.stdin.readline\nsys.setrecursionlimit(10 ** 7)\n\n\"\"\"\n逆再生。長さL以上になるものをくっつけられる。\n一度L以上になったらそこだけ見ていけばよい\n\"\"\"\n\nN,L = map(int,input().split())\nA = [int(x) for x in input().split()]\n\nA2 = [x+y for x,y in zip(A,A[1:])]\n\nM = max(A2)\ni = A2.index(M)\nif M < L:\n answer = ['Impossible']\nelse:\n answer = ['Possible']\n i += 1 # ここを最後にする\n answer += [str(x) for x in range(1,i)] + [str(x) for x in range(N-1,i,-1)] + [str(i)]\n\nprint('\\n'.join(answer))",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"sys.setrecursionlimit(10 ** 7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 7",
"10",
"7",
"\"\"\"\n逆再生。長さL以上になるものをくっつけられる。\n一度L以上になったらそこだけ見ていけばよい\n\"\"\"",
"N,L = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"int(x) for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"int(x)",
"int",
"x",
"A = [int(x) for x in input().split()]",
"A",
"[int(x) for x in input().split()]",
"x+y for x,y in zip(A,A[1:])",
"for x,y in zip(A,A[1:])",
"x",
"y",
"zip(A,A[1:])",
"zip",
"A",
"A[1:]",
"A",
"1:",
"1",
"for x,y in zip(A,A[1:])",
"x+y",
"x",
"y",
"A2 = [x+y for x,y in zip(A,A[1:])]",
"A2",
"[x+y for x,y in zip(A,A[1:])]",
"M = max(A2)",
"M",
"max(A2)",
"max",
"A2",
"i = A2.index(M)",
"i",
"A2.index(M)",
"A2.index",
"A2",
"index",
"M",
"if M < L:\n answer = ['Impossible']\nelse:\n answer = ['Possible']\n i += 1 # ここを最後にする\n answer += [str(x) for x in range(1,i)] + [str(x) for x in range(N-1,i,-1)] + [str(i)]",
"M < L",
"M",
"L",
"answer = ['Impossible']",
"answer",
"['Impossible']",
"'Impossible'",
"answer = ['Possible']",
"answer",
"['Possible']",
"'Possible'",
"i += 1",
"i",
"1",
"str(x) for x in range(1,i)",
"for x in range(1,i)",
"x",
"range(1,i)",
"range",
"1",
"i",
"for x in range(1,i)",
"str(x)",
"str",
"x",
"answer += [str(x) for x in range(1,i)] + [str(x) for x in range(N-1,i,-1)] + [str(i)]",
"answer",
"[str(x) for x in range(1,i)] + [str(x) for x in range(N-1,i,-1)] + [str(i)]",
"[str(x) for x in range(1,i)] + [str(x) for x in range(N-1,i,-1)]",
"[str(x) for x in range(1,i)]",
"[str(x) for x in range(N-1,i,-1)]",
"[str(i)]",
"str(i)",
"str",
"i",
"print('\\n'.join(answer))",
"print",
"'\\n'.join(answer)",
"'\\n'.join",
"'\\n'",
"join",
"answer",
"answer += [str(x) for x in range(1,i)] + [str(x) for x in range(N-1,i,-1)] + [str(i)]",
"[str(x) for x in range(1,i)] + [str(x) for x in range(N-1,i,-1)] + [str(i)]",
"answer",
"answer = ['Impossible']",
"['Impossible']",
"answer",
"A = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"A",
"A2 = [x+y for x,y in zip(A,A[1:])]",
"[x+y for x,y in zip(A,A[1:])]",
"A2",
"i = A2.index(M)",
"A2.index(M)",
"i",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"i += 1",
"1",
"i",
"answer = ['Possible']",
"['Possible']",
"answer",
"N,L = map(int,input().split())",
"map(int,input().split())",
"N",
"M = max(A2)",
"max(A2)",
"M",
"L = map(int,input().split())",
"map(int,input().split())",
"L"
] | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
"""
逆再生。長さL以上になるものをくっつけられる。
一度L以上になったらそこだけ見ていけばよい
"""
N,L = map(int,input().split())
A = [int(x) for x in input().split()]
A2 = [x+y for x,y in zip(A,A[1:])]
M = max(A2)
i = A2.index(M)
if M < L:
answer = ['Impossible']
else:
answer = ['Possible']
i += 1 # ここを最後にする
answer += [str(x) for x in range(1,i)] + [str(x) for x in range(N-1,i,-1)] + [str(i)]
print('\n'.join(answer)) |
[
7,
12,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
2,
13,
17,
14,
2,
13,
13,
29,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
18,
4,
13,
13,
13,
39,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
6,
5
],
[
5,
14
],
[
17,
16
],
[
17,
18
],
[
22,
21
],
[
21,
30
],
[
33,
32
],
[
36,
35
],
[
39,
38
],
[
42,
41
],
[
16,
45
],
[
35,
49
],
[
60,
49
],
[
32,
52
],
[
41,
53
],
[
32,
55
],
[
41,
57
],
[
61,
60
],
[
32,
63
],
[
41,
64
],
[
32,
66
],
[
41,
68
],
[
72,
71
],
[
41,
73
],
[
60,
77
],
[
35,
77
],
[
18,
78
],
[
88,
87
],
[
71,
91
],
[
38,
91
],
[
87,
94
],
[
97,
96
],
[
71,
100
],
[
38,
100
],
[
16,
101
],
[
96,
106
],
[
115,
112
]
] | [
"def main():\n N, L = (int(i) for i in input().split())\n A = [int(i) for i in input().split()]\n\n ma = 0\n idx = -1\n for i in range(N-1):\n if ma < A[i] + A[i+1]:\n ma = A[i] + A[i+1]\n idx = i+1\n if ma < L:\n return print(\"Impossible\")\n print(\"Possible\")\n for i in range(1, idx):\n print(i)\n for i in range(idx, N)[::-1]:\n print(i)\n\n\nif __name__ == '__main__':\n main()",
"def main():\n N, L = (int(i) for i in input().split())\n A = [int(i) for i in input().split()]\n\n ma = 0\n idx = -1\n for i in range(N-1):\n if ma < A[i] + A[i+1]:\n ma = A[i] + A[i+1]\n idx = i+1\n if ma < L:\n return print(\"Impossible\")\n print(\"Possible\")\n for i in range(1, idx):\n print(i)\n for i in range(idx, N)[::-1]:\n print(i)",
"main",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"N, L = (int(i) for i in input().split())",
"N",
"(int(i) for i in input().split())",
"L",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"A = [int(i) for i in input().split()]",
"A",
"[int(i) for i in input().split()]",
"ma = 0",
"ma",
"0",
"idx = -1",
"idx",
"-1",
"for i in range(N-1):\n if ma < A[i] + A[i+1]:\n ma = A[i] + A[i+1]\n idx = i+1\n ",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if ma < A[i] + A[i+1]:\n ma = A[i] + A[i+1]\n idx = i+1\n ",
"ma < A[i] + A[i+1]",
"ma",
"A[i] + A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"ma = A[i] + A[i+1]",
"ma",
"A[i] + A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"idx = i+1",
"idx",
"i+1",
"i",
"1",
"if ma < L:\n return print(\"Impossible\")\n ",
"ma < L",
"ma",
"L",
"return print(\"Impossible\")",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(1, idx):\n print(i)\n ",
"i",
"range(1, idx)",
"range",
"1",
"idx",
"print(i)",
"print",
"i",
"for i in range(idx, N)[::-1]:\n print(i)",
"i",
"range(idx, N)[::-1]",
"(idx, N)",
"range",
"idx",
"N",
"::-1",
"-1",
"print(i)",
"print",
"i",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n N, L = (int(i) for i in input().split())\n A = [int(i) for i in input().split()]\n\n ma = 0\n idx = -1\n for i in range(N-1):\n if ma < A[i] + A[i+1]:\n ma = A[i] + A[i+1]\n idx = i+1\n if ma < L:\n return print(\"Impossible\")\n print(\"Possible\")\n for i in range(1, idx):\n print(i)\n for i in range(idx, N)[::-1]:\n print(i)",
"def main():\n N, L = (int(i) for i in input().split())\n A = [int(i) for i in input().split()]\n\n ma = 0\n idx = -1\n for i in range(N-1):\n if ma < A[i] + A[i+1]:\n ma = A[i] + A[i+1]\n idx = i+1\n if ma < L:\n return print(\"Impossible\")\n print(\"Possible\")\n for i in range(1, idx):\n print(i)\n for i in range(idx, N)[::-1]:\n print(i)",
"main"
] | def main():
N, L = (int(i) for i in input().split())
A = [int(i) for i in input().split()]
ma = 0
idx = -1
for i in range(N-1):
if ma < A[i] + A[i+1]:
ma = A[i] + A[i+1]
idx = i+1
if ma < L:
return print("Impossible")
print("Possible")
for i in range(1, idx):
print(i)
for i in range(idx, N)[::-1]:
print(i)
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
0,
13,
13,
3,
4,
13,
17,
4,
13,
14,
2,
13,
17,
4,
13,
31,
18,
4,
13,
4,
13,
17,
13,
39,
17,
0,
13,
17,
0,
13,
4,
13,
4,
13,
17,
13,
0,
18,
13,
39,
13,
18,
13,
39,
2,
13,
17,
2,
13,
17,
17,
4,
13,
31,
13,
0,
13,
17,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
114,
2
],
[
114,
11
],
[
117,
13
],
[
26,
25
],
[
109,
29
],
[
118,
35
],
[
25,
36
],
[
118,
38
],
[
25,
40
],
[
115,
42
],
[
105,
47
],
[
25,
48
],
[
106,
57
],
[
109,
68
],
[
73,
72
],
[
111,
75
],
[
109,
81
],
[
87,
83
],
[
112,
84
],
[
112,
88
],
[
109,
91
],
[
106,
94
],
[
112,
100
],
[
103,
102
],
[
25,
105
],
[
105,
106
],
[
114,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
]
] | [
"n,k = map(int,input().split())\na = list(map(int,input().split()))\nfor i in range(n-1):\n if a[i]+a[i+1] >= k:\n print(\"Possible\")\n x = i\n break\nelse:\n print(\"Impossible\")\n exit()\nif x == 0:\n print(*list(range(1,n))[::-1],sep=\"\\n\")\nelse:\n ans = list(range(1,n))\n ans[x:] = ans[n-1:x-1:-1]\n print(*ans,sep=\"\\n\")",
"n,k = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"k",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(n-1):\n if a[i]+a[i+1] >= k:\n print(\"Possible\")\n x = i\n break\nelse:\n print(\"Impossible\")\n exit()",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1] >= k:\n print(\"Possible\")\n x = i\n break",
"a[i]+a[i+1] >= k",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"k",
"print(\"Possible\")",
"print",
"\"Possible\"",
"x = i",
"x",
"i",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit()",
"exit",
"if x == 0:\n print(*list(range(1,n))[::-1],sep=\"\\n\")\nelse:\n ans = list(range(1,n))\n ans[x:] = ans[n-1:x-1:-1]\n print(*ans,sep=\"\\n\")",
"x == 0",
"x",
"0",
"print(*list(range(1,n))[::-1],sep=\"\\n\")",
"print",
"*list(range(1,n))[::-1]",
"list(range(1,n))[::-1]",
"(range(1,n))",
"list",
"range(1,n)",
"range",
"1",
"n",
"::-1",
"-1",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"ans = list(range(1,n))",
"ans",
"list(range(1,n))",
"list",
"range(1,n)",
"range",
"1",
"n",
"ans[x:] = ans[n-1:x-1:-1]",
"ans[x:]",
"ans",
"x:",
"x",
"ans[n-1:x-1:-1]",
"ans",
"n-1:x-1:-1",
"n-1",
"n",
"1",
"x-1",
"x",
"1",
"-1",
"print(*ans,sep=\"\\n\")",
"print",
"*ans",
"ans",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"x = i",
"i",
"x",
"n,k = map(int,input().split())",
"map(int,input().split())",
"n",
"ans = list(range(1,n))",
"list(range(1,n))",
"ans",
"k = map(int,input().split())",
"map(int,input().split())",
"k",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a"
] | n,k = map(int,input().split())
a = list(map(int,input().split()))
for i in range(n-1):
if a[i]+a[i+1] >= k:
print("Possible")
x = i
break
else:
print("Impossible")
exit()
if x == 0:
print(*list(range(1,n))[::-1],sep="\n")
else:
ans = list(range(1,n))
ans[x:] = ans[n-1:x-1:-1]
print(*ans,sep="\n") |
[
7,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
39,
13,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
9,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
17,
4,
13,
17,
10,
12,
13,
10,
4,
13
] | [
[
18,
15
],
[
78,
19
],
[
80,
21
],
[
78,
23
],
[
26,
25
],
[
81,
35
],
[
25,
36
],
[
81,
38
],
[
25,
40
],
[
49,
48
],
[
25,
53
],
[
48,
57
],
[
60,
59
],
[
25,
65
],
[
59,
69
],
[
80,
81
]
] | [
"def get_ints():\n return list(map(int, input().split()))\n\n[n, l] = get_ints()\na = get_ints()\n\nfor i in range(n - 1):\n if a[i] + a[i + 1] < l:\n continue\n print(\"Possible\")\n for j in range(1, i + 1):\n print(j)\n for j in range(n - 1, i, -1):\n print(j)\n exit(0)\n\nprint(\"Impossible\")",
"def get_ints():\n return list(map(int, input().split()))",
"get_ints",
"return list(map(int, input().split()))",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[n, l] = get_ints()",
"[n, l]",
"n",
"l",
"get_ints()",
"get_ints",
"a = get_ints()",
"a",
"get_ints()",
"get_ints",
"for i in range(n - 1):\n if a[i] + a[i + 1] < l:\n continue\n print(\"Possible\")\n for j in range(1, i + 1):\n print(j)\n for j in range(n - 1, i, -1):\n print(j)\n exit(0)",
"i",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"if a[i] + a[i + 1] < l:\n continue\n ",
"a[i] + a[i + 1] < l",
"a[i] + a[i + 1]",
"a[i]",
"a",
"i",
"a[i + 1]",
"a",
"i + 1",
"i",
"1",
"l",
"continue",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for j in range(1, i + 1):\n print(j)\n ",
"j",
"range(1, i + 1)",
"range",
"1",
"i + 1",
"i",
"1",
"print(j)",
"print",
"j",
"for j in range(n - 1, i, -1):\n print(j)\n ",
"j",
"range(n - 1, i, -1)",
"range",
"n - 1",
"n",
"1",
"i",
"-1",
"print(j)",
"print",
"j",
"exit(0)",
"exit",
"0",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"def get_ints():\n return list(map(int, input().split()))",
"def get_ints():\n return list(map(int, input().split()))",
"get_ints",
"a = get_ints()",
"get_ints()",
"a"
] | def get_ints():
return list(map(int, input().split()))
[n, l] = get_ints()
a = get_ints()
for i in range(n - 1):
if a[i] + a[i + 1] < l:
continue
print("Possible")
for j in range(1, i + 1):
print(j)
for j in range(n - 1, i, -1):
print(j)
exit(0)
print("Impossible")
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
14,
40,
13,
13,
0,
13,
17,
0,
13,
2,
13,
17,
3,
14,
2,
13,
17,
4,
13,
13,
4,
13,
13,
14,
40,
13,
17,
28,
13,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
14,
40,
13,
2,
13,
17,
28,
13,
4,
13,
4,
13,
2,
13,
17,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13
] | [
[
131,
2
],
[
131,
11
],
[
113,
13
],
[
122,
25
],
[
125,
28
],
[
32,
31
],
[
132,
35
],
[
128,
38
],
[
114,
41
],
[
31,
42
],
[
114,
44
],
[
31,
46
],
[
129,
50
],
[
111,
51
],
[
119,
53
],
[
116,
56
],
[
31,
58
],
[
120,
63
],
[
123,
63
],
[
120,
67
],
[
123,
67
],
[
120,
70
],
[
123,
70
],
[
117,
73
],
[
126,
73
],
[
77,
76
],
[
117,
80
],
[
126,
80
],
[
76,
85
],
[
117,
89
],
[
126,
89
],
[
132,
91
],
[
95,
94
],
[
117,
100
],
[
126,
100
],
[
132,
102
],
[
94,
105
],
[
117,
108
],
[
126,
108
],
[
131,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
128,
129
],
[
131,
132
]
] | [
"n,l = map(int, input().split())\na = list(map(int, input().split()))\nans = \"Impossible\"\nlast = 0\n\nfor i in range(n-1):\n A = a[i]+a[i+1]\n if A>=l:\n ans= \"Possible\"\n last = i+1\n break\n\nif ans==\"Impossible\":\n print(ans)\nelse:\n print(ans)\n\n if last!=1:\n for i in range(last-1):\n print(i+1)\n\n if last!=n-1:\n for i in reversed(range(last+1,n)):\n print(i)\n\n print(last)",
"n,l = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = \"Impossible\"",
"ans",
"\"Impossible\"",
"last = 0",
"last",
"0",
"for i in range(n-1):\n A = a[i]+a[i+1]\n if A>=l:\n ans= \"Possible\"\n last = i+1\n break",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"A = a[i]+a[i+1]",
"A",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"if A>=l:\n ans= \"Possible\"\n last = i+1\n break",
"A>=l",
"A",
"l",
"ans= \"Possible\"",
"ans",
"\"Possible\"",
"last = i+1",
"last",
"i+1",
"i",
"1",
"break",
"if ans==\"Impossible\":\n print(ans)\nelse:\n print(ans)\n\n if last!=1:\n for i in range(last-1):\n print(i+1)\n\n if last!=n-1:\n for i in reversed(range(last+1,n)):\n print(i)\n\n print(last)",
"ans==\"Impossible\"",
"ans",
"\"Impossible\"",
"print(ans)",
"print",
"ans",
"print(ans)",
"print",
"ans",
"if last!=1:\n for i in range(last-1):\n print(i+1)\n\n ",
"last!=1",
"last",
"1",
"for i in range(last-1):\n print(i+1)\n\n ",
"i",
"range(last-1)",
"range",
"last-1",
"last",
"1",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"if last!=n-1:\n for i in reversed(range(last+1,n)):\n print(i)\n\n ",
"last!=n-1",
"last",
"n-1",
"n",
"1",
"for i in reversed(range(last+1,n)):\n print(i)\n\n ",
"i",
"reversed(range(last+1,n))",
"reversed",
"range(last+1,n)",
"range",
"last+1",
"last",
"1",
"n",
"print(i)",
"print",
"i",
"print(last)",
"print",
"last",
"l = map(int, input().split())",
"map(int, input().split())",
"l",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"last = i+1",
"i+1",
"last",
"ans= \"Possible\"",
"\"Possible\"",
"ans",
"ans = \"Impossible\"",
"\"Impossible\"",
"ans",
"last = 0",
"0",
"last",
"A = a[i]+a[i+1]",
"a[i]+a[i+1]",
"A",
"n,l = map(int, input().split())",
"map(int, input().split())",
"n"
] | n,l = map(int, input().split())
a = list(map(int, input().split()))
ans = "Impossible"
last = 0
for i in range(n-1):
A = a[i]+a[i+1]
if A>=l:
ans= "Possible"
last = i+1
break
if ans=="Impossible":
print(ans)
else:
print(ans)
if last!=1:
for i in range(last-1):
print(i+1)
if last!=n-1:
for i in reversed(range(last+1,n)):
print(i)
print(last) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
17,
13,
14,
40,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
0,
13,
13,
3,
4,
13,
17,
4,
13,
0,
13,
39,
28,
13,
4,
13,
17,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
18,
13,
13,
13,
4,
18,
13,
13,
13,
4,
13,
17,
4,
13,
31,
13,
0,
13,
17,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
13,
13
] | [
[
98,
2
],
[
98,
11
],
[
104,
13
],
[
26,
25
],
[
96,
29
],
[
105,
34
],
[
25,
36
],
[
105,
39
],
[
25,
40
],
[
99,
41
],
[
107,
43
],
[
25,
44
],
[
101,
52
],
[
56,
55
],
[
108,
59
],
[
102,
62
],
[
55,
64
],
[
67,
66
],
[
96,
70
],
[
108,
72
],
[
102,
76
],
[
66,
78
],
[
102,
81
],
[
108,
83
],
[
102,
90
],
[
93,
92
],
[
98,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
25,
107
],
[
107,
108
]
] | [
"N, L = map(int, input().split())\nA = list(map(int, input().split()))\n\nfor i in range(1, N):\n if A[i-1] + A[i] >= L:\n X = i\n break\nelse:\n print(\"Impossible\")\n exit()\n\nans = []\nfor i in range(1, X):\n ans.append(i)\nfor i in range(N-1, X, -1):\n ans.append(i)\nans.append(X)\nprint(\"Possible\")\nprint(*ans, sep=\"\\n\")",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(1, N):\n if A[i-1] + A[i] >= L:\n X = i\n break\nelse:\n print(\"Impossible\")\n exit()",
"i",
"range(1, N)",
"range",
"1",
"N",
"if A[i-1] + A[i] >= L:\n X = i\n break",
"A[i-1] + A[i] >= L",
"A[i-1] + A[i]",
"A[i-1]",
"A",
"i-1",
"i",
"1",
"A[i]",
"A",
"i",
"L",
"X = i",
"X",
"i",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit()",
"exit",
"ans = []",
"ans",
"[]",
"for i in range(1, X):\n ans.append(i)",
"i",
"range(1, X)",
"range",
"1",
"X",
"ans.append(i)",
"ans.append",
"ans",
"append",
"i",
"for i in range(N-1, X, -1):\n ans.append(i)",
"i",
"range(N-1, X, -1)",
"range",
"N-1",
"N",
"1",
"X",
"-1",
"ans.append(i)",
"ans.append",
"ans",
"append",
"i",
"ans.append(X)",
"ans.append",
"ans",
"append",
"X",
"print(\"Possible\")",
"print",
"\"Possible\"",
"print(*ans, sep=\"\\n\")",
"print",
"*ans",
"ans",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"ans = []",
"[]",
"ans",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"X = i",
"i",
"X"
] | N, L = map(int, input().split())
A = list(map(int, input().split()))
for i in range(1, N):
if A[i-1] + A[i] >= L:
X = i
break
else:
print("Impossible")
exit()
ans = []
for i in range(1, X):
ans.append(i)
for i in range(N-1, X, -1):
ans.append(i)
ans.append(X)
print("Possible")
print(*ans, sep="\n")
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
4,
18,
13,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
14,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
4,
13,
13,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13
] | [
[
117,
2
],
[
117,
11
],
[
108,
13
],
[
109,
26
],
[
111,
31
],
[
35,
34
],
[
106,
38
],
[
109,
43
],
[
34,
44
],
[
109,
46
],
[
34,
48
],
[
118,
50
],
[
114,
52
],
[
34,
53
],
[
115,
57
],
[
112,
57
],
[
115,
67
],
[
112,
67
],
[
71,
70
],
[
106,
74
],
[
70,
80
],
[
83,
82
],
[
115,
86
],
[
112,
86
],
[
82,
89
],
[
92,
91
],
[
106,
95
],
[
115,
98
],
[
112,
98
],
[
91,
103
],
[
117,
106
],
[
108,
109
],
[
111,
112
],
[
34,
114
],
[
114,
115
],
[
117,
118
]
] | [
"N,L = map(int,input().split())\nA = list(map(int,input().split()))\nA.insert(0,0)\nflag = 0\nfor i in range(1,N):\n if A[i]+A[i+1]>=L:\n flag = i\n break\nif flag == 0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n if flag==1:\n for i in range(N-1,0,-1):\n print(i)\n else:\n for i in range(1,flag):\n print(i)\n for i in range(N-1,flag-1,-1):\n print(i)",
"N,L = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A.insert(0,0)",
"A.insert",
"A",
"insert",
"0",
"0",
"flag = 0",
"flag",
"0",
"for i in range(1,N):\n if A[i]+A[i+1]>=L:\n flag = i\n break",
"i",
"range(1,N)",
"range",
"1",
"N",
"if A[i]+A[i+1]>=L:\n flag = i\n break",
"A[i]+A[i+1]>=L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"flag = i",
"flag",
"i",
"break",
"if flag == 0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n if flag==1:\n for i in range(N-1,0,-1):\n print(i)\n else:\n for i in range(1,flag):\n print(i)\n for i in range(N-1,flag-1,-1):\n print(i)",
"flag == 0",
"flag",
"0",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"if flag==1:\n for i in range(N-1,0,-1):\n print(i)\n else:\n for i in range(1,flag):\n print(i)\n for i in range(N-1,flag-1,-1):\n print(i)",
"flag==1",
"flag",
"1",
"for i in range(N-1,0,-1):\n print(i)\n ",
"i",
"range(N-1,0,-1)",
"range",
"N-1",
"N",
"1",
"0",
"-1",
"print(i)",
"print",
"i",
"for i in range(1,flag):\n print(i)\n ",
"i",
"range(1,flag)",
"range",
"1",
"flag",
"print(i)",
"print",
"i",
"for i in range(N-1,flag-1,-1):\n print(i)",
"i",
"range(N-1,flag-1,-1)",
"range",
"N-1",
"N",
"1",
"flag-1",
"flag",
"1",
"-1",
"print(i)",
"print",
"i",
"N,L = map(int,input().split())",
"map(int,input().split())",
"N",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"flag = 0",
"0",
"flag",
"flag = i",
"i",
"flag",
"L = map(int,input().split())",
"map(int,input().split())",
"L"
] | N,L = map(int,input().split())
A = list(map(int,input().split()))
A.insert(0,0)
flag = 0
for i in range(1,N):
if A[i]+A[i+1]>=L:
flag = i
break
if flag == 0:
print("Impossible")
else:
print("Possible")
if flag==1:
for i in range(N-1,0,-1):
print(i)
else:
for i in range(1,flag):
print(i)
for i in range(N-1,flag-1,-1):
print(i) |
[
7,
12,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
18,
13,
13,
2,
13,
17,
0,
13,
13,
3,
29,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
4,
18,
13,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
4,
18,
13,
13,
2,
13,
17,
29,
13,
23,
13,
23,
13,
23,
13,
14,
2,
13,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
13,
13,
14,
40,
13,
4,
13,
17,
4,
13,
17,
4,
13,
31,
18,
13,
39,
17,
0,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
5,
4
],
[
8,
7
],
[
74,
11
],
[
78,
17
],
[
7,
18
],
[
78,
20
],
[
7,
22
],
[
76,
24
],
[
4,
27
],
[
7,
30
],
[
34,
33
],
[
7,
34
],
[
4,
37
],
[
40,
39
],
[
33,
43
],
[
74,
46
],
[
4,
50
],
[
39,
53
],
[
57,
56
],
[
33,
60
],
[
4,
66
],
[
56,
69
],
[
4,
72
],
[
74,
74
],
[
76,
76
],
[
78,
78
],
[
136,
84
],
[
136,
93
],
[
145,
95
],
[
139,
107
],
[
143,
109
],
[
134,
110
],
[
137,
111
],
[
146,
112
],
[
140,
115
],
[
143,
115
],
[
140,
126
],
[
143,
126
],
[
131,
130
],
[
136,
134
],
[
136,
137
],
[
139,
140
],
[
145,
146
]
] | [
"\ndef knot(N, L, a):\n res = []\n for i in range(N - 1):\n if a[i] + a[i + 1] >= L:\n res.append(i + 1)\n start = i\n break\n else:\n return res\n\n for i in range(start + 1, N - 1):\n res.append(i + 1)\n for i in range(start - 1, -1, -1):\n res.append(i + 1)\n return res\n\n\nif __name__ == \"__main__\":\n N, L = map(int, input().split())\n a = list(map(int, input().split()))\n knot = knot(N, L, a)\n if not knot:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n print(*knot[::-1], sep=\"\\n\")",
"def knot(N, L, a):\n res = []\n for i in range(N - 1):\n if a[i] + a[i + 1] >= L:\n res.append(i + 1)\n start = i\n break\n else:\n return res\n\n for i in range(start + 1, N - 1):\n res.append(i + 1)\n for i in range(start - 1, -1, -1):\n res.append(i + 1)\n return res",
"knot",
"res = []",
"res",
"[]",
"for i in range(N - 1):\n if a[i] + a[i + 1] >= L:\n res.append(i + 1)\n start = i\n break\n else:\n return res\n\n ",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"if a[i] + a[i + 1] >= L:\n res.append(i + 1)\n start = i\n break\n ",
"a[i] + a[i + 1] >= L",
"a[i] + a[i + 1]",
"a[i]",
"a",
"i",
"a[i + 1]",
"a",
"i + 1",
"i",
"1",
"L",
"res.append(i + 1)",
"res.append",
"res",
"append",
"i + 1",
"i",
"1",
"start = i",
"start",
"i",
"break",
"return res",
"res",
"for i in range(start + 1, N - 1):\n res.append(i + 1)\n ",
"i",
"range(start + 1, N - 1)",
"range",
"start + 1",
"start",
"1",
"N - 1",
"N",
"1",
"res.append(i + 1)",
"res.append",
"res",
"append",
"i + 1",
"i",
"1",
"for i in range(start - 1, -1, -1):\n res.append(i + 1)\n ",
"i",
"range(start - 1, -1, -1)",
"range",
"start - 1",
"start",
"1",
"-1",
"-1",
"res.append(i + 1)",
"res.append",
"res",
"append",
"i + 1",
"i",
"1",
"return res",
"res",
"N",
"N",
"L",
"L",
"a",
"a",
"if __name__ == \"__main__\":\n N, L = map(int, input().split())\n a = list(map(int, input().split()))\n knot = knot(N, L, a)\n if not knot:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n print(*knot[::-1], sep=\"\\n\")",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"knot = knot(N, L, a)",
"knot",
"knot(N, L, a)",
"knot",
"N",
"L",
"a",
"if not knot:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n print(*knot[::-1], sep=\"\\n\")",
"not knot",
"knot",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"print(*knot[::-1], sep=\"\\n\")",
"print",
"*knot[::-1]",
"knot[::-1]",
"knot",
"::-1",
"-1",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"knot = knot(N, L, a)",
"knot(N, L, a)",
"knot",
"def knot(N, L, a):\n res = []\n for i in range(N - 1):\n if a[i] + a[i + 1] >= L:\n res.append(i + 1)\n start = i\n break\n else:\n return res\n\n for i in range(start + 1, N - 1):\n res.append(i + 1)\n for i in range(start - 1, -1, -1):\n res.append(i + 1)\n return res",
"def knot(N, L, a):\n res = []\n for i in range(N - 1):\n if a[i] + a[i + 1] >= L:\n res.append(i + 1)\n start = i\n break\n else:\n return res\n\n for i in range(start + 1, N - 1):\n res.append(i + 1)\n for i in range(start - 1, -1, -1):\n res.append(i + 1)\n return res",
"knot",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a"
] |
def knot(N, L, a):
res = []
for i in range(N - 1):
if a[i] + a[i + 1] >= L:
res.append(i + 1)
start = i
break
else:
return res
for i in range(start + 1, N - 1):
res.append(i + 1)
for i in range(start - 1, -1, -1):
res.append(i + 1)
return res
if __name__ == "__main__":
N, L = map(int, input().split())
a = list(map(int, input().split()))
knot = knot(N, L, a)
if not knot:
print("Impossible")
else:
print("Possible")
print(*knot[::-1], sep="\n")
|
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
13,
14,
40,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
0,
13,
13,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
96,
3
],
[
96,
12
],
[
93,
14
],
[
87,
26
],
[
30,
29
],
[
97,
33
],
[
94,
38
],
[
29,
40
],
[
94,
43
],
[
29,
44
],
[
91,
45
],
[
84,
47
],
[
29,
48
],
[
85,
51
],
[
88,
51
],
[
61,
60
],
[
85,
64
],
[
88,
64
],
[
60,
67
],
[
70,
69
],
[
97,
73
],
[
85,
75
],
[
88,
75
],
[
69,
79
],
[
85,
82
],
[
88,
82
],
[
29,
84
],
[
84,
85
],
[
87,
88
],
[
96,
91
],
[
93,
94
],
[
96,
97
]
] | [
"from collections import deque\nn, l = map(int, input().split())\na = list(map(int, input().split()))\nlast = -1\nfor i in range(1,n):\n if a[i-1] + a[i] >= l :\n last = i\nif last == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1, last):\n print(i)\n for i in range(n-1,last,-1):\n print(i)\n print(last)",
"from collections import deque",
"n, l = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"last = -1",
"last",
"-1",
"for i in range(1,n):\n if a[i-1] + a[i] >= l :\n last = i",
"i",
"range(1,n)",
"range",
"1",
"n",
"if a[i-1] + a[i] >= l :\n last = i",
"a[i-1] + a[i] >= l",
"a[i-1] + a[i]",
"a[i-1]",
"a",
"i-1",
"i",
"1",
"a[i]",
"a",
"i",
"l",
"last = i",
"last",
"i",
"if last == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1, last):\n print(i)\n for i in range(n-1,last,-1):\n print(i)\n print(last)",
"last == -1",
"last",
"-1",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(1, last):\n print(i)\n ",
"i",
"range(1, last)",
"range",
"1",
"last",
"print(i)",
"print",
"i",
"for i in range(n-1,last,-1):\n print(i)\n ",
"i",
"range(n-1,last,-1)",
"range",
"n-1",
"n",
"1",
"last",
"-1",
"print(i)",
"print",
"i",
"print(last)",
"print",
"last",
"last = i",
"i",
"last",
"last = -1",
"-1",
"last",
"l = map(int, input().split())",
"map(int, input().split())",
"l",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"n, l = map(int, input().split())",
"map(int, input().split())",
"n"
] | from collections import deque
n, l = map(int, input().split())
a = list(map(int, input().split()))
last = -1
for i in range(1,n):
if a[i-1] + a[i] >= l :
last = i
if last == -1:
print("Impossible")
else:
print("Possible")
for i in range(1, last):
print(i)
for i in range(n-1,last,-1):
print(i)
print(last) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
4,
18,
13,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
14,
40,
4,
13,
13,
13,
0,
13,
17,
0,
13,
17,
4,
13,
13,
14,
2,
13,
17,
0,
13,
4,
18,
13,
13,
4,
13,
13,
0,
13,
2,
2,
4,
13,
4,
13,
17,
2,
13,
17,
4,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
39,
2,
13,
17,
28,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
39,
13,
10,
17,
13
] | [
[
124,
2
],
[
124,
11
],
[
15,
14
],
[
14,
23
],
[
127,
25
],
[
130,
28
],
[
32,
31
],
[
125,
35
],
[
131,
39
],
[
128,
43
],
[
31,
44
],
[
128,
46
],
[
31,
48
],
[
131,
54
],
[
116,
55
],
[
121,
57
],
[
133,
60
],
[
134,
64
],
[
122,
64
],
[
134,
67
],
[
122,
67
],
[
112,
70
],
[
131,
73
],
[
131,
77
],
[
118,
79
],
[
113,
88
],
[
125,
95
],
[
113,
98
],
[
113,
103
],
[
107,
106
],
[
119,
106
],
[
134,
106
],
[
122,
106
],
[
106,
110
],
[
112,
113
],
[
124,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
]
] | [
"n, l = map(int, input().split())\na = [int(i) for i in input().split()]\nb = []\nfor i in range(n-1):\n b.append(a[i] + a[i+1])\nif max(b) >= l:\n ans = \"Possible\"\nelse:\n ans = \"Impossible\"\nprint(ans)\nif ans == \"Possible\":\n k = b.index(max(b))\n ans = list(range(1, k + 1)) + list(range(n - 1, k + 1, -1)) + [k + 1]\n for i in ans:\n print(i)",
"n, l = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"a = [int(i) for i in input().split()]",
"a",
"[int(i) for i in input().split()]",
"b = []",
"b",
"[]",
"for i in range(n-1):\n b.append(a[i] + a[i+1])",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"b.append(a[i] + a[i+1])",
"b.append",
"b",
"append",
"a[i] + a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"if max(b) >= l:\n ans = \"Possible\"\nelse:\n ans = \"Impossible\"",
"max(b) >= l",
"max(b)",
"max",
"b",
"l",
"ans = \"Possible\"",
"ans",
"\"Possible\"",
"ans = \"Impossible\"",
"ans",
"\"Impossible\"",
"print(ans)",
"print",
"ans",
"if ans == \"Possible\":\n k = b.index(max(b))\n ans = list(range(1, k + 1)) + list(range(n - 1, k + 1, -1)) + [k + 1]\n for i in ans:\n print(i)",
"ans == \"Possible\"",
"ans",
"\"Possible\"",
"k = b.index(max(b))",
"k",
"b.index(max(b))",
"b.index",
"b",
"index",
"max(b)",
"max",
"b",
"ans = list(range(1, k + 1)) + list(range(n - 1, k + 1, -1)) + [k + 1]",
"ans",
"list(range(1, k + 1)) + list(range(n - 1, k + 1, -1)) + [k + 1]",
"list(range(1, k + 1)) + list(range(n - 1, k + 1, -1))",
"list(range(1, k + 1))",
"list",
"range(1, k + 1)",
"range",
"1",
"k + 1",
"k",
"1",
"list(range(n - 1, k + 1, -1))",
"list",
"range(n - 1, k + 1, -1)",
"range",
"n - 1",
"n",
"1",
"k + 1",
"k",
"1",
"-1",
"[k + 1]",
"k + 1",
"k",
"1",
"for i in ans:\n print(i)",
"i",
"ans",
"print(i)",
"print",
"i",
"k = b.index(max(b))",
"b.index(max(b))",
"k",
"l = map(int, input().split())",
"map(int, input().split())",
"l",
"ans = list(range(1, k + 1)) + list(range(n - 1, k + 1, -1)) + [k + 1]",
"list(range(1, k + 1)) + list(range(n - 1, k + 1, -1)) + [k + 1]",
"ans",
"ans = \"Possible\"",
"\"Possible\"",
"ans",
"n, l = map(int, input().split())",
"map(int, input().split())",
"n",
"a = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"a",
"b = []",
"[]",
"b",
"ans = \"Impossible\"",
"\"Impossible\"",
"ans"
] | n, l = map(int, input().split())
a = [int(i) for i in input().split()]
b = []
for i in range(n-1):
b.append(a[i] + a[i+1])
if max(b) >= l:
ans = "Possible"
else:
ans = "Impossible"
print(ans)
if ans == "Possible":
k = b.index(max(b))
ans = list(range(1, k + 1)) + list(range(n - 1, k + 1, -1)) + [k + 1]
for i in ans:
print(i) |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
18,
4,
13,
2,
13,
17,
13,
39,
17,
4,
13,
13,
4,
13,
4,
13,
17,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13
] | [
[
89,
4
],
[
95,
11
],
[
90,
18
],
[
95,
20
],
[
92,
22
],
[
90,
31
],
[
35,
34
],
[
96,
38
],
[
93,
44
],
[
34,
45
],
[
93,
47
],
[
34,
49
],
[
87,
51
],
[
57,
56
],
[
34,
61
],
[
56,
65
],
[
68,
67
],
[
34,
72
],
[
96,
74
],
[
67,
79
],
[
95,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
]
] | [
"import sys\ninput = sys.stdin.readline\n\nN, L = map(int, input().split())\na = list(map(int, input().split()))\nfor i in range(N-1):\n if a[i] + a[i+1] >= L:\n print('Possible')\n for j in range(1, i+1):\n print(j)\n for j in range(i+1, N)[::-1]:\n print(j)\n exit()\nprint('Impossible')",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(N-1):\n if a[i] + a[i+1] >= L:\n print('Possible')\n for j in range(1, i+1):\n print(j)\n for j in range(i+1, N)[::-1]:\n print(j)\n exit()",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if a[i] + a[i+1] >= L:\n print('Possible')\n for j in range(1, i+1):\n print(j)\n for j in range(i+1, N)[::-1]:\n print(j)\n exit()",
"a[i] + a[i+1] >= L",
"a[i] + a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"L",
"print('Possible')",
"print",
"'Possible'",
"for j in range(1, i+1):\n print(j)\n ",
"j",
"range(1, i+1)",
"range",
"1",
"i+1",
"i",
"1",
"print(j)",
"print",
"j",
"for j in range(i+1, N)[::-1]:\n print(j)\n ",
"j",
"range(i+1, N)[::-1]",
"(i+1, N)",
"range",
"i+1",
"i",
"1",
"N",
"::-1",
"-1",
"print(j)",
"print",
"j",
"exit()",
"exit",
"print('Impossible')",
"print",
"'Impossible'",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N"
] | import sys
input = sys.stdin.readline
N, L = map(int, input().split())
a = list(map(int, input().split()))
for i in range(N-1):
if a[i] + a[i+1] >= L:
print('Possible')
for j in range(1, i+1):
print(j)
for j in range(i+1, N)[::-1]:
print(j)
exit()
print('Impossible') |
[
7,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
0,
13,
2,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
13,
4,
18,
13,
13,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13
] | [
[
91,
4
],
[
91,
13
],
[
17,
16
],
[
16,
25
],
[
97,
27
],
[
31,
30
],
[
92,
34
],
[
98,
40
],
[
30,
41
],
[
98,
43
],
[
30,
45
],
[
89,
47
],
[
94,
52
],
[
30,
54
],
[
58,
57
],
[
95,
61
],
[
57,
64
],
[
67,
66
],
[
92,
70
],
[
95,
72
],
[
66,
76
],
[
95,
79
],
[
91,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
]
] | [
"import sys\nN, L = map(int, input().split())\nA = [int(_) for _ in input().split()]\n\n\nfor n in range(N - 1):\n if A[n] + A[n + 1] >= L:\n print('Possible')\n tmp_ind = n + 1\n for m in range(1, tmp_ind):\n print(m)\n for m in range(N - 1, tmp_ind, -1):\n print(m)\n print(tmp_ind)\n sys.exit()\nprint('Impossible')",
"import sys",
"sys",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"int(_) for _ in input().split()",
"for _ in input().split()",
"_",
"input().split()",
"().split",
"()",
"input",
"split",
"for _ in input().split()",
"int(_)",
"int",
"_",
"A = [int(_) for _ in input().split()]",
"A",
"[int(_) for _ in input().split()]",
"for n in range(N - 1):\n if A[n] + A[n + 1] >= L:\n print('Possible')\n tmp_ind = n + 1\n for m in range(1, tmp_ind):\n print(m)\n for m in range(N - 1, tmp_ind, -1):\n print(m)\n print(tmp_ind)\n sys.exit()",
"n",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"if A[n] + A[n + 1] >= L:\n print('Possible')\n tmp_ind = n + 1\n for m in range(1, tmp_ind):\n print(m)\n for m in range(N - 1, tmp_ind, -1):\n print(m)\n print(tmp_ind)\n sys.exit()",
"A[n] + A[n + 1] >= L",
"A[n] + A[n + 1]",
"A[n]",
"A",
"n",
"A[n + 1]",
"A",
"n + 1",
"n",
"1",
"L",
"print('Possible')",
"print",
"'Possible'",
"tmp_ind = n + 1",
"tmp_ind",
"n + 1",
"n",
"1",
"for m in range(1, tmp_ind):\n print(m)\n ",
"m",
"range(1, tmp_ind)",
"range",
"1",
"tmp_ind",
"print(m)",
"print",
"m",
"for m in range(N - 1, tmp_ind, -1):\n print(m)\n ",
"m",
"range(N - 1, tmp_ind, -1)",
"range",
"N - 1",
"N",
"1",
"tmp_ind",
"-1",
"print(m)",
"print",
"m",
"print(tmp_ind)",
"print",
"tmp_ind",
"sys.exit()",
"sys.exit",
"sys",
"exit",
"print('Impossible')",
"print",
"'Impossible'",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"tmp_ind = n + 1",
"n + 1",
"tmp_ind",
"A = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"A"
] | import sys
N, L = map(int, input().split())
A = [int(_) for _ in input().split()]
for n in range(N - 1):
if A[n] + A[n + 1] >= L:
print('Possible')
tmp_ind = n + 1
for m in range(1, tmp_ind):
print(m)
for m in range(N - 1, tmp_ind, -1):
print(m)
print(tmp_ind)
sys.exit()
print('Impossible') |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
13,
17,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
92,
2
],
[
92,
11
],
[
95,
13
],
[
98,
25
],
[
29,
28
],
[
93,
32
],
[
96,
38
],
[
28,
39
],
[
96,
41
],
[
28,
43
],
[
87,
45
],
[
89,
47
],
[
28,
49
],
[
90,
54
],
[
99,
54
],
[
64,
63
],
[
90,
67
],
[
99,
67
],
[
63,
70
],
[
73,
72
],
[
93,
76
],
[
90,
79
],
[
99,
79
],
[
72,
84
],
[
92,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
]
] | [
"N,L = map(int,input().split())\nA = list(map(int,input().split()))\n\nlast = 0\nfor i in range(N-1):\n if A[i] + A[i+1] >= L:\n last = i+1\n break\nif last == 0:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,last):\n print(i)\n for i in range(N-1,last-1,-1):\n print(i)",
"N,L = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"last = 0",
"last",
"0",
"for i in range(N-1):\n if A[i] + A[i+1] >= L:\n last = i+1\n break",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i] + A[i+1] >= L:\n last = i+1\n break",
"A[i] + A[i+1] >= L",
"A[i] + A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"last = i+1",
"last",
"i+1",
"i",
"1",
"break",
"if last == 0:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,last):\n print(i)\n for i in range(N-1,last-1,-1):\n print(i)",
"last == 0",
"last",
"0",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"for i in range(1,last):\n print(i)\n ",
"i",
"range(1,last)",
"range",
"1",
"last",
"print(i)",
"print",
"i",
"for i in range(N-1,last-1,-1):\n print(i)",
"i",
"range(N-1,last-1,-1)",
"range",
"N-1",
"N",
"1",
"last-1",
"last",
"1",
"-1",
"print(i)",
"print",
"i",
"L = map(int,input().split())",
"map(int,input().split())",
"L",
"last = i+1",
"i+1",
"last",
"N,L = map(int,input().split())",
"map(int,input().split())",
"N",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"last = 0",
"0",
"last"
] | N,L = map(int,input().split())
A = list(map(int,input().split()))
last = 0
for i in range(N-1):
if A[i] + A[i+1] >= L:
last = i+1
break
if last == 0:
print('Impossible')
else:
print('Possible')
for i in range(1,last):
print(i)
for i in range(N-1,last-1,-1):
print(i)
|
[
7,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
14,
2,
13,
13,
0,
13,
13,
0,
13,
2,
13,
17,
14,
2,
13,
13,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13
] | [
[
4,
3
],
[
3,
12
],
[
121,
14
],
[
121,
16
],
[
20,
19
],
[
19,
28
],
[
124,
30
],
[
115,
33
],
[
112,
36
],
[
40,
39
],
[
104,
43
],
[
106,
46
],
[
125,
49
],
[
39,
50
],
[
125,
52
],
[
39,
54
],
[
107,
58
],
[
116,
59
],
[
119,
59
],
[
118,
61
],
[
107,
62
],
[
109,
64
],
[
39,
66
],
[
119,
70
],
[
116,
70
],
[
122,
71
],
[
80,
79
],
[
110,
83
],
[
113,
83
],
[
79,
86
],
[
89,
88
],
[
104,
92
],
[
110,
94
],
[
113,
94
],
[
88,
98
],
[
110,
101
],
[
113,
101
],
[
121,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
107,
118
],
[
118,
119
],
[
121,
122
],
[
124,
125
]
] | [
"#C\n#各ペアについてみていき、一つでもｌ以上⇔Possible\n\nn,l = [int(i) for i in input().split()]\na = [int(i) for i in input().split()]\n\nmaxsum=0\nmaxind = 0\nfor i in range(n-1):\n s = a[i]+a[i+1]\n if s > maxsum:\n maxsum = s\n maxind = i+1\n\nif maxsum<l:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,maxind):\n print(i)\n for i in range(n-1,maxind,-1):\n print(i)\n print(maxind)",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"n,l = [int(i) for i in input().split()]",
"n",
"[int(i) for i in input().split()]",
"l",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"a = [int(i) for i in input().split()]",
"a",
"[int(i) for i in input().split()]",
"maxsum=0",
"maxsum",
"0",
"maxind = 0",
"maxind",
"0",
"for i in range(n-1):\n s = a[i]+a[i+1]\n if s > maxsum:\n maxsum = s\n maxind = i+1",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"s = a[i]+a[i+1]",
"s",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"if s > maxsum:\n maxsum = s\n maxind = i+1",
"s > maxsum",
"s",
"maxsum",
"maxsum = s",
"maxsum",
"s",
"maxind = i+1",
"maxind",
"i+1",
"i",
"1",
"if maxsum<l:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,maxind):\n print(i)\n for i in range(n-1,maxind,-1):\n print(i)\n print(maxind)",
"maxsum<l",
"maxsum",
"l",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(1,maxind):\n print(i)\n ",
"i",
"range(1,maxind)",
"range",
"1",
"maxind",
"print(i)",
"print",
"i",
"for i in range(n-1,maxind,-1):\n print(i)\n ",
"i",
"range(n-1,maxind,-1)",
"range",
"n-1",
"n",
"1",
"maxind",
"-1",
"print(i)",
"print",
"i",
"print(maxind)",
"print",
"maxind",
"n,l = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"n",
"s = a[i]+a[i+1]",
"a[i]+a[i+1]",
"s",
"maxind = i+1",
"i+1",
"maxind",
"maxind = 0",
"0",
"maxind",
"maxsum=0",
"0",
"maxsum",
"maxsum = s",
"s",
"maxsum",
"l = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"l",
"a = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"a"
] | #C
#各ペアについてみていき、一つでもｌ以上⇔Possible
n,l = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
maxsum=0
maxind = 0
for i in range(n-1):
s = a[i]+a[i+1]
if s > maxsum:
maxsum = s
maxind = i+1
if maxsum<l:
print("Impossible")
else:
print("Possible")
for i in range(1,maxind):
print(i)
for i in range(n-1,maxind,-1):
print(i)
print(maxind) |
[
7,
15,
13,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
18,
13,
13,
17,
2,
17,
17,
13,
13,
31,
13,
12,
13,
0,
13,
4,
13,
13,
41,
28,
13,
13,
4,
13,
13,
18,
13,
39,
17,
4,
40,
2,
13,
13,
13,
0,
13,
13,
14,
40,
4,
13,
13,
4,
13,
17,
29,
4,
13,
17,
0,
13,
4,
18,
13,
13,
17,
0,
13,
2,
4,
13,
4,
13,
17,
2,
13,
17,
4,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
31,
13,
0,
13,
17,
23,
13,
23,
13,
4,
13,
13,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
112,
6
],
[
112,
21
],
[
112,
22
],
[
28,
27
],
[
100,
30
],
[
100,
37
],
[
100,
39
],
[
98,
47
],
[
50,
49
],
[
49,
55
],
[
65,
64
],
[
49,
67
],
[
72,
71
],
[
64,
79
],
[
27,
86
],
[
113,
86
],
[
64,
88
],
[
71,
93
],
[
96,
95
],
[
98,
98
],
[
100,
100
],
[
110,
102
],
[
107,
103
],
[
112,
107
],
[
112,
113
]
] | [
"import sys\nimport os\n\nN, L, *A = map(int, os.read(0, 10**8).split())\n\ndef main(L, A):\n N = len(A)\n is_long = [x + y >= L for x, y in zip(A, A[1:])]\n if not any(is_long):\n print('Impossible')\n return\n print('Possible')\n i = is_long.index(True)\n nums = list(range(1, i + 1)) + list(range(N - 1, i, -1))\n print(*nums, sep='\\n')\n\nmain(L, A)",
"import sys",
"sys",
"import os",
"os",
"N, L, *A = map(int, os.read(0, 10**8).split())",
"N",
"map(int, os.read(0, 10**8).split())",
"map",
"int",
"os.read(0, 10**8).split()",
"os.read(0, 10**8).split",
"os.read(0, 10**8)",
"os.read",
"os",
"read",
"0",
"10**8",
"10",
"8",
"split",
"L",
"*A",
"A",
"def main(L, A):\n N = len(A)\n is_long = [x + y >= L for x, y in zip(A, A[1:])]\n if not any(is_long):\n print('Impossible')\n return\n print('Possible')\n i = is_long.index(True)\n nums = list(range(1, i + 1)) + list(range(N - 1, i, -1))\n print(*nums, sep='\\n')",
"main",
"N = len(A)",
"N",
"len(A)",
"len",
"A",
"x + y >= L for x, y in zip(A, A[1:])",
"for x, y in zip(A, A[1:])",
"x",
"y",
"zip(A, A[1:])",
"zip",
"A",
"A[1:]",
"A",
"1:",
"1",
"for x, y in zip(A, A[1:])",
"x + y >= L",
"x + y",
"x",
"y",
"L",
"is_long = [x + y >= L for x, y in zip(A, A[1:])]",
"is_long",
"[x + y >= L for x, y in zip(A, A[1:])]",
"if not any(is_long):\n print('Impossible')\n return\n ",
"not any(is_long)",
"any(is_long)",
"any",
"is_long",
"print('Impossible')",
"print",
"'Impossible'",
"return",
"print('Possible')",
"print",
"'Possible'",
"i = is_long.index(True)",
"i",
"is_long.index(True)",
"is_long.index",
"is_long",
"index",
"True",
"nums = list(range(1, i + 1)) + list(range(N - 1, i, -1))",
"nums",
"list(range(1, i + 1)) + list(range(N - 1, i, -1))",
"list(range(1, i + 1))",
"list",
"range(1, i + 1)",
"range",
"1",
"i + 1",
"i",
"1",
"list(range(N - 1, i, -1))",
"list",
"range(N - 1, i, -1)",
"range",
"N - 1",
"N",
"1",
"i",
"-1",
"print(*nums, sep='\\n')",
"print",
"*nums",
"nums",
"sep='\\n'",
"sep",
"'\\n'",
"L",
"L",
"A",
"A",
"main(L, A)",
"main",
"L",
"A",
"L, *A = map(int, os.read(0, 10**8).split())",
"map(int, os.read(0, 10**8).split())",
"L",
"def main(L, A):\n N = len(A)\n is_long = [x + y >= L for x, y in zip(A, A[1:])]\n if not any(is_long):\n print('Impossible')\n return\n print('Possible')\n i = is_long.index(True)\n nums = list(range(1, i + 1)) + list(range(N - 1, i, -1))\n print(*nums, sep='\\n')",
"def main(L, A):\n N = len(A)\n is_long = [x + y >= L for x, y in zip(A, A[1:])]\n if not any(is_long):\n print('Impossible')\n return\n print('Possible')\n i = is_long.index(True)\n nums = list(range(1, i + 1)) + list(range(N - 1, i, -1))\n print(*nums, sep='\\n')",
"main",
"N, L, *A = map(int, os.read(0, 10**8).split())",
"map(int, os.read(0, 10**8).split())",
"N"
] | import sys
import os
N, L, *A = map(int, os.read(0, 10**8).split())
def main(L, A):
N = len(A)
is_long = [x + y >= L for x, y in zip(A, A[1:])]
if not any(is_long):
print('Impossible')
return
print('Possible')
i = is_long.index(True)
nums = list(range(1, i + 1)) + list(range(N - 1, i, -1))
print(*nums, sep='\n')
main(L, A)
|
[
7,
12,
13,
15,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
2,
13,
17,
14,
2,
13,
17,
29,
4,
13,
17,
41,
28,
13,
4,
13,
17,
13,
4,
13,
0,
13,
2,
2,
13,
18,
13,
39,
17,
39,
13,
4,
13,
17,
4,
13,
31,
13,
0,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
7,
6
],
[
17,
16
],
[
6,
20
],
[
16,
25
],
[
28,
27
],
[
28,
29
],
[
33,
32
],
[
6,
36
],
[
32,
41
],
[
44,
43
],
[
47,
46
],
[
50,
49
],
[
27,
53
],
[
29,
57
],
[
43,
60
],
[
49,
61
],
[
43,
63
],
[
49,
65
],
[
69,
68
],
[
49,
70
],
[
68,
74
],
[
46,
74
],
[
83,
82
],
[
68,
86
],
[
46,
86
],
[
82,
88
],
[
91,
90
],
[
90,
106
],
[
109,
108
],
[
118,
115
]
] | [
"def main():\n import sys\n input = sys.stdin.buffer.readline\n N, L = (int(i) for i in input().split())\n A = [int(i) for i in input().split()]\n last = -1\n for i in range(N-1):\n if L <= A[i] + A[i+1]:\n last = i+1\n if last < 0:\n return print(\"Impossible\")\n ans = [i for i in range(1, last)] + \\\n [i for i in range(last+1, N)][::-1] + [last]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")\n\n\nif __name__ == '__main__':\n main()",
"def main():\n import sys\n input = sys.stdin.buffer.readline\n N, L = (int(i) for i in input().split())\n A = [int(i) for i in input().split()]\n last = -1\n for i in range(N-1):\n if L <= A[i] + A[i+1]:\n last = i+1\n if last < 0:\n return print(\"Impossible\")\n ans = [i for i in range(1, last)] + \\\n [i for i in range(last+1, N)][::-1] + [last]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")",
"main",
"import sys",
"sys",
"input = sys.stdin.buffer.readline",
"input",
"sys.stdin.buffer.readline",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readline",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"N, L = (int(i) for i in input().split())",
"N",
"(int(i) for i in input().split())",
"L",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"A = [int(i) for i in input().split()]",
"A",
"[int(i) for i in input().split()]",
"last = -1",
"last",
"-1",
"for i in range(N-1):\n if L <= A[i] + A[i+1]:\n last = i+1\n ",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if L <= A[i] + A[i+1]:\n last = i+1\n ",
"L <= A[i] + A[i+1]",
"L",
"A[i] + A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"last = i+1",
"last",
"i+1",
"i",
"1",
"if last < 0:\n return print(\"Impossible\")\n ",
"last < 0",
"last",
"0",
"return print(\"Impossible\")",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"i for i in range(1, last)",
"for i in range(1, last)",
"i",
"range(1, last)",
"range",
"1",
"last",
"for i in range(1, last)",
"i",
"ans = [i for i in range(1, last)] + \\\n [i for i in range(last+1, N)][::-1] + [last]",
"ans",
"[i for i in range(1, last)] + \\\n [i for i in range(last+1, N)][::-1] + [last]",
"[i for i in range(1, last)] + \\\n [i for i in range(last+1, N)][::-1]",
"[i for i in range(1, last)]",
"[i for i in range(last+1, N)][::-1]",
"[i for i in range(last+1, N)]",
"::-1",
"-1",
"[last]",
"last",
"print(\"Possible\")",
"print",
"\"Possible\"",
"print(*ans, sep=\"\\n\")",
"print",
"*ans",
"ans",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n import sys\n input = sys.stdin.buffer.readline\n N, L = (int(i) for i in input().split())\n A = [int(i) for i in input().split()]\n last = -1\n for i in range(N-1):\n if L <= A[i] + A[i+1]:\n last = i+1\n if last < 0:\n return print(\"Impossible\")\n ans = [i for i in range(1, last)] + \\\n [i for i in range(last+1, N)][::-1] + [last]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")",
"def main():\n import sys\n input = sys.stdin.buffer.readline\n N, L = (int(i) for i in input().split())\n A = [int(i) for i in input().split()]\n last = -1\n for i in range(N-1):\n if L <= A[i] + A[i+1]:\n last = i+1\n if last < 0:\n return print(\"Impossible\")\n ans = [i for i in range(1, last)] + \\\n [i for i in range(last+1, N)][::-1] + [last]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")",
"main"
] | def main():
import sys
input = sys.stdin.buffer.readline
N, L = (int(i) for i in input().split())
A = [int(i) for i in input().split()]
last = -1
for i in range(N-1):
if L <= A[i] + A[i+1]:
last = i+1
if last < 0:
return print("Impossible")
ans = [i for i in range(1, last)] + \
[i for i in range(last+1, N)][::-1] + [last]
print("Possible")
print(*ans, sep="\n")
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
39,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
4,
18,
13,
13,
2,
13,
17,
4,
18,
13,
13,
2,
13,
17,
4,
18,
13,
13,
2,
2,
13,
17,
13,
0,
13,
17,
14,
2,
13,
17,
4,
13,
17,
4,
13,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
18,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13
] | [
[
124,
2
],
[
124,
11
],
[
127,
13
],
[
133,
25
],
[
112,
28
],
[
121,
31
],
[
35,
34
],
[
125,
39
],
[
134,
43
],
[
131,
43
],
[
128,
49
],
[
34,
50
],
[
128,
52
],
[
34,
54
],
[
119,
56
],
[
130,
58
],
[
122,
62
],
[
125,
65
],
[
122,
69
],
[
34,
72
],
[
122,
76
],
[
125,
80
],
[
113,
82
],
[
116,
82
],
[
115,
84
],
[
131,
88
],
[
134,
88
],
[
100,
99
],
[
125,
104
],
[
122,
109
],
[
99,
110
],
[
112,
113
],
[
115,
116
],
[
124,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
]
] | [
"N, M = map(int, input().split())\nL = list(map(int, input().split()))\n\ncount = 0\nvouch = 0\nA = []\n\nfor i in range (0, N-1):\n\tif count == 0:\n\t\tif L[i]+L[i+1] >= M:\n\t\t\tcount=1\n\t\t\tA.append(N-1)\n\t\telse:\n\t\t\tA.append(i+1)\n\telse:\n\t\tA.append(N-2-vouch)\n\t\tvouch+=1\n\nif count == 0:\n\tprint('Impossible')\n\texit()\nelse:\n\tprint('Possible')\n \nfor i in range (0, N-1):\n\tprint(A[i])",
"N, M = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"M",
"L = list(map(int, input().split()))",
"L",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"count = 0",
"count",
"0",
"vouch = 0",
"vouch",
"0",
"A = []",
"A",
"[]",
"for i in range (0, N-1):\n\tif count == 0:\n\t\tif L[i]+L[i+1] >= M:\n\t\t\tcount=1\n\t\t\tA.append(N-1)\n\t\telse:\n\t\t\tA.append(i+1)\n\telse:\n\t\tA.append(N-2-vouch)\n\t\tvouch+=1",
"i",
"range (0, N-1)",
"range",
"0",
"N-1",
"N",
"1",
"if count == 0:\n\t\tif L[i]+L[i+1] >= M:\n\t\t\tcount=1\n\t\t\tA.append(N-1)\n\t\telse:\n\t\t\tA.append(i+1)\n\telse:\n\t\tA.append(N-2-vouch)\n\t\tvouch+=1",
"count == 0",
"count",
"0",
"if L[i]+L[i+1] >= M:\n\t\t\tcount=1\n\t\t\tA.append(N-1)\n\t\telse:\n\t\t\tA.append(i+1)\n\t",
"L[i]+L[i+1] >= M",
"L[i]+L[i+1]",
"L[i]",
"L",
"i",
"L[i+1]",
"L",
"i+1",
"i",
"1",
"M",
"count=1",
"count",
"1",
"A.append(N-1)",
"A.append",
"A",
"append",
"N-1",
"N",
"1",
"A.append(i+1)",
"A.append",
"A",
"append",
"i+1",
"i",
"1",
"A.append(N-2-vouch)",
"A.append",
"A",
"append",
"N-2-vouch",
"N-2",
"N",
"2",
"vouch",
"vouch+=1",
"vouch",
"1",
"if count == 0:\n\tprint('Impossible')\n\texit()\nelse:\n\tprint('Possible')\n ",
"count == 0",
"count",
"0",
"print('Impossible')",
"print",
"'Impossible'",
"exit()",
"exit",
"print('Possible')",
"print",
"'Possible'",
"for i in range (0, N-1):\n\tprint(A[i])",
"i",
"range (0, N-1)",
"range",
"0",
"N-1",
"N",
"1",
"print(A[i])",
"print",
"A[i]",
"A",
"i",
"vouch = 0",
"0",
"vouch",
"vouch+=1",
"1",
"vouch",
"M = map(int, input().split())",
"map(int, input().split())",
"M",
"A = []",
"[]",
"A",
"N, M = map(int, input().split())",
"map(int, input().split())",
"N",
"L = list(map(int, input().split()))",
"list(map(int, input().split()))",
"L",
"count=1",
"1",
"count",
"count = 0",
"0",
"count"
] | N, M = map(int, input().split())
L = list(map(int, input().split()))
count = 0
vouch = 0
A = []
for i in range (0, N-1):
if count == 0:
if L[i]+L[i+1] >= M:
count=1
A.append(N-1)
else:
A.append(i+1)
else:
A.append(N-2-vouch)
vouch+=1
if count == 0:
print('Impossible')
exit()
else:
print('Possible')
for i in range (0, N-1):
print(A[i]) |
[
7,
15,
13,
0,
13,
12,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
18,
13,
13,
4,
13,
17,
2,
17,
17,
0,
13,
12,
4,
18,
18,
13,
13,
13,
2,
13,
17,
23,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
39,
17,
41,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
0,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
0,
13,
13,
4,
18,
13,
13,
2,
13,
17,
3,
0,
13,
39,
17,
4,
13,
4,
18,
17,
13,
4,
13,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
39,
13,
10,
39,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
159,
4
],
[
162,
26
],
[
141,
39
],
[
160,
46
],
[
141,
48
],
[
156,
50
],
[
160,
59
],
[
63,
62
],
[
139,
66
],
[
157,
72
],
[
62,
73
],
[
157,
75
],
[
62,
77
],
[
142,
79
],
[
150,
81
],
[
87,
86
],
[
62,
91
],
[
86,
94
],
[
144,
96
],
[
101,
100
],
[
139,
104
],
[
62,
107
],
[
100,
111
],
[
147,
113
],
[
148,
117
],
[
145,
117
],
[
151,
117
],
[
154,
117
],
[
62,
120
],
[
153,
124
],
[
163,
128
],
[
154,
136
],
[
148,
136
],
[
145,
136
],
[
151,
136
],
[
141,
139
],
[
141,
142
],
[
144,
145
],
[
147,
148
],
[
150,
151
],
[
153,
154
],
[
156,
157
],
[
159,
160
],
[
162,
163
]
] | [
"import sys\ninput = lambda : sys.stdin.readline().rstrip()\nsys.setrecursionlimit(max(1000, 10**9))\nwrite = lambda x: sys.stdout.write(x+\"\\n\")\n\n\nn,l = map(int, input().split())\na = list(map(int, input().split()))\n\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n ans = [\"Possible\"]\n ans += [j for j in range(1,i+1)]\n ans += [j for j in range(n-1, i+1, -1)]\n ans.append(i+1)\n break\nelse:\n ans = [\"Impossible\"]\nwrite(\"\\n\".join(map(str, ans)))",
"import sys",
"sys",
"input = lambda : sys.stdin.readline().rstrip()",
"input",
"lambda : sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"sys.setrecursionlimit(max(1000, 10**9))",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"max(1000, 10**9)",
"max",
"1000",
"10**9",
"10",
"9",
"write = lambda x: sys.stdout.write(x+\"\\n\")",
"write",
"lambda x: sys.stdout.write(x+\"\\n\")",
"sys.stdout.write(x+\"\\n\")",
"sys.stdout.write",
"sys.stdout",
"sys",
"stdout",
"write",
"x+\"\\n\"",
"x",
"\"\\n\"",
"x",
"n,l = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(n-1):\n if a[i]+a[i+1]>=l:\n ans = [\"Possible\"]\n ans += [j for j in range(1,i+1)]\n ans += [j for j in range(n-1, i+1, -1)]\n ans.append(i+1)\n break\nelse:\n ans = [\"Impossible\"]",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1]>=l:\n ans = [\"Possible\"]\n ans += [j for j in range(1,i+1)]\n ans += [j for j in range(n-1, i+1, -1)]\n ans.append(i+1)\n break",
"a[i]+a[i+1]>=l",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"ans = [\"Possible\"]",
"ans",
"[\"Possible\"]",
"\"Possible\"",
"j for j in range(1,i+1)",
"for j in range(1,i+1)",
"j",
"range(1,i+1)",
"range",
"1",
"i+1",
"i",
"1",
"for j in range(1,i+1)",
"j",
"ans += [j for j in range(1,i+1)]",
"ans",
"[j for j in range(1,i+1)]",
"j for j in range(n-1, i+1, -1)",
"for j in range(n-1, i+1, -1)",
"j",
"range(n-1, i+1, -1)",
"range",
"n-1",
"n",
"1",
"i+1",
"i",
"1",
"-1",
"for j in range(n-1, i+1, -1)",
"j",
"ans += [j for j in range(n-1, i+1, -1)]",
"ans",
"[j for j in range(n-1, i+1, -1)]",
"ans.append(i+1)",
"ans.append",
"ans",
"append",
"i+1",
"i",
"1",
"break",
"ans = [\"Impossible\"]",
"ans",
"[\"Impossible\"]",
"\"Impossible\"",
"write(\"\\n\".join(map(str, ans)))",
"write",
"\"\\n\".join(map(str, ans))",
"\"\\n\".join",
"\"\\n\"",
"join",
"map(str, ans)",
"map",
"str",
"ans",
"n,l = map(int, input().split())",
"map(int, input().split())",
"n",
"l = map(int, input().split())",
"map(int, input().split())",
"l",
"ans += [j for j in range(1,i+1)]",
"[j for j in range(1,i+1)]",
"ans",
"ans += [j for j in range(n-1, i+1, -1)]",
"[j for j in range(n-1, i+1, -1)]",
"ans",
"ans = [\"Possible\"]",
"[\"Possible\"]",
"ans",
"ans = [\"Impossible\"]",
"[\"Impossible\"]",
"ans",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"input = lambda : sys.stdin.readline().rstrip()",
"lambda : sys.stdin.readline().rstrip()",
"input",
"write = lambda x: sys.stdout.write(x+\"\\n\")",
"lambda x: sys.stdout.write(x+\"\\n\")",
"write"
] | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,l = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n-1):
if a[i]+a[i+1]>=l:
ans = ["Possible"]
ans += [j for j in range(1,i+1)]
ans += [j for j in range(n-1, i+1, -1)]
ans.append(i+1)
break
else:
ans = ["Impossible"]
write("\n".join(map(str, ans))) |
[
7,
15,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
13,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
4,
13,
17,
4,
13,
0,
13,
39,
28,
13,
4,
13,
17,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
4,
13,
2,
13,
17,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
13,
4,
13,
17,
4,
13,
31,
13,
0,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13
] | [
[
141,
11
],
[
138,
18
],
[
144,
23
],
[
33,
32
],
[
142,
39
],
[
33,
41
],
[
44,
43
],
[
142,
52
],
[
56,
55
],
[
59,
58
],
[
32,
62
],
[
43,
67
],
[
58,
68
],
[
43,
70
],
[
58,
72
],
[
41,
74
],
[
77,
76
],
[
58,
77
],
[
86,
85
],
[
89,
88
],
[
76,
92
],
[
55,
92
],
[
85,
95
],
[
88,
97
],
[
100,
99
],
[
76,
105
],
[
55,
105
],
[
32,
107
],
[
85,
110
],
[
99,
112
],
[
85,
115
],
[
76,
117
],
[
55,
117
],
[
85,
124
],
[
127,
126
],
[
136,
133
],
[
138,
139
],
[
141,
142
],
[
144,
145
]
] | [
"import sys\n\nsys.setrecursionlimit(10 ** 7)\ninput = sys.stdin.readline\nf_inf = float('inf')\nmod = 10 ** 9 + 7\n\n\ndef resolve():\n n, L = map(int, input().split())\n A = list(map(int, input().split()))\n\n init = -1\n for i in range(1, n):\n if A[i] + A[i - 1] >= L:\n init = i\n break\n else:\n print(\"Impossible\")\n exit()\n res = []\n for i in range(1, init):\n res.append(i)\n\n for i in reversed(range(init + 1, n)):\n res.append(i)\n res.append(init)\n print(\"Possible\")\n print(*res, sep=\"\\n\")\n\n\nif __name__ == '__main__':\n resolve()",
"import sys",
"sys",
"sys.setrecursionlimit(10 ** 7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 7",
"10",
"7",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"f_inf = float('inf')",
"f_inf",
"float('inf')",
"float",
"'inf'",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def resolve():\n n, L = map(int, input().split())\n A = list(map(int, input().split()))\n\n init = -1\n for i in range(1, n):\n if A[i] + A[i - 1] >= L:\n init = i\n break\n else:\n print(\"Impossible\")\n exit()\n res = []\n for i in range(1, init):\n res.append(i)\n\n for i in reversed(range(init + 1, n)):\n res.append(i)\n res.append(init)\n print(\"Possible\")\n print(*res, sep=\"\\n\")",
"resolve",
"n, L = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"init = -1",
"init",
"-1",
"for i in range(1, n):\n if A[i] + A[i - 1] >= L:\n init = i\n break\n else:\n print(\"Impossible\")\n exit()\n ",
"i",
"range(1, n)",
"range",
"1",
"n",
"if A[i] + A[i - 1] >= L:\n init = i\n break\n ",
"A[i] + A[i - 1] >= L",
"A[i] + A[i - 1]",
"A[i]",
"A",
"i",
"A[i - 1]",
"A",
"i - 1",
"i",
"1",
"L",
"init = i",
"init",
"i",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit()",
"exit",
"res = []",
"res",
"[]",
"for i in range(1, init):\n res.append(i)\n\n ",
"i",
"range(1, init)",
"range",
"1",
"init",
"res.append(i)",
"res.append",
"res",
"append",
"i",
"for i in reversed(range(init + 1, n)):\n res.append(i)\n ",
"i",
"reversed(range(init + 1, n))",
"reversed",
"range(init + 1, n)",
"range",
"init + 1",
"init",
"1",
"n",
"res.append(i)",
"res.append",
"res",
"append",
"i",
"res.append(init)",
"res.append",
"res",
"append",
"init",
"print(\"Possible\")",
"print",
"\"Possible\"",
"print(*res, sep=\"\\n\")",
"print",
"*res",
"res",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"if __name__ == '__main__':\n resolve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"resolve()",
"resolve",
"def resolve():\n n, L = map(int, input().split())\n A = list(map(int, input().split()))\n\n init = -1\n for i in range(1, n):\n if A[i] + A[i - 1] >= L:\n init = i\n break\n else:\n print(\"Impossible\")\n exit()\n res = []\n for i in range(1, init):\n res.append(i)\n\n for i in reversed(range(init + 1, n)):\n res.append(i)\n res.append(init)\n print(\"Possible\")\n print(*res, sep=\"\\n\")",
"def resolve():\n n, L = map(int, input().split())\n A = list(map(int, input().split()))\n\n init = -1\n for i in range(1, n):\n if A[i] + A[i - 1] >= L:\n init = i\n break\n else:\n print(\"Impossible\")\n exit()\n res = []\n for i in range(1, init):\n res.append(i)\n\n for i in reversed(range(init + 1, n)):\n res.append(i)\n res.append(init)\n print(\"Possible\")\n print(*res, sep=\"\\n\")",
"resolve",
"f_inf = float('inf')",
"float('inf')",
"f_inf",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod"
] | import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, L = map(int, input().split())
A = list(map(int, input().split()))
init = -1
for i in range(1, n):
if A[i] + A[i - 1] >= L:
init = i
break
else:
print("Impossible")
exit()
res = []
for i in range(1, init):
res.append(i)
for i in reversed(range(init + 1, n)):
res.append(i)
res.append(init)
print("Possible")
print(*res, sep="\n")
if __name__ == '__main__':
resolve()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
13,
17,
3,
4,
13,
17,
4,
13,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
91,
2
],
[
91,
11
],
[
82,
13
],
[
26,
25
],
[
92,
29
],
[
83,
35
],
[
25,
36
],
[
83,
38
],
[
25,
40
],
[
89,
42
],
[
85,
44
],
[
25,
46
],
[
59,
58
],
[
86,
62
],
[
58,
65
],
[
68,
67
],
[
92,
71
],
[
86,
73
],
[
67,
77
],
[
86,
80
],
[
82,
83
],
[
85,
86
],
[
91,
89
],
[
91,
92
]
] | [
"n, l = map(int, input().split())\nA = list(map(int, input().split()))\nfor i in range(n-1):\n if A[i]+A[i+1] >= l:\n f = i+1\n break\nelse:\n print(\"Impossible\")\n exit()\nprint(\"Possible\")\nfor i in range(1, f):\n print(i)\nfor i in range(n-1, f, -1):\n print(i)\nprint(f)",
"n, l = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(n-1):\n if A[i]+A[i+1] >= l:\n f = i+1\n break\nelse:\n print(\"Impossible\")\n exit()",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if A[i]+A[i+1] >= l:\n f = i+1\n break",
"A[i]+A[i+1] >= l",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"l",
"f = i+1",
"f",
"i+1",
"i",
"1",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit()",
"exit",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(1, f):\n print(i)",
"i",
"range(1, f)",
"range",
"1",
"f",
"print(i)",
"print",
"i",
"for i in range(n-1, f, -1):\n print(i)",
"i",
"range(n-1, f, -1)",
"range",
"n-1",
"n",
"1",
"f",
"-1",
"print(i)",
"print",
"i",
"print(f)",
"print",
"f",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"f = i+1",
"i+1",
"f",
"l = map(int, input().split())",
"map(int, input().split())",
"l",
"n, l = map(int, input().split())",
"map(int, input().split())",
"n"
] | n, l = map(int, input().split())
A = list(map(int, input().split()))
for i in range(n-1):
if A[i]+A[i+1] >= l:
f = i+1
break
else:
print("Impossible")
exit()
print("Possible")
for i in range(1, f):
print(i)
for i in range(n-1, f, -1):
print(i)
print(f) |
[
7,
15,
13,
15,
13,
15,
4,
18,
13,
13,
2,
17,
17,
12,
13,
29,
18,
4,
18,
18,
13,
13,
13,
39,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
12,
13,
12,
13,
14,
40,
13,
17,
41,
28,
13,
4,
13,
13,
4,
39,
29,
13,
14,
2,
13,
17,
41,
28,
13,
4,
13,
13,
4,
4,
13,
29,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
0,
13,
13,
29,
4,
13,
13,
4,
13,
31,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
18,
4,
13,
2,
13,
17,
13,
39,
17,
4,
13,
13,
4,
13,
2,
13,
17,
4,
13,
9,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
165,
26
],
[
88,
40
],
[
45,
44
],
[
90,
47
],
[
90,
54
],
[
59,
58
],
[
88,
61
],
[
169,
64
],
[
70,
69
],
[
88,
72
],
[
175,
75
],
[
78,
77
],
[
77,
86
],
[
88,
88
],
[
90,
90
],
[
162,
92
],
[
175,
94
],
[
162,
95
],
[
171,
97
],
[
175,
99
],
[
102,
101
],
[
163,
105
],
[
172,
111
],
[
101,
112
],
[
172,
114
],
[
101,
116
],
[
160,
118
],
[
124,
123
],
[
101,
128
],
[
123,
132
],
[
135,
134
],
[
101,
139
],
[
163,
141
],
[
134,
146
],
[
101,
150
],
[
162,
160
],
[
162,
163
],
[
165,
166
],
[
171,
172
]
] | [
"import sys\nimport math\nfrom collections import defaultdict\n\nsys.setrecursionlimit(10**7)\ndef input():\n return sys.stdin.readline()[:-1]\n\nmod = 10**9 + 7\n\ndef I(): return int(input())\ndef LI(): return list(map(int, input().split()))\ndef LIR(row,col):\n if row <= 0:\n return [[] for _ in range(col)]\n elif col == 1:\n return [I() for _ in range(row)]\n else:\n read_all = [LI() for _ in range(row)]\n return map(list, zip(*read_all))\n\n#################\n\nN,L = LI()\na = LI()\n\nfor i in range(N-1):\n if a[i]+a[i+1] >= L:\n print('Possible')\n for j in range(1,i+1):\n print(j)\n for j in range(i+2,N)[::-1]:\n print(j)\n print(i+1)\n exit()\n else:\n continue\n\nprint('Impossible')",
"import sys",
"sys",
"import math",
"math",
"from collections import defaultdict",
"sys.setrecursionlimit(10**7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**7",
"10",
"7",
"def input():\n return sys.stdin.readline()[:-1]",
"input",
"return sys.stdin.readline()[:-1]",
"sys.stdin.readline()[:-1]",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
":-1",
"-1",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"def I(): return int(input())",
"I",
"def LI(): return list(map(int, input().split()))",
"LI",
"def LIR(row,col):\n if row <= 0:\n return [[] for _ in range(col)]\n elif col == 1:\n return [I() for _ in range(row)]\n else:\n read_all = [LI() for _ in range(row)]\n return map(list, zip(*read_all))\n\n#################",
"LIR",
"if row <= 0:\n return [[] for _ in range(col)]\n elif col == 1:\n return [I() for _ in range(row)]\n else:\n read_all = [LI() for _ in range(row)]\n return map(list, zip(*read_all))\n\n#################",
"row <= 0",
"row",
"0",
"[] for _ in range(col)",
"for _ in range(col)",
"_",
"range(col)",
"range",
"col",
"for _ in range(col)",
"[]",
"return [[] for _ in range(col)]",
"[[] for _ in range(col)]",
"elif col == 1:\n return [I() for _ in range(row)]\n ",
"col == 1",
"col",
"1",
"I() for _ in range(row)",
"for _ in range(row)",
"_",
"range(row)",
"range",
"row",
"for _ in range(row)",
"I()",
"I",
"return [I() for _ in range(row)]",
"[I() for _ in range(row)]",
"LI() for _ in range(row)",
"for _ in range(row)",
"_",
"range(row)",
"range",
"row",
"for _ in range(row)",
"LI()",
"LI",
"read_all = [LI() for _ in range(row)]",
"read_all",
"[LI() for _ in range(row)]",
"return map(list, zip(*read_all))",
"map(list, zip(*read_all))",
"map",
"list",
"zip(*read_all)",
"zip",
"*read_all",
"read_all",
"row",
"row",
"col",
"col",
"N,L = LI()",
"N",
"LI()",
"LI",
"L",
"a = LI()",
"a",
"LI()",
"LI",
"for i in range(N-1):\n if a[i]+a[i+1] >= L:\n print('Possible')\n for j in range(1,i+1):\n print(j)\n for j in range(i+2,N)[::-1]:\n print(j)\n print(i+1)\n exit()\n else:\n continue",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if a[i]+a[i+1] >= L:\n print('Possible')\n for j in range(1,i+1):\n print(j)\n for j in range(i+2,N)[::-1]:\n print(j)\n print(i+1)\n exit()\n else:\n continue",
"a[i]+a[i+1] >= L",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"L",
"print('Possible')",
"print",
"'Possible'",
"for j in range(1,i+1):\n print(j)\n ",
"j",
"range(1,i+1)",
"range",
"1",
"i+1",
"i",
"1",
"print(j)",
"print",
"j",
"for j in range(i+2,N)[::-1]:\n print(j)\n ",
"j",
"range(i+2,N)[::-1]",
"(i+2,N)",
"range",
"i+2",
"i",
"2",
"N",
"::-1",
"-1",
"print(j)",
"print",
"j",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"exit()",
"exit",
"continue",
"print('Impossible')",
"print",
"'Impossible'",
"L = LI()",
"LI()",
"L",
"N,L = LI()",
"LI()",
"N",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"def I(): return int(input())",
"def I(): return int(input())",
"I",
"a = LI()",
"LI()",
"a",
"def LI(): return list(map(int, input().split()))",
"def LI(): return list(map(int, input().split()))",
"LI",
"def input():\n return sys.stdin.readline()[:-1]",
"def input():\n return sys.stdin.readline()[:-1]",
"input",
"def LIR(row,col):\n if row <= 0:\n return [[] for _ in range(col)]\n elif col == 1:\n return [I() for _ in range(row)]\n else:\n read_all = [LI() for _ in range(row)]\n return map(list, zip(*read_all))\n\n#################",
"def LIR(row,col):\n if row <= 0:\n return [[] for _ in range(col)]\n elif col == 1:\n return [I() for _ in range(row)]\n else:\n read_all = [LI() for _ in range(row)]\n return map(list, zip(*read_all))\n\n#################",
"LIR"
] | import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return map(list, zip(*read_all))
#################
N,L = LI()
a = LI()
for i in range(N-1):
if a[i]+a[i+1] >= L:
print('Possible')
for j in range(1,i+1):
print(j)
for j in range(i+2,N)[::-1]:
print(j)
print(i+1)
exit()
else:
continue
print('Impossible') |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
31,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
13,
0,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
14,
40,
13,
13,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
17,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13
] | [
[
104,
2
],
[
104,
11
],
[
15,
13
],
[
110,
24
],
[
101,
27
],
[
31,
30
],
[
99,
34
],
[
111,
38
],
[
96,
38
],
[
30,
43
],
[
30,
47
],
[
107,
49
],
[
30,
50
],
[
95,
52
],
[
30,
57
],
[
30,
61
],
[
96,
64
],
[
111,
64
],
[
105,
65
],
[
71,
70
],
[
108,
73
],
[
102,
73
],
[
70,
77
],
[
81,
80
],
[
99,
84
],
[
108,
86
],
[
102,
86
],
[
80,
90
],
[
95,
96
],
[
104,
99
],
[
101,
102
],
[
104,
105
],
[
30,
107
],
[
107,
108
],
[
110,
111
]
] | [
"n,l=map(int, input().split())\n*a,=map(int, input().split())\nmx=0\nind=-1\nfor i in range(n-1):\n if mx<=a[i+1]+a[i]:\n ind=i\n mx=a[i+1]+a[i]\nif mx>=l:\n print(\"Possible\")\n for i in range(ind):\n print(i+1)\n for i in range(n-1,ind,-1):\n print(i)\nelse:\n print(\"Impossible\")",
"n,l=map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"*a,=map(int, input().split())",
"*a",
"a",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mx=0",
"mx",
"0",
"ind=-1",
"ind",
"-1",
"for i in range(n-1):\n if mx<=a[i+1]+a[i]:\n ind=i\n mx=a[i+1]+a[i]",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if mx<=a[i+1]+a[i]:\n ind=i\n mx=a[i+1]+a[i]",
"mx<=a[i+1]+a[i]",
"mx",
"a[i+1]+a[i]",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"a[i]",
"a",
"i",
"ind=i",
"ind",
"i",
"mx=a[i+1]+a[i]",
"mx",
"a[i+1]+a[i]",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"a[i]",
"a",
"i",
"if mx>=l:\n print(\"Possible\")\n for i in range(ind):\n print(i+1)\n for i in range(n-1,ind,-1):\n print(i)\nelse:\n print(\"Impossible\")",
"mx>=l",
"mx",
"l",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(ind):\n print(i+1)\n ",
"i",
"range(ind)",
"range",
"ind",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for i in range(n-1,ind,-1):\n print(i)",
"i",
"range(n-1,ind,-1)",
"range",
"n-1",
"n",
"1",
"ind",
"-1",
"print(i)",
"print",
"i",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"mx=a[i+1]+a[i]",
"a[i+1]+a[i]",
"mx",
"n,l=map(int, input().split())",
"map(int, input().split())",
"n",
"ind=-1",
"-1",
"ind",
"l=map(int, input().split())",
"map(int, input().split())",
"l",
"ind=i",
"i",
"ind",
"mx=0",
"0",
"mx"
] | n,l=map(int, input().split())
*a,=map(int, input().split())
mx=0
ind=-1
for i in range(n-1):
if mx<=a[i+1]+a[i]:
ind=i
mx=a[i+1]+a[i]
if mx>=l:
print("Possible")
for i in range(ind):
print(i+1)
for i in range(n-1,ind,-1):
print(i)
else:
print("Impossible") |
[
7,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
13,
4,
13,
17,
29,
4,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
4,
13,
2,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
13
],
[
16,
15
],
[
28,
27
],
[
4,
28
],
[
31,
30
],
[
4,
34
],
[
15,
40
],
[
30,
41
],
[
15,
43
],
[
30,
45
],
[
13,
47
],
[
50,
49
],
[
30,
50
],
[
49,
54
],
[
27,
54
],
[
4,
55
],
[
65,
64
],
[
49,
67
],
[
27,
67
],
[
70,
69
],
[
4,
74
],
[
49,
75
],
[
27,
75
],
[
49,
80
],
[
27,
80
],
[
90,
87
]
] | [
"#! /usr/bin/env python3\n\ndef main():\n N, L = map(int, input().split())\n A = list(map(int, input().split()))\n la = N\n for i in range(N-1):\n if A[i] + A[i+1] >= L:\n la = i\n break\n if la == N:\n print('Impossible')\n return\n print('Possible')\n for i in range(la) : print(i+1)\n for i in range(N-la-2) : print(N-i-1)\n print(la+1)\nif __name__ == '__main__':\n main()",
"def main():\n N, L = map(int, input().split())\n A = list(map(int, input().split()))\n la = N\n for i in range(N-1):\n if A[i] + A[i+1] >= L:\n la = i\n break\n if la == N:\n print('Impossible')\n return\n print('Possible')\n for i in range(la) : print(i+1)\n for i in range(N-la-2) : print(N-i-1)\n print(la+1)",
"main",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"la = N",
"la",
"N",
"for i in range(N-1):\n if A[i] + A[i+1] >= L:\n la = i\n break\n ",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i] + A[i+1] >= L:\n la = i\n break\n ",
"A[i] + A[i+1] >= L",
"A[i] + A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"la = i",
"la",
"i",
"break",
"if la == N:\n print('Impossible')\n return\n ",
"la == N",
"la",
"N",
"print('Impossible')",
"print",
"'Impossible'",
"return",
"print('Possible')",
"print",
"'Possible'",
"for i in range(la) : print(i+1)\n ",
"i",
"range(la)",
"range",
"la",
"for i in range(N-la-2) : print(N-i-1)\n ",
"i",
"range(N-la-2)",
"range",
"N-la-2",
"N-la",
"N",
"la",
"2",
"print(la+1)",
"print",
"la+1",
"la",
"1",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n N, L = map(int, input().split())\n A = list(map(int, input().split()))\n la = N\n for i in range(N-1):\n if A[i] + A[i+1] >= L:\n la = i\n break\n if la == N:\n print('Impossible')\n return\n print('Possible')\n for i in range(la) : print(i+1)\n for i in range(N-la-2) : print(N-i-1)\n print(la+1)",
"def main():\n N, L = map(int, input().split())\n A = list(map(int, input().split()))\n la = N\n for i in range(N-1):\n if A[i] + A[i+1] >= L:\n la = i\n break\n if la == N:\n print('Impossible')\n return\n print('Possible')\n for i in range(la) : print(i+1)\n for i in range(N-la-2) : print(N-i-1)\n print(la+1)",
"main"
] | #! /usr/bin/env python3
def main():
N, L = map(int, input().split())
A = list(map(int, input().split()))
la = N
for i in range(N-1):
if A[i] + A[i+1] >= L:
la = i
break
if la == N:
print('Impossible')
return
print('Possible')
for i in range(la) : print(i+1)
for i in range(N-la-2) : print(N-i-1)
print(la+1)
if __name__ == '__main__':
main() |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
0,
13,
2,
13,
17,
3,
14,
40,
13,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13
] | [
[
101,
2
],
[
101,
11
],
[
95,
13
],
[
104,
25
],
[
29,
28
],
[
90,
32
],
[
96,
38
],
[
28,
39
],
[
96,
41
],
[
28,
43
],
[
102,
45
],
[
92,
47
],
[
98,
50
],
[
28,
52
],
[
93,
57
],
[
105,
57
],
[
66,
65
],
[
99,
69
],
[
65,
72
],
[
75,
74
],
[
90,
78
],
[
99,
80
],
[
74,
84
],
[
99,
87
],
[
101,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
]
] | [
"N,L=map(int,input().split())\nA=list(map(int,input().split()))\nflag=False\nfor i in range(N-1):\n if A[i]+A[i+1]>=L:\n flag=True\n idx=i+1\n break\nif not flag:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,idx):\n print(i)\n for i in range(N-1,idx,-1):\n print(i)\n print(idx)",
"N,L=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"flag=False",
"flag",
"False",
"for i in range(N-1):\n if A[i]+A[i+1]>=L:\n flag=True\n idx=i+1\n break",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i]+A[i+1]>=L:\n flag=True\n idx=i+1\n break",
"A[i]+A[i+1]>=L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"flag=True",
"flag",
"True",
"idx=i+1",
"idx",
"i+1",
"i",
"1",
"break",
"if not flag:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,idx):\n print(i)\n for i in range(N-1,idx,-1):\n print(i)\n print(idx)",
"not flag",
"flag",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"for i in range(1,idx):\n print(i)\n ",
"i",
"range(1,idx)",
"range",
"1",
"idx",
"print(i)",
"print",
"i",
"for i in range(N-1,idx,-1):\n print(i)\n ",
"i",
"range(N-1,idx,-1)",
"range",
"N-1",
"N",
"1",
"idx",
"-1",
"print(i)",
"print",
"i",
"print(idx)",
"print",
"idx",
"N,L=map(int,input().split())",
"map(int,input().split())",
"N",
"flag=True",
"True",
"flag",
"A=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"idx=i+1",
"i+1",
"idx",
"L=map(int,input().split())",
"map(int,input().split())",
"L",
"flag=False",
"False",
"flag"
] | N,L=map(int,input().split())
A=list(map(int,input().split()))
flag=False
for i in range(N-1):
if A[i]+A[i+1]>=L:
flag=True
idx=i+1
break
if not flag:
print('Impossible')
else:
print('Possible')
for i in range(1,idx):
print(i)
for i in range(N-1,idx,-1):
print(i)
print(idx) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] | [
[
95,
2
],
[
95,
11
],
[
98,
13
],
[
89,
25
],
[
29,
28
],
[
96,
32
],
[
99,
38
],
[
28,
39
],
[
99,
41
],
[
28,
43
],
[
87,
45
],
[
92,
47
],
[
28,
48
],
[
93,
52
],
[
90,
52
],
[
64,
63
],
[
93,
68
],
[
90,
68
],
[
63,
72
],
[
75,
74
],
[
96,
78
],
[
93,
80
],
[
90,
80
],
[
74,
84
],
[
95,
87
],
[
89,
90
],
[
28,
92
],
[
92,
93
],
[
95,
96
],
[
98,
99
]
] | [
"n, k = map(int,input().split())\na = list(map(int,input().split()))\nidx = -1\nfor i in range(n-1):\n if a[i]+a[i+1]>=k:\n idx = i\n break\nif idx == -1:\n print('Impossible')\n exit()\nelse:\n print('Possible')\n for i in range(1, idx+1):\n print(i)\n for i in range(n-1, idx, -1):\n print(i)",
"n, k = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"k",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"idx = -1",
"idx",
"-1",
"for i in range(n-1):\n if a[i]+a[i+1]>=k:\n idx = i\n break",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1]>=k:\n idx = i\n break",
"a[i]+a[i+1]>=k",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"k",
"idx = i",
"idx",
"i",
"break",
"if idx == -1:\n print('Impossible')\n exit()\nelse:\n print('Possible')\n for i in range(1, idx+1):\n print(i)\n for i in range(n-1, idx, -1):\n print(i)",
"idx == -1",
"idx",
"-1",
"print('Impossible')",
"print",
"'Impossible'",
"exit()",
"exit",
"print('Possible')",
"print",
"'Possible'",
"for i in range(1, idx+1):\n print(i)\n ",
"i",
"range(1, idx+1)",
"range",
"1",
"idx+1",
"idx",
"1",
"print(i)",
"print",
"i",
"for i in range(n-1, idx, -1):\n print(i)",
"i",
"range(n-1, idx, -1)",
"range",
"n-1",
"n",
"1",
"idx",
"-1",
"print(i)",
"print",
"i",
"k = map(int,input().split())",
"map(int,input().split())",
"k",
"idx = -1",
"-1",
"idx",
"idx = i",
"i",
"idx",
"n, k = map(int,input().split())",
"map(int,input().split())",
"n",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a"
] | n, k = map(int,input().split())
a = list(map(int,input().split()))
idx = -1
for i in range(n-1):
if a[i]+a[i+1]>=k:
idx = i
break
if idx == -1:
print('Impossible')
exit()
else:
print('Possible')
for i in range(1, idx+1):
print(i)
for i in range(n-1, idx, -1):
print(i) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
18,
13,
17,
18,
13,
17,
0,
13,
2,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
2,
13,
17,
14,
2,
13,
13,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13
] | [
[
118,
2
],
[
118,
11
],
[
109,
13
],
[
115,
25
],
[
110,
28
],
[
110,
31
],
[
115,
34
],
[
106,
37
],
[
41,
40
],
[
119,
44
],
[
121,
47
],
[
110,
50
],
[
40,
52
],
[
110,
55
],
[
40,
56
],
[
122,
59
],
[
116,
59
],
[
113,
60
],
[
125,
60
],
[
124,
62
],
[
122,
63
],
[
116,
63
],
[
127,
65
],
[
40,
67
],
[
125,
71
],
[
113,
71
],
[
104,
72
],
[
81,
80
],
[
128,
85
],
[
107,
85
],
[
80,
89
],
[
92,
91
],
[
119,
95
],
[
128,
97
],
[
107,
97
],
[
91,
101
],
[
118,
104
],
[
106,
107
],
[
109,
110
],
[
115,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
],
[
122,
124
],
[
116,
124
],
[
124,
125
],
[
127,
128
]
] | [
"N, L = map(int, input().split())\nA = list(map(int, input().split()))\nl = max_2 = A[0] + A[1]\nidx = 0\nfor i in range(N-2):\n l += A[i+2] - A[i]\n if l > max_2:\n max_2 = l\n idx = i + 1\n\nif max_2 < L:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1, idx + 1):\n print(i)\n for i in range(N-1, idx, -1):\n print(i)",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l = max_2 = A[0] + A[1]",
"l",
"A[0] + A[1]",
"A[0]",
"A",
"0",
"A[1]",
"A",
"1",
"= max_2 = A[0] + A[1]",
"max_2",
"A[0] + A[1]",
"idx = 0",
"idx",
"0",
"for i in range(N-2):\n l += A[i+2] - A[i]\n if l > max_2:\n max_2 = l\n idx = i + 1",
"i",
"range(N-2)",
"range",
"N-2",
"N",
"2",
"l += A[i+2] - A[i]",
"l",
"A[i+2] - A[i]",
"A[i+2]",
"A",
"i+2",
"i",
"2",
"A[i]",
"A",
"i",
"if l > max_2:\n max_2 = l\n idx = i + 1",
"l > max_2",
"l",
"max_2",
"max_2 = l",
"max_2",
"l",
"idx = i + 1",
"idx",
"i + 1",
"i",
"1",
"if max_2 < L:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1, idx + 1):\n print(i)\n for i in range(N-1, idx, -1):\n print(i)",
"max_2 < L",
"max_2",
"L",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"for i in range(1, idx + 1):\n print(i)\n ",
"i",
"range(1, idx + 1)",
"range",
"1",
"idx + 1",
"idx",
"1",
"print(i)",
"print",
"i",
"for i in range(N-1, idx, -1):\n print(i)",
"i",
"range(N-1, idx, -1)",
"range",
"N-1",
"N",
"1",
"idx",
"-1",
"print(i)",
"print",
"i",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"idx = 0",
"0",
"idx",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"max_2 = A[0] + A[1]",
"A[0] + A[1]",
"max_2",
"l = max_2 = A[0] + A[1]",
"A[0] + A[1]",
"l",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"l += A[i+2] - A[i]",
"A[i+2] - A[i]",
"l",
"max_2 = l",
"l",
"max_2",
"idx = i + 1",
"i + 1",
"idx"
] | N, L = map(int, input().split())
A = list(map(int, input().split()))
l = max_2 = A[0] + A[1]
idx = 0
for i in range(N-2):
l += A[i+2] - A[i]
if l > max_2:
max_2 = l
idx = i + 1
if max_2 < L:
print('Impossible')
else:
print('Possible')
for i in range(1, idx + 1):
print(i)
for i in range(N-1, idx, -1):
print(i) |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
18,
13,
13,
13,
3,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
2,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
2,
18,
13,
17,
17,
2,
13,
17,
4,
18,
13,
13,
4,
13,
17,
28,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
18,
13
] | [
[
113,
4
],
[
107,
11
],
[
114,
18
],
[
107,
20
],
[
104,
22
],
[
114,
31
],
[
110,
34
],
[
38,
37
],
[
102,
41
],
[
105,
47
],
[
37,
48
],
[
105,
50
],
[
37,
52
],
[
108,
54
],
[
111,
57
],
[
37,
59
],
[
69,
68
],
[
111,
73
],
[
80,
79
],
[
111,
84
],
[
102,
88
],
[
111,
92
],
[
99,
98
],
[
111,
98
],
[
107,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
]
] | [
"import sys\ninput = sys.stdin.readline\nN, L = map(int, input().split())\na = list(map(int, input().split()))\nres = []\nfor i in range(N - 1):\n if a[i] + a[i + 1] >= L:\n res.append(i)\n break\nelse:\n print(\"Impossible\")\n exit(0)\nfor i in range(res[0] - 1, -1, -1): res.append(i)\nfor i in range(res[0] + 1, N - 1): res.append(i)\nres.reverse()\nprint(\"Possible\")\nfor r in res: print(r + 1)",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"res = []",
"res",
"[]",
"for i in range(N - 1):\n if a[i] + a[i + 1] >= L:\n res.append(i)\n break\nelse:\n print(\"Impossible\")\n exit(0)",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"if a[i] + a[i + 1] >= L:\n res.append(i)\n break",
"a[i] + a[i + 1] >= L",
"a[i] + a[i + 1]",
"a[i]",
"a",
"i",
"a[i + 1]",
"a",
"i + 1",
"i",
"1",
"L",
"res.append(i)",
"res.append",
"res",
"append",
"i",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit(0)",
"exit",
"0",
"for i in range(res[0] - 1, -1, -1): res.append(i)",
"i",
"range(res[0] - 1, -1, -1)",
"range",
"res[0] - 1",
"res[0]",
"res",
"0",
"1",
"-1",
"-1",
"for i in range(res[0] + 1, N - 1): res.append(i)",
"i",
"range(res[0] + 1, N - 1)",
"range",
"res[0] + 1",
"res[0]",
"res",
"0",
"1",
"N - 1",
"N",
"1",
"res.reverse()",
"res.reverse",
"res",
"reverse",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for r in res: print(r + 1)",
"r",
"res",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"res = []",
"[]",
"res",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input"
] | import sys
input = sys.stdin.readline
N, L = map(int, input().split())
a = list(map(int, input().split()))
res = []
for i in range(N - 1):
if a[i] + a[i + 1] >= L:
res.append(i)
break
else:
print("Impossible")
exit(0)
for i in range(res[0] - 1, -1, -1): res.append(i)
for i in range(res[0] + 1, N - 1): res.append(i)
res.reverse()
print("Possible")
for r in res: print(r + 1) |
[
7,
15,
13,
13,
13,
13,
13,
13,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
39,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
18,
13,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
17,
13,
17,
28,
13,
13,
4,
13,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
13,
14,
40,
13,
13,
13,
28,
13,
4,
13,
13,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
17,
13,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13
] | [
[
128,
12
],
[
128,
21
],
[
107,
23
],
[
125,
33
],
[
117,
38
],
[
42,
41
],
[
117,
45
],
[
51,
48
],
[
126,
49
],
[
41,
50
],
[
108,
53
],
[
41,
54
],
[
108,
56
],
[
41,
58
],
[
119,
61
],
[
110,
63
],
[
126,
70
],
[
120,
74
],
[
114,
74
],
[
113,
76
],
[
122,
79
],
[
114,
83
],
[
120,
83
],
[
129,
84
],
[
88,
87
],
[
123,
90
],
[
111,
90
],
[
87,
93
],
[
97,
96
],
[
117,
100
],
[
123,
102
],
[
111,
102
],
[
107,
108
],
[
110,
111
],
[
113,
114
],
[
128,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
128,
129
]
] | [
"# -*- coding: utf-8 -*-\nimport sys,copy,math,heapq,itertools as it,fractions,re,bisect,collections as coll\n\nN, L = map(int, raw_input().split())\na = map(int, raw_input().split())\nb = [0]*(N - 1)\nfor i in xrange(N - 1):\n b[i] = a[i] + a[i + 1]\n\nmx, idx = 0, 0\nfor i, bi in enumerate(b):\n if bi > mx:\n mx = bi\n idx = i\n\nif mx >= L:\n print \"Possible\"\n for i in xrange(idx):\n print i + 1\n for i in xrange(N - 1, idx, -1):\n print i\nelse:\n print \"Impossible\"",
"import sys,copy,math,heapq,itertools as it,fractions,re,bisect,collections as coll",
"sys",
"copy",
"math",
"heapq",
"itertools",
"fractions",
"re",
"bisect",
"collections",
"N, L = map(int, raw_input().split())",
"N",
"map(int, raw_input().split())",
"map",
"int",
"raw_input().split()",
"().split",
"()",
"raw_input",
"split",
"L",
"a = map(int, raw_input().split())",
"a",
"map(int, raw_input().split())",
"map",
"int",
"raw_input().split()",
"().split",
"()",
"raw_input",
"split",
"b = [0]*(N - 1)",
"b",
"[0]*(N - 1)",
"[0]",
"0",
"N - 1",
"N",
"1",
"for i in xrange(N - 1):\n b[i] = a[i] + a[i + 1]",
"i",
"xrange(N - 1)",
"xrange",
"N - 1",
"N",
"1",
"b[i] = a[i] + a[i + 1]",
"b[i]",
"b",
"i",
"a[i] + a[i + 1]",
"a[i]",
"a",
"i",
"a[i + 1]",
"a",
"i + 1",
"i",
"1",
"mx, idx = 0, 0",
"mx",
"0",
"idx",
"0",
"for i, bi in enumerate(b):\n if bi > mx:\n mx = bi\n idx = i",
"i",
"bi",
"enumerate(b)",
"enumerate",
"b",
"if bi > mx:\n mx = bi\n idx = i",
"bi > mx",
"bi",
"mx",
"mx = bi",
"mx",
"bi",
"idx = i",
"idx",
"i",
"if mx >= L:\n print \"Possible\"\n for i in xrange(idx):\n print i + 1\n for i in xrange(N - 1, idx, -1):\n print i\nelse:\n print \"Impossible\"",
"mx >= L",
"mx",
"L",
"print",
"for i in xrange(idx):\n print i + 1\n ",
"i",
"xrange(idx)",
"xrange",
"idx",
"print",
"i + 1",
"i",
"1",
"for i in xrange(N - 1, idx, -1):\n print i",
"i",
"xrange(N - 1, idx, -1)",
"xrange",
"N - 1",
"N",
"1",
"idx",
"-1",
"print",
"print",
"a = map(int, raw_input().split())",
"map(int, raw_input().split())",
"a",
"idx = 0, 0",
"0",
"idx",
"mx = bi",
"bi",
"mx",
"N, L = map(int, raw_input().split())",
"map(int, raw_input().split())",
"N",
"mx, idx = 0, 0",
"0",
"mx",
"idx = i",
"i",
"idx",
"b = [0]*(N - 1)",
"[0]*(N - 1)",
"b",
"L = map(int, raw_input().split())",
"map(int, raw_input().split())",
"L"
] | # -*- coding: utf-8 -*-
import sys,copy,math,heapq,itertools as it,fractions,re,bisect,collections as coll
N, L = map(int, raw_input().split())
a = map(int, raw_input().split())
b = [0]*(N - 1)
for i in xrange(N - 1):
b[i] = a[i] + a[i + 1]
mx, idx = 0, 0
for i, bi in enumerate(b):
if bi > mx:
mx = bi
idx = i
if mx >= L:
print "Possible"
for i in xrange(idx):
print i + 1
for i in xrange(N - 1, idx, -1):
print i
else:
print "Impossible"
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
13,
17,
3,
4,
13,
17,
4,
13,
0,
13,
2,
4,
13,
4,
13,
17,
13,
18,
4,
13,
4,
13,
13,
13,
39,
17,
4,
13,
17,
4,
13,
31,
13,
0,
13,
17,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
98,
2
],
[
98,
11
],
[
101,
13
],
[
89,
25
],
[
29,
28
],
[
96,
32
],
[
102,
38
],
[
28,
39
],
[
102,
41
],
[
28,
43
],
[
99,
45
],
[
92,
47
],
[
28,
49
],
[
86,
58
],
[
93,
65
],
[
90,
65
],
[
93,
71
],
[
90,
71
],
[
96,
72
],
[
87,
81
],
[
84,
83
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
98,
96
],
[
98,
99
],
[
101,
102
]
] | [
"N, L = map(int, input().split())\na = list(map(int, input().split()))\nend = 0\nfor i in range(N - 1):\n if a[i] + a[i + 1] >= L:\n end = i + 1\n break\nelse:\n print('Impossible')\n exit()\n\nans = list(range(1, end)) + list(range(end, N))[::-1]\nprint('Possible')\nprint(*ans, sep='\\n')",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"end = 0",
"end",
"0",
"for i in range(N - 1):\n if a[i] + a[i + 1] >= L:\n end = i + 1\n break\nelse:\n print('Impossible')\n exit()",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"if a[i] + a[i + 1] >= L:\n end = i + 1\n break",
"a[i] + a[i + 1] >= L",
"a[i] + a[i + 1]",
"a[i]",
"a",
"i",
"a[i + 1]",
"a",
"i + 1",
"i",
"1",
"L",
"end = i + 1",
"end",
"i + 1",
"i",
"1",
"break",
"print('Impossible')",
"print",
"'Impossible'",
"exit()",
"exit",
"ans = list(range(1, end)) + list(range(end, N))[::-1]",
"ans",
"list(range(1, end)) + list(range(end, N))[::-1]",
"list(range(1, end))",
"list",
"range(1, end)",
"range",
"1",
"end",
"list(range(end, N))[::-1]",
"(range(end, N))",
"list",
"range(end, N)",
"range",
"end",
"N",
"::-1",
"-1",
"print('Possible')",
"print",
"'Possible'",
"print(*ans, sep='\\n')",
"print",
"*ans",
"ans",
"sep='\\n'",
"sep",
"'\\n'",
"ans = list(range(1, end)) + list(range(end, N))[::-1]",
"list(range(1, end)) + list(range(end, N))[::-1]",
"ans",
"end = 0",
"0",
"end",
"end = i + 1",
"i + 1",
"end",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a"
] | N, L = map(int, input().split())
a = list(map(int, input().split()))
end = 0
for i in range(N - 1):
if a[i] + a[i + 1] >= L:
end = i + 1
break
else:
print('Impossible')
exit()
ans = list(range(1, end)) + list(range(end, N))[::-1]
print('Possible')
print(*ans, sep='\n') |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
2,
13,
17,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] | [
[
98,
2
],
[
98,
11
],
[
101,
13
],
[
89,
25
],
[
29,
28
],
[
99,
33
],
[
102,
39
],
[
28,
40
],
[
102,
42
],
[
28,
44
],
[
93,
46
],
[
95,
48
],
[
28,
49
],
[
96,
53
],
[
90,
53
],
[
63,
62
],
[
99,
66
],
[
96,
69
],
[
90,
69
],
[
62,
74
],
[
77,
76
],
[
96,
81
],
[
90,
81
],
[
76,
86
],
[
89,
90
],
[
98,
93
],
[
28,
95
],
[
95,
96
],
[
98,
99
],
[
101,
102
]
] | [
"N,L=map(int,input().split())\na=list(map(int,input().split()))\n\nx=-1\nfor i in range(0,N-1):\n if a[i]+a[i+1]>=L:\n x=i\n break\nif x==-1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(N-1, x+1,-1):\n print(i)\n for i in range(0,x+1):\n print(i+1)",
"N,L=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x=-1",
"x",
"-1",
"for i in range(0,N-1):\n if a[i]+a[i+1]>=L:\n x=i\n break",
"i",
"range(0,N-1)",
"range",
"0",
"N-1",
"N",
"1",
"if a[i]+a[i+1]>=L:\n x=i\n break",
"a[i]+a[i+1]>=L",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"L",
"x=i",
"x",
"i",
"break",
"if x==-1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(N-1, x+1,-1):\n print(i)\n for i in range(0,x+1):\n print(i+1)",
"x==-1",
"x",
"-1",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(N-1, x+1,-1):\n print(i)\n ",
"i",
"range(N-1, x+1,-1)",
"range",
"N-1",
"N",
"1",
"x+1",
"x",
"1",
"-1",
"print(i)",
"print",
"i",
"for i in range(0,x+1):\n print(i+1)",
"i",
"range(0,x+1)",
"range",
"0",
"x+1",
"x",
"1",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"x=-1",
"-1",
"x",
"L=map(int,input().split())",
"map(int,input().split())",
"L",
"x=i",
"i",
"x",
"N,L=map(int,input().split())",
"map(int,input().split())",
"N",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a"
] | N,L=map(int,input().split())
a=list(map(int,input().split()))
x=-1
for i in range(0,N-1):
if a[i]+a[i+1]>=L:
x=i
break
if x==-1:
print("Impossible")
else:
print("Possible")
for i in range(N-1, x+1,-1):
print(i)
for i in range(0,x+1):
print(i+1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
4,
13,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
83,
2
],
[
83,
11
],
[
15,
14
],
[
14,
23
],
[
86,
25
],
[
29,
28
],
[
81,
32
],
[
87,
38
],
[
28,
39
],
[
87,
41
],
[
28,
43
],
[
84,
45
],
[
51,
50
],
[
81,
54
],
[
28,
57
],
[
50,
62
],
[
65,
64
],
[
28,
69
],
[
64,
73
],
[
83,
81
],
[
83,
84
],
[
86,
87
]
] | [
"n,l = map(int,input().split())\na = [int(i) for i in input().split()]\nfor i in range(n-1):\n if a[i]+a[i+1] >= l:\n print('Possible')\n for j in range(n-1,i+1,-1):\n print(j)\n for k in range(1,i+2):\n print(k)\n exit()\nprint('Impossible')",
"n,l = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"a = [int(i) for i in input().split()]",
"a",
"[int(i) for i in input().split()]",
"for i in range(n-1):\n if a[i]+a[i+1] >= l:\n print('Possible')\n for j in range(n-1,i+1,-1):\n print(j)\n for k in range(1,i+2):\n print(k)\n exit()",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1] >= l:\n print('Possible')\n for j in range(n-1,i+1,-1):\n print(j)\n for k in range(1,i+2):\n print(k)\n exit()",
"a[i]+a[i+1] >= l",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"print('Possible')",
"print",
"'Possible'",
"for j in range(n-1,i+1,-1):\n print(j)\n ",
"j",
"range(n-1,i+1,-1)",
"range",
"n-1",
"n",
"1",
"i+1",
"i",
"1",
"-1",
"print(j)",
"print",
"j",
"for k in range(1,i+2):\n print(k)\n ",
"k",
"range(1,i+2)",
"range",
"1",
"i+2",
"i",
"2",
"print(k)",
"print",
"k",
"exit()",
"exit",
"print('Impossible')",
"print",
"'Impossible'",
"n,l = map(int,input().split())",
"map(int,input().split())",
"n",
"l = map(int,input().split())",
"map(int,input().split())",
"l",
"a = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"a"
] | n,l = map(int,input().split())
a = [int(i) for i in input().split()]
for i in range(n-1):
if a[i]+a[i+1] >= l:
print('Possible')
for j in range(n-1,i+1,-1):
print(j)
for k in range(1,i+2):
print(k)
exit()
print('Impossible') |
[
7,
15,
13,
13,
15,
15,
15,
15,
15,
15,
15,
15,
15,
15,
12,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
0,
13,
4,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
4,
13,
17,
4,
13,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
25,
24
],
[
131,
30
],
[
34,
34
],
[
133,
43
],
[
118,
48
],
[
148,
55
],
[
131,
57
],
[
148,
58
],
[
142,
60
],
[
128,
62
],
[
65,
64
],
[
122,
68
],
[
143,
74
],
[
64,
75
],
[
143,
77
],
[
64,
79
],
[
149,
81
],
[
124,
83
],
[
64,
84
],
[
96,
95
],
[
95,
100
],
[
95,
104
],
[
107,
106
],
[
122,
110
],
[
106,
112
],
[
106,
116
],
[
118,
119
],
[
148,
122
],
[
64,
124
],
[
124,
125
],
[
133,
134
],
[
142,
143
],
[
148,
149
]
] | [
"import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians\nfrom itertools import accumulate, permutations, combinations, product\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom bisect import bisect, bisect_left\nfrom fractions import gcd\nfrom heapq import heappush, heappop\nfrom functools import reduce\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef ZIP(n): return zip(*(MAP() for _ in range(n)))\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10 ** 9 + 7\n\nN, L = MAP()\na = LIST()\n\nfor i in range(N-1):\n if a[i]+a[i+1] >= L:\n idx = i\n break\nelse:\n print(\"Impossible\")\n exit()\n\nprint(\"Possible\")\n\nfor i in range(1, i+1):\n print(i)\n\nfor i in range(N-1, i, -1):\n print(i)",
"import sys, re",
"sys",
"re",
"from collections import deque, defaultdict, Counter",
"from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians",
"from itertools import accumulate, permutations, combinations, product",
"from operator import itemgetter, mul",
"from copy import deepcopy",
"from string import ascii_lowercase, ascii_uppercase, digits",
"from bisect import bisect, bisect_left",
"from fractions import gcd",
"from heapq import heappush, heappop",
"from functools import reduce",
"def input(): return sys.stdin.readline().strip()",
"input",
"def INT(): return int(input())",
"INT",
"def MAP(): return map(int, input().split())",
"MAP",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"MAP() for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"MAP()",
"MAP",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"n",
"n",
"sys.setrecursionlimit(10 ** 9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 9",
"10",
"9",
"INF = float('inf')",
"INF",
"float('inf')",
"float",
"'inf'",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N, L = MAP()",
"N",
"MAP()",
"MAP",
"L",
"a = LIST()",
"a",
"LIST()",
"LIST",
"for i in range(N-1):\n if a[i]+a[i+1] >= L:\n idx = i\n break\nelse:\n print(\"Impossible\")\n exit()",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if a[i]+a[i+1] >= L:\n idx = i\n break",
"a[i]+a[i+1] >= L",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"L",
"idx = i",
"idx",
"i",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit()",
"exit",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(1, i+1):\n print(i)",
"i",
"range(1, i+1)",
"range",
"1",
"i+1",
"i",
"1",
"print(i)",
"print",
"i",
"for i in range(N-1, i, -1):\n print(i)",
"i",
"range(N-1, i, -1)",
"range",
"N-1",
"N",
"1",
"i",
"-1",
"print(i)",
"print",
"i",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"N, L = MAP()",
"MAP()",
"N",
"idx = i",
"i",
"idx",
"def LIST(): return list(map(int, input().split()))",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"def MAP(): return map(int, input().split())",
"def MAP(): return map(int, input().split())",
"MAP",
"INF = float('inf')",
"float('inf')",
"INF",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input",
"a = LIST()",
"LIST()",
"a",
"def INT(): return int(input())",
"def INT(): return int(input())",
"INT",
"L = MAP()",
"MAP()",
"L"
] | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N, L = MAP()
a = LIST()
for i in range(N-1):
if a[i]+a[i+1] >= L:
idx = i
break
else:
print("Impossible")
exit()
print("Possible")
for i in range(1, i+1):
print(i)
for i in range(N-1, i, -1):
print(i)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
18,
13,
17,
0,
13,
17,
28,
13,
13,
4,
13,
18,
13,
39,
17,
14,
40,
2,
13,
13,
13,
0,
13,
17,
3,
0,
13,
13,
14,
40,
13,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
13,
4,
13,
2,
13,
17,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
13,
13
] | [
[
100,
2
],
[
100,
11
],
[
103,
13
],
[
109,
25
],
[
104,
27
],
[
106,
30
],
[
104,
38
],
[
110,
44
],
[
113,
44
],
[
95,
46
],
[
97,
48
],
[
112,
52
],
[
98,
56
],
[
107,
56
],
[
65,
64
],
[
64,
73
],
[
76,
75
],
[
101,
79
],
[
75,
87
],
[
100,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
]
] | [
"n, l = map(int, input().split())\nalist = list(map(int, input().split()))\n\npreva = alist[0]\nis_possible = False\nfor i, a in enumerate(alist[1:]):\n if preva + a >= l:\n is_possible = True\n break\n preva = a\n\nif not is_possible:\n print('Impossible')\nelse:\n print('Possible')\n for j in range(1, i+1):\n print(j)\n for j in range(n-1, i+1, -1):\n print(j)\n print(i + 1)",
"n, l = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"alist = list(map(int, input().split()))",
"alist",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"preva = alist[0]",
"preva",
"alist[0]",
"alist",
"0",
"is_possible = False",
"is_possible",
"False",
"for i, a in enumerate(alist[1:]):\n if preva + a >= l:\n is_possible = True\n break\n preva = a",
"i",
"a",
"enumerate(alist[1:])",
"enumerate",
"alist[1:]",
"alist",
"1:",
"1",
"if preva + a >= l:\n is_possible = True\n break\n ",
"preva + a >= l",
"preva + a",
"preva",
"a",
"l",
"is_possible = True",
"is_possible",
"True",
"break",
"preva = a",
"preva",
"a",
"if not is_possible:\n print('Impossible')\nelse:\n print('Possible')\n for j in range(1, i+1):\n print(j)\n for j in range(n-1, i+1, -1):\n print(j)\n print(i + 1)",
"not is_possible",
"is_possible",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"for j in range(1, i+1):\n print(j)\n ",
"j",
"range(1, i+1)",
"range",
"1",
"i+1",
"i",
"1",
"print(j)",
"print",
"j",
"for j in range(n-1, i+1, -1):\n print(j)\n ",
"j",
"range(n-1, i+1, -1)",
"range",
"n-1",
"n",
"1",
"i+1",
"i",
"1",
"-1",
"print(j)",
"print",
"j",
"print(i + 1)",
"print",
"i + 1",
"i",
"1",
"l = map(int, input().split())",
"map(int, input().split())",
"l",
"is_possible = True",
"True",
"is_possible",
"n, l = map(int, input().split())",
"map(int, input().split())",
"n",
"alist = list(map(int, input().split()))",
"list(map(int, input().split()))",
"alist",
"is_possible = False",
"False",
"is_possible",
"preva = alist[0]",
"alist[0]",
"preva",
"preva = a",
"a",
"preva"
] | n, l = map(int, input().split())
alist = list(map(int, input().split()))
preva = alist[0]
is_possible = False
for i, a in enumerate(alist[1:]):
if preva + a >= l:
is_possible = True
break
preva = a
if not is_possible:
print('Impossible')
else:
print('Possible')
for j in range(1, i+1):
print(j)
for j in range(n-1, i+1, -1):
print(j)
print(i + 1)
|
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13
] | [
[
114,
4
],
[
108,
11
],
[
115,
18
],
[
108,
20
],
[
105,
22
],
[
115,
31
],
[
111,
34
],
[
38,
37
],
[
100,
41
],
[
106,
47
],
[
37,
48
],
[
106,
50
],
[
37,
52
],
[
109,
54
],
[
102,
56
],
[
37,
57
],
[
103,
61
],
[
112,
61
],
[
71,
70
],
[
103,
73
],
[
112,
73
],
[
70,
77
],
[
81,
80
],
[
100,
84
],
[
103,
86
],
[
112,
86
],
[
80,
91
],
[
103,
96
],
[
112,
96
],
[
108,
100
],
[
37,
102
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
]
] | [
"import sys\ninput=sys.stdin.readline\n\nn,l=map(int,input().split())\na=list(map(int,input().split()))\n\nx=-1\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n x=i\n break\n\nif x==-1:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(x):\n print(i+1)\n for i in range(n-2,x,-1):\n print(i+1)\n print(x+1)",
"import sys",
"sys",
"input=sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"n,l=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x=-1",
"x",
"-1",
"for i in range(n-1):\n if a[i]+a[i+1]>=l:\n x=i\n break",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1]>=l:\n x=i\n break",
"a[i]+a[i+1]>=l",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"x=i",
"x",
"i",
"break",
"if x==-1:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(x):\n print(i+1)\n for i in range(n-2,x,-1):\n print(i+1)\n print(x+1)",
"x==-1",
"x",
"-1",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"for i in range(x):\n print(i+1)\n ",
"i",
"range(x)",
"range",
"x",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for i in range(n-2,x,-1):\n print(i+1)\n ",
"i",
"range(n-2,x,-1)",
"range",
"n-2",
"n",
"2",
"x",
"-1",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"print(x+1)",
"print",
"x+1",
"x",
"1",
"n,l=map(int,input().split())",
"map(int,input().split())",
"n",
"x=i",
"i",
"x",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"l=map(int,input().split())",
"map(int,input().split())",
"l",
"x=-1",
"-1",
"x",
"input=sys.stdin.readline",
"sys.stdin.readline",
"input"
] | import sys
input=sys.stdin.readline
n,l=map(int,input().split())
a=list(map(int,input().split()))
x=-1
for i in range(n-1):
if a[i]+a[i+1]>=l:
x=i
break
if x==-1:
print('Impossible')
else:
print('Possible')
for i in range(x):
print(i+1)
for i in range(n-2,x,-1):
print(i+1)
print(x+1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
13,
14,
40,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
4,
13,
17,
28,
13,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
28,
13,
4,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13
] | [
[
97,
2
],
[
97,
11
],
[
85,
13
],
[
94,
25
],
[
29,
28
],
[
89,
32
],
[
86,
37
],
[
28,
39
],
[
86,
42
],
[
28,
43
],
[
98,
44
],
[
91,
46
],
[
28,
47
],
[
92,
51
],
[
95,
51
],
[
63,
62
],
[
92,
66
],
[
95,
66
],
[
62,
71
],
[
75,
74
],
[
92,
79
],
[
95,
79
],
[
89,
80
],
[
74,
83
],
[
85,
86
],
[
97,
89
],
[
28,
91
],
[
91,
92
],
[
94,
95
],
[
97,
98
]
] | [
"N, L = map(int, input().split())\nAs = list(map(int, input().split()))\nn = -1\nfor i in range(1, N):\n if As[i-1]+As[i] >= L:\n n = i\n break\n#print(n)\nif n < 0:\n print(\"Impossible\")\n exit()\nprint(\"Possible\")\nfor i in range(n-1):\n print(i+1)\nfor i in reversed(range(n, N)):\n print(i)",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"As = list(map(int, input().split()))",
"As",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"n = -1",
"n",
"-1",
"for i in range(1, N):\n if As[i-1]+As[i] >= L:\n n = i\n break\n#print(n)",
"i",
"range(1, N)",
"range",
"1",
"N",
"if As[i-1]+As[i] >= L:\n n = i\n break\n#print(n)",
"As[i-1]+As[i] >= L",
"As[i-1]+As[i]",
"As[i-1]",
"As",
"i-1",
"i",
"1",
"As[i]",
"As",
"i",
"L",
"n = i",
"n",
"i",
"break",
"if n < 0:\n print(\"Impossible\")\n exit()",
"n < 0",
"n",
"0",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit()",
"exit",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(n-1):\n print(i+1)",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for i in reversed(range(n, N)):\n print(i)",
"i",
"reversed(range(n, N))",
"reversed",
"range(n, N)",
"range",
"n",
"N",
"print(i)",
"print",
"i",
"As = list(map(int, input().split()))",
"list(map(int, input().split()))",
"As",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"n = i",
"i",
"n",
"n = -1",
"-1",
"n",
"L = map(int, input().split())",
"map(int, input().split())",
"L"
] | N, L = map(int, input().split())
As = list(map(int, input().split()))
n = -1
for i in range(1, N):
if As[i-1]+As[i] >= L:
n = i
break
#print(n)
if n < 0:
print("Impossible")
exit()
print("Possible")
for i in range(n-1):
print(i+1)
for i in reversed(range(n, N)):
print(i)
|
[
7,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
0,
13,
13,
3,
4,
13,
17,
4,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
2,
13,
17,
28,
13,
4,
13,
13,
0,
18,
13,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
13,
17,
13,
0,
18,
13,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
28,
13,
4,
13,
2,
13,
17,
4,
13,
18,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13
] | [
[
131,
2
],
[
131,
13
],
[
122,
15
],
[
28,
27
],
[
132,
31
],
[
123,
37
],
[
27,
38
],
[
123,
40
],
[
27,
42
],
[
120,
44
],
[
128,
49
],
[
27,
50
],
[
125,
58
],
[
132,
63
],
[
69,
66
],
[
126,
67
],
[
129,
68
],
[
132,
70
],
[
74,
73
],
[
129,
76
],
[
81,
78
],
[
126,
79
],
[
73,
80
],
[
73,
82
],
[
86,
85
],
[
132,
90
],
[
129,
92
],
[
101,
94
],
[
126,
95
],
[
132,
98
],
[
85,
99
],
[
129,
103
],
[
85,
104
],
[
108,
107
],
[
132,
111
],
[
78,
115
],
[
126,
116
],
[
107,
117
],
[
131,
120
],
[
122,
123
],
[
125,
126
],
[
27,
128
],
[
128,
129
],
[
131,
132
]
] | [
"N,L=list(map(int, input().split()))\nA=list(map(int, input().split()))\nfor i in range(N-1):\n if A[i]+A[i+1]>=L:\n print('Possible')\n k=i\n break\nelse:\n print('Impossible')\n exit()\nans=[0]*(N-1)\nans[k]=N-1\nfor i in range(k):\n ans[i]=i+1\nfor i in range(N-2-k):\n ans[N-i-2]=k+i+1\nfor i in range(N-1):\n print(ans[i])",
"N,L=list(map(int, input().split()))",
"N",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A=list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(N-1):\n if A[i]+A[i+1]>=L:\n print('Possible')\n k=i\n break\nelse:\n print('Impossible')\n exit()",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i]+A[i+1]>=L:\n print('Possible')\n k=i\n break",
"A[i]+A[i+1]>=L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"print('Possible')",
"print",
"'Possible'",
"k=i",
"k",
"i",
"break",
"print('Impossible')",
"print",
"'Impossible'",
"exit()",
"exit",
"ans=[0]*(N-1)",
"ans",
"[0]*(N-1)",
"[0]",
"0",
"N-1",
"N",
"1",
"ans[k]=N-1",
"ans[k]",
"ans",
"k",
"N-1",
"N",
"1",
"for i in range(k):\n ans[i]=i+1",
"i",
"range(k)",
"range",
"k",
"ans[i]=i+1",
"ans[i]",
"ans",
"i",
"i+1",
"i",
"1",
"for i in range(N-2-k):\n ans[N-i-2]=k+i+1",
"i",
"range(N-2-k)",
"range",
"N-2-k",
"N-2",
"N",
"2",
"k",
"ans[N-i-2]=k+i+1",
"ans[N-i-2]",
"ans",
"N-i-2",
"N-i",
"N",
"i",
"2",
"k+i+1",
"k+i",
"k",
"i",
"1",
"for i in range(N-1):\n print(ans[i])",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"print(ans[i])",
"print",
"ans[i]",
"ans",
"i",
"L=list(map(int, input().split()))",
"list(map(int, input().split()))",
"L",
"A=list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"ans=[0]*(N-1)",
"[0]*(N-1)",
"ans",
"k=i",
"i",
"k",
"N,L=list(map(int, input().split()))",
"list(map(int, input().split()))",
"N"
] | N,L=list(map(int, input().split()))
A=list(map(int, input().split()))
for i in range(N-1):
if A[i]+A[i+1]>=L:
print('Possible')
k=i
break
else:
print('Impossible')
exit()
ans=[0]*(N-1)
ans[k]=N-1
for i in range(k):
ans[i]=i+1
for i in range(N-2-k):
ans[N-i-2]=k+i+1
for i in range(N-1):
print(ans[i]) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
13,
17,
28,
13,
4,
13,
13,
14,
40,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
0,
13,
13,
13,
2,
13,
17,
3,
0,
13,
2,
13,
17,
14,
2,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
13,
14,
2,
13,
13,
28,
13,
4,
13,
17,
13,
0,
13,
2,
13,
13,
14,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13
] | [
[
134,
2
],
[
134,
11
],
[
122,
13
],
[
131,
25
],
[
116,
28
],
[
113,
30
],
[
34,
33
],
[
108,
36
],
[
33,
39
],
[
108,
41
],
[
123,
47
],
[
33,
48
],
[
123,
50
],
[
33,
52
],
[
135,
54
],
[
110,
56
],
[
128,
59
],
[
33,
60
],
[
137,
61
],
[
33,
63
],
[
125,
67
],
[
129,
69
],
[
117,
69
],
[
111,
73
],
[
132,
73
],
[
80,
79
],
[
108,
83
],
[
79,
86
],
[
126,
87
],
[
90,
89
],
[
108,
93
],
[
119,
95
],
[
108,
97
],
[
89,
98
],
[
120,
101
],
[
126,
102
],
[
126,
105
],
[
134,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
33,
128
],
[
128,
129
],
[
131,
132
],
[
134,
135
],
[
137,
138
]
] | [
"N,L = map(int,input().split())\nA = list(map(int,input().split()))\n\n#(方針)ロープの和がある2か所でL以上ならPossible,それ以外ならImposible\n#→Possibleな理由はその2か所以外から1つずつほどいていけば必ずL以上の部分ができるから\n#→端からほどくとわかりやすい(?)\n#→両端から行かないとL以上の部分が存在しなくなることがある\n\njudge = 0\np1,p2 = -1,-1 #2か所で和がL以上になるところ\nfor i in range(N):\n if(i != N-1):\n if(A[i]+A[i+1] >= L):\n judge = 1\n p1,p2 = i,i+1\n break\npoint = p1+1 #p1とp2の結び目(index→問題文の数)\n\nif(judge == 0): print('Impossible')\nelse:\n print('Possible')\n for i in range(1,N):\n if(i == point): break\n else: print(i)\n for i in range(1,N):\n j = N-i\n if(j == point): break\n else: print(j) \n print(point) ",
"N,L = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"judge = 0",
"judge",
"0",
"p1,p2 = -1,-1",
"p1",
"-1",
"p2",
"-1",
"for i in range(N):\n if(i != N-1):\n if(A[i]+A[i+1] >= L):\n judge = 1\n p1,p2 = i,i+1\n break",
"i",
"range(N)",
"range",
"N",
"if(i != N-1):\n if(A[i]+A[i+1] >= L):\n judge = 1\n p1,p2 = i,i+1\n break",
"i != N-1",
"i",
"N-1",
"N",
"1",
"if(A[i]+A[i+1] >= L):\n judge = 1\n p1,p2 = i,i+1\n break",
"A[i]+A[i+1] >= L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"judge = 1",
"judge",
"1",
"p1,p2 = i,i+1",
"p1",
"i",
"p2",
"i+1",
"i",
"1",
"break",
"point = p1+1",
"point",
"p1+1",
"p1",
"1",
"if(judge == 0): print('Impossible')\nelse:\n print('Possible')\n for i in range(1,N):\n if(i == point): break\n else: print(i)\n for i in range(1,N):\n j = N-i\n if(j == point): break\n else: print(j) \n print(point) ",
"judge == 0",
"judge",
"0",
"print('Possible')",
"print",
"'Possible'",
"for i in range(1,N):\n if(i == point): break\n else: print(i)\n ",
"i",
"range(1,N)",
"range",
"1",
"N",
"if(i == point): break\n else: print(i)\n ",
"i == point",
"i",
"point",
"for i in range(1,N):\n j = N-i\n if(j == point): break\n else: print(j) \n ",
"i",
"range(1,N)",
"range",
"1",
"N",
"j = N-i",
"j",
"N-i",
"N",
"i",
"if(j == point): break\n else: print(j) \n ",
"j == point",
"j",
"point",
"print(point)",
"print",
"point",
"N,L = map(int,input().split())",
"map(int,input().split())",
"N",
"judge = 1",
"1",
"judge",
"p2 = -1,-1",
"-1",
"p2",
"p1,p2 = -1,-1",
"-1",
"p1",
"j = N-i",
"N-i",
"j",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"point = p1+1",
"p1+1",
"point",
"p1,p2 = i,i+1",
"i",
"p1",
"judge = 0",
"0",
"judge",
"L = map(int,input().split())",
"map(int,input().split())",
"L",
"p2 = i,i+1",
"i+1",
"p2"
] | N,L = map(int,input().split())
A = list(map(int,input().split()))
#(方針)ロープの和がある2か所でL以上ならPossible,それ以外ならImposible
#→Possibleな理由はその2か所以外から1つずつほどいていけば必ずL以上の部分ができるから
#→端からほどくとわかりやすい(?)
#→両端から行かないとL以上の部分が存在しなくなることがある
judge = 0
p1,p2 = -1,-1 #2か所で和がL以上になるところ
for i in range(N):
if(i != N-1):
if(A[i]+A[i+1] >= L):
judge = 1
p1,p2 = i,i+1
break
point = p1+1 #p1とp2の結び目(index→問題文の数)
if(judge == 0): print('Impossible')
else:
print('Possible')
for i in range(1,N):
if(i == point): break
else: print(i)
for i in range(1,N):
j = N-i
if(j == point): break
else: print(j)
print(point) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
40,
13,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
13,
17,
0,
13,
17,
14,
40,
13,
4,
13,
17,
4,
13,
0,
13,
39,
13,
28,
13,
4,
13,
2,
13,
17,
17,
17,
4,
18,
13,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
4,
18,
13,
13,
13,
0,
13,
18,
13,
39,
17,
4,
13,
17,
28,
13,
4,
13,
4,
13,
13,
4,
13,
18,
13,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13
] | [
[
143,
2
],
[
143,
11
],
[
134,
13
],
[
140,
25
],
[
146,
28
],
[
32,
31
],
[
129,
36
],
[
147,
40
],
[
126,
40
],
[
135,
45
],
[
31,
46
],
[
135,
48
],
[
31,
50
],
[
144,
52
],
[
137,
54
],
[
31,
56
],
[
125,
59
],
[
126,
63
],
[
147,
63
],
[
131,
70
],
[
75,
74
],
[
138,
78
],
[
141,
78
],
[
132,
84
],
[
74,
86
],
[
89,
88
],
[
138,
92
],
[
141,
92
],
[
129,
94
],
[
132,
97
],
[
88,
99
],
[
122,
101
],
[
132,
103
],
[
111,
110
],
[
123,
115
],
[
132,
115
],
[
123,
119
],
[
132,
119
],
[
110,
120
],
[
122,
123
],
[
125,
126
],
[
143,
129
],
[
131,
132
],
[
134,
135
],
[
137,
138
],
[
140,
141
],
[
143,
144
],
[
146,
147
]
] | [
"n,l=map(int,input().split())\na=list(map(int,input().split()))\ncnt=0\nflag=False\nfor i in range(0,n-1):\n if not flag:\n if a[i]+a[i+1]>=l:\n cnt=i+1\n flag=True\n\nif not flag:\n print(\"Impossible\")\n exit()\n\nans=[cnt]\n\nfor i in range(cnt-1,0,-1):\n ans.append(i)\nfor i in range(cnt+1,n):\n ans.append(i)\nans=ans[::-1]\nprint(\"Possible\")\nfor i in range(len(ans)):\n print(ans[i])",
"n,l=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"cnt=0",
"cnt",
"0",
"flag=False",
"flag",
"False",
"for i in range(0,n-1):\n if not flag:\n if a[i]+a[i+1]>=l:\n cnt=i+1\n flag=True",
"i",
"range(0,n-1)",
"range",
"0",
"n-1",
"n",
"1",
"if not flag:\n if a[i]+a[i+1]>=l:\n cnt=i+1\n flag=True",
"not flag",
"flag",
"if a[i]+a[i+1]>=l:\n cnt=i+1\n flag=True",
"a[i]+a[i+1]>=l",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"cnt=i+1",
"cnt",
"i+1",
"i",
"1",
"flag=True",
"flag",
"True",
"if not flag:\n print(\"Impossible\")\n exit()",
"not flag",
"flag",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit()",
"exit",
"ans=[cnt]",
"ans",
"[cnt]",
"cnt",
"for i in range(cnt-1,0,-1):\n ans.append(i)",
"i",
"range(cnt-1,0,-1)",
"range",
"cnt-1",
"cnt",
"1",
"0",
"-1",
"ans.append(i)",
"ans.append",
"ans",
"append",
"i",
"for i in range(cnt+1,n):\n ans.append(i)",
"i",
"range(cnt+1,n)",
"range",
"cnt+1",
"cnt",
"1",
"n",
"ans.append(i)",
"ans.append",
"ans",
"append",
"i",
"ans=ans[::-1]",
"ans",
"ans[::-1]",
"ans",
"::-1",
"-1",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(len(ans)):\n print(ans[i])",
"i",
"range(len(ans))",
"range",
"len(ans)",
"len",
"ans",
"print(ans[i])",
"print",
"ans[i]",
"ans",
"i",
"ans=ans[::-1]",
"ans[::-1]",
"ans",
"flag=True",
"True",
"flag",
"n,l=map(int,input().split())",
"map(int,input().split())",
"n",
"ans=[cnt]",
"[cnt]",
"ans",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"cnt=i+1",
"i+1",
"cnt",
"cnt=0",
"0",
"cnt",
"l=map(int,input().split())",
"map(int,input().split())",
"l",
"flag=False",
"False",
"flag"
] | n,l=map(int,input().split())
a=list(map(int,input().split()))
cnt=0
flag=False
for i in range(0,n-1):
if not flag:
if a[i]+a[i+1]>=l:
cnt=i+1
flag=True
if not flag:
print("Impossible")
exit()
ans=[cnt]
for i in range(cnt-1,0,-1):
ans.append(i)
for i in range(cnt+1,n):
ans.append(i)
ans=ans[::-1]
print("Possible")
for i in range(len(ans)):
print(ans[i])
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
0,
13,
2,
2,
4,
13,
4,
13,
17,
2,
13,
17,
4,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
39,
2,
13,
17,
4,
13,
31,
13,
0,
13,
17,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
107,
2
],
[
107,
11
],
[
101,
13
],
[
95,
25
],
[
29,
28
],
[
105,
32
],
[
102,
38
],
[
28,
39
],
[
102,
41
],
[
28,
43
],
[
108,
45
],
[
110,
47
],
[
28,
48
],
[
111,
52
],
[
96,
52
],
[
98,
61
],
[
111,
70
],
[
96,
70
],
[
105,
77
],
[
111,
80
],
[
96,
80
],
[
111,
85
],
[
96,
85
],
[
99,
90
],
[
93,
92
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
107,
105
],
[
107,
108
],
[
28,
110
],
[
110,
111
]
] | [
"N,L=map(int,input().split())\nA=list(map(int,input().split()))\nx=-1\nfor i in range(N-1):\n if A[i]+A[i+1]>=L:\n x=i\n break\nif x==-1:\n print('Impossible')\nelse:\n print('Possible')\n r=list(range(1,x+1))+list(range(N-1,x+1,-1))+[x+1,]\n print(*r,sep='\\n')",
"N,L=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x=-1",
"x",
"-1",
"for i in range(N-1):\n if A[i]+A[i+1]>=L:\n x=i\n break",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i]+A[i+1]>=L:\n x=i\n break",
"A[i]+A[i+1]>=L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"x=i",
"x",
"i",
"break",
"if x==-1:\n print('Impossible')\nelse:\n print('Possible')\n r=list(range(1,x+1))+list(range(N-1,x+1,-1))+[x+1,]\n print(*r,sep='\\n')",
"x==-1",
"x",
"-1",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"r=list(range(1,x+1))+list(range(N-1,x+1,-1))+[x+1,]",
"r",
"list(range(1,x+1))+list(range(N-1,x+1,-1))+[x+1,]",
"list(range(1,x+1))+list(range(N-1,x+1,-1))",
"list(range(1,x+1))",
"list",
"range(1,x+1)",
"range",
"1",
"x+1",
"x",
"1",
"list(range(N-1,x+1,-1))",
"list",
"range(N-1,x+1,-1)",
"range",
"N-1",
"N",
"1",
"x+1",
"x",
"1",
"-1",
"[x+1,]",
"x+1",
"x",
"1",
"print(*r,sep='\\n')",
"print",
"*r",
"r",
"sep='\\n'",
"sep",
"'\\n'",
"x=-1",
"-1",
"x",
"r=list(range(1,x+1))+list(range(N-1,x+1,-1))+[x+1,]",
"list(range(1,x+1))+list(range(N-1,x+1,-1))+[x+1,]",
"r",
"A=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"N,L=map(int,input().split())",
"map(int,input().split())",
"N",
"L=map(int,input().split())",
"map(int,input().split())",
"L",
"x=i",
"i",
"x"
] | N,L=map(int,input().split())
A=list(map(int,input().split()))
x=-1
for i in range(N-1):
if A[i]+A[i+1]>=L:
x=i
break
if x==-1:
print('Impossible')
else:
print('Possible')
r=list(range(1,x+1))+list(range(N-1,x+1,-1))+[x+1,]
print(*r,sep='\n') |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
39,
13,
13,
4,
13,
4,
13,
13,
18,
13,
39,
17,
14,
40,
2,
13,
13,
13,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
73,
2
],
[
73,
11
],
[
76,
13
],
[
77,
33
],
[
77,
35
],
[
74,
43
],
[
49,
48
],
[
57,
56
],
[
71,
60
],
[
73,
71
],
[
73,
74
],
[
76,
77
]
] | [
"N,L = map(int,input().split())\nsrc = list(map(int,input().split()))\n\nfor i,(a,b) in enumerate(zip(src, src[1:])):\n if a+b >= L:\n print('Possible')\n for j in range(1,i+1): print(j)\n for j in range(N-1,i,-1): print(j)\n exit()\nprint('Impossible')",
"N,L = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"src = list(map(int,input().split()))",
"src",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i,(a,b) in enumerate(zip(src, src[1:])):\n if a+b >= L:\n print('Possible')\n for j in range(1,i+1): print(j)\n for j in range(N-1,i,-1): print(j)\n exit()",
"i",
"(a,b)",
"a",
"b",
"enumerate(zip(src, src[1:]))",
"enumerate",
"zip(src, src[1:])",
"zip",
"src",
"src[1:]",
"src",
"1:",
"1",
"if a+b >= L:\n print('Possible')\n for j in range(1,i+1): print(j)\n for j in range(N-1,i,-1): print(j)\n exit()",
"a+b >= L",
"a+b",
"a",
"b",
"L",
"print('Possible')",
"print",
"'Possible'",
"for j in range(1,i+1): print(j)\n ",
"j",
"range(1,i+1)",
"range",
"1",
"i+1",
"i",
"1",
"for j in range(N-1,i,-1): print(j)\n ",
"j",
"range(N-1,i,-1)",
"range",
"N-1",
"N",
"1",
"i",
"-1",
"exit()",
"exit",
"print('Impossible')",
"print",
"'Impossible'",
"N,L = map(int,input().split())",
"map(int,input().split())",
"N",
"L = map(int,input().split())",
"map(int,input().split())",
"L",
"src = list(map(int,input().split()))",
"list(map(int,input().split()))",
"src"
] | N,L = map(int,input().split())
src = list(map(int,input().split()))
for i,(a,b) in enumerate(zip(src, src[1:])):
if a+b >= L:
print('Possible')
for j in range(1,i+1): print(j)
for j in range(N-1,i,-1): print(j)
exit()
print('Impossible')
|
[
7,
12,
13,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
13,
17,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
13,
17,
13,
28,
13,
4,
13,
17,
13,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
28,
13,
4,
13,
17,
13,
4,
13,
13,
4,
13,
13,
4,
13,
4,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
7,
6
],
[
14,
13
],
[
6,
24
],
[
14,
28
],
[
31,
30
],
[
6,
41
],
[
47,
46
],
[
13,
50
],
[
30,
55
],
[
46,
56
],
[
30,
58
],
[
46,
60
],
[
28,
62
],
[
68,
67
],
[
13,
71
],
[
46,
73
],
[
67,
77
],
[
80,
79
],
[
46,
83
],
[
79,
86
],
[
46,
89
],
[
103,
100
]
] | [
"def slove():\n import sys\n input = sys.stdin.readline\n n, l = list(map(int, input().rstrip('\\n').split()))\n a = list(map(int, input().rstrip('\\n').split()))\n for i in range(1, n):\n if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(n-1, i, -1):\n print(j)\n for j in range(1, i):\n print(j)\n print(i)\n exit()\n print(\"Impossible\")\n\n\nif __name__ == '__main__':\n slove()",
"def slove():\n import sys\n input = sys.stdin.readline\n n, l = list(map(int, input().rstrip('\\n').split()))\n a = list(map(int, input().rstrip('\\n').split()))\n for i in range(1, n):\n if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(n-1, i, -1):\n print(j)\n for j in range(1, i):\n print(j)\n print(i)\n exit()\n print(\"Impossible\")",
"slove",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"n, l = list(map(int, input().rstrip('\\n').split()))",
"n",
"list(map(int, input().rstrip('\\n').split()))",
"list",
"map(int, input().rstrip('\\n').split())",
"map",
"int",
"input().rstrip('\\n').split()",
"().rstrip('\\n').split",
"().rstrip('\\n')",
"().rstrip",
"()",
"input",
"rstrip",
"'\\n'",
"split",
"l",
"a = list(map(int, input().rstrip('\\n').split()))",
"a",
"list(map(int, input().rstrip('\\n').split()))",
"list",
"map(int, input().rstrip('\\n').split())",
"map",
"int",
"input().rstrip('\\n').split()",
"().rstrip('\\n').split",
"().rstrip('\\n')",
"().rstrip",
"()",
"input",
"rstrip",
"'\\n'",
"split",
"for i in range(1, n):\n if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(n-1, i, -1):\n print(j)\n for j in range(1, i):\n print(j)\n print(i)\n exit()\n ",
"i",
"range(1, n)",
"range",
"1",
"n",
"if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(n-1, i, -1):\n print(j)\n for j in range(1, i):\n print(j)\n print(i)\n exit()\n ",
"a[i] + a[i-1] >= l",
"a[i] + a[i-1]",
"a[i]",
"a",
"i",
"a[i-1]",
"a",
"i-1",
"i",
"1",
"l",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for j in range(n-1, i, -1):\n print(j)\n ",
"j",
"range(n-1, i, -1)",
"range",
"n-1",
"n",
"1",
"i",
"-1",
"print(j)",
"print",
"j",
"for j in range(1, i):\n print(j)\n ",
"j",
"range(1, i)",
"range",
"1",
"i",
"print(j)",
"print",
"j",
"print(i)",
"print",
"i",
"exit()",
"exit",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"if __name__ == '__main__':\n slove()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"slove()",
"slove",
"def slove():\n import sys\n input = sys.stdin.readline\n n, l = list(map(int, input().rstrip('\\n').split()))\n a = list(map(int, input().rstrip('\\n').split()))\n for i in range(1, n):\n if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(n-1, i, -1):\n print(j)\n for j in range(1, i):\n print(j)\n print(i)\n exit()\n print(\"Impossible\")",
"def slove():\n import sys\n input = sys.stdin.readline\n n, l = list(map(int, input().rstrip('\\n').split()))\n a = list(map(int, input().rstrip('\\n').split()))\n for i in range(1, n):\n if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(n-1, i, -1):\n print(j)\n for j in range(1, i):\n print(j)\n print(i)\n exit()\n print(\"Impossible\")",
"slove"
] | def slove():
import sys
input = sys.stdin.readline
n, l = list(map(int, input().rstrip('\n').split()))
a = list(map(int, input().rstrip('\n').split()))
for i in range(1, n):
if a[i] + a[i-1] >= l:
print("Possible")
for j in range(n-1, i, -1):
print(j)
for j in range(1, i):
print(j)
print(i)
exit()
print("Impossible")
if __name__ == '__main__':
slove()
|
[
7,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
13,
17,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
13,
10,
13,
13,
10,
13,
13,
10,
17,
13,
10,
13,
13,
10,
2,
13
] | [
[
4,
3
],
[
3,
12
],
[
103,
14
],
[
103,
16
],
[
20,
19
],
[
19,
28
],
[
94,
30
],
[
100,
33
],
[
37,
36
],
[
104,
40
],
[
95,
46
],
[
36,
47
],
[
95,
49
],
[
36,
51
],
[
98,
53
],
[
106,
55
],
[
36,
57
],
[
107,
61
],
[
101,
61
],
[
71,
70
],
[
107,
74
],
[
101,
74
],
[
70,
77
],
[
80,
79
],
[
104,
83
],
[
107,
85
],
[
101,
85
],
[
79,
89
],
[
107,
92
],
[
101,
92
],
[
94,
95
],
[
103,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
]
] | [
"n,l = [int(i) for i in input().split()]\na = [int(i) for i in input().split()]\n\nindex = 0\nfor i in range(n-1):\n if a[i]+a[i+1] >= l:\n index = i+1\n\nif index==0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,index):\n print(i)\n for i in range(n-1,index,-1):\n print(i)\n print(index)",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"n,l = [int(i) for i in input().split()]",
"n",
"[int(i) for i in input().split()]",
"l",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"a = [int(i) for i in input().split()]",
"a",
"[int(i) for i in input().split()]",
"index = 0",
"index",
"0",
"for i in range(n-1):\n if a[i]+a[i+1] >= l:\n index = i+1",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1] >= l:\n index = i+1",
"a[i]+a[i+1] >= l",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"index = i+1",
"index",
"i+1",
"i",
"1",
"if index==0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,index):\n print(i)\n for i in range(n-1,index,-1):\n print(i)\n print(index)",
"index==0",
"index",
"0",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(1,index):\n print(i)\n ",
"i",
"range(1,index)",
"range",
"1",
"index",
"print(i)",
"print",
"i",
"for i in range(n-1,index,-1):\n print(i)\n ",
"i",
"range(n-1,index,-1)",
"range",
"n-1",
"n",
"1",
"index",
"-1",
"print(i)",
"print",
"i",
"print(index)",
"print",
"index",
"a = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"a",
"l = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"l",
"index = 0",
"0",
"index",
"n,l = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"n",
"index = i+1",
"i+1",
"index"
] | n,l = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
index = 0
for i in range(n-1):
if a[i]+a[i+1] >= l:
index = i+1
if index==0:
print("Impossible")
else:
print("Possible")
for i in range(1,index):
print(i)
for i in range(n-1,index,-1):
print(i)
print(index) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
4,
13,
31,
2,
4,
13,
4,
13,
17,
2,
13,
17,
4,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
0,
13,
17,
4,
13,
2,
13,
17,
4,
13,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
89,
2
],
[
89,
11
],
[
86,
13
],
[
26,
25
],
[
84,
29
],
[
87,
35
],
[
25,
36
],
[
87,
38
],
[
25,
40
],
[
90,
42
],
[
25,
56
],
[
84,
63
],
[
25,
66
],
[
71,
70
],
[
25,
75
],
[
89,
84
],
[
86,
87
],
[
89,
90
]
] | [
"n,l=map(int,input().split())\nt=list(map(int,input().split()))\nfor i in range(n-1):\n if t[i]+t[i+1]>=l:\n print('Possible')\n print(*(list(range(1,i+1))+list(range(n-1,i+1,-1))),sep='\\n')\n print(i+1)\n exit()\nprint('Impossible')",
"n,l=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"t=list(map(int,input().split()))",
"t",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(n-1):\n if t[i]+t[i+1]>=l:\n print('Possible')\n print(*(list(range(1,i+1))+list(range(n-1,i+1,-1))),sep='\\n')\n print(i+1)\n exit()",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if t[i]+t[i+1]>=l:\n print('Possible')\n print(*(list(range(1,i+1))+list(range(n-1,i+1,-1))),sep='\\n')\n print(i+1)\n exit()",
"t[i]+t[i+1]>=l",
"t[i]+t[i+1]",
"t[i]",
"t",
"i",
"t[i+1]",
"t",
"i+1",
"i",
"1",
"l",
"print('Possible')",
"print",
"'Possible'",
"print(*(list(range(1,i+1))+list(range(n-1,i+1,-1))),sep='\\n')",
"print",
"*(list(range(1,i+1))+list(range(n-1,i+1,-1)))",
"list(range(1,i+1))+list(range(n-1,i+1,-1))",
"list(range(1,i+1))",
"list",
"range(1,i+1)",
"range",
"1",
"i+1",
"i",
"1",
"list(range(n-1,i+1,-1))",
"list",
"range(n-1,i+1,-1)",
"range",
"n-1",
"n",
"1",
"i+1",
"i",
"1",
"-1",
"sep='\\n'",
"sep",
"'\\n'",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"exit()",
"exit",
"print('Impossible')",
"print",
"'Impossible'",
"n,l=map(int,input().split())",
"map(int,input().split())",
"n",
"t=list(map(int,input().split()))",
"list(map(int,input().split()))",
"t",
"l=map(int,input().split())",
"map(int,input().split())",
"l"
] | n,l=map(int,input().split())
t=list(map(int,input().split()))
for i in range(n-1):
if t[i]+t[i+1]>=l:
print('Possible')
print(*(list(range(1,i+1))+list(range(n-1,i+1,-1))),sep='\n')
print(i+1)
exit()
print('Impossible') |
[
7,
0,
13,
4,
13,
0,
13,
4,
18,
4,
18,
4,
18,
17,
13,
13,
13,
17,
13,
17,
0,
13,
4,
13,
18,
13,
17,
0,
13,
4,
13,
18,
13,
17,
0,
13,
4,
13,
0,
13,
4,
18,
4,
18,
17,
13,
13,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
4,
13,
18,
13,
13,
4,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
13,
17,
4,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
17,
13,
28,
13,
4,
13,
13,
14,
2,
2,
2,
13,
17,
13,
13,
3,
4,
13,
2,
2,
13,
17,
13,
3,
14,
2,
2,
13,
17,
13,
9,
4,
13,
2,
13,
17,
4,
13,
13,
3,
14,
2,
13,
2,
13,
17,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] | [
[
147,
2
],
[
150,
6
],
[
148,
15
],
[
141,
21
],
[
151,
25
],
[
148,
25
],
[
144,
28
],
[
151,
32
],
[
148,
32
],
[
159,
35
],
[
153,
39
],
[
160,
46
],
[
51,
50
],
[
142,
54
],
[
154,
62
],
[
160,
62
],
[
50,
63
],
[
154,
67
],
[
160,
67
],
[
50,
69
],
[
145,
71
],
[
156,
73
],
[
50,
75
],
[
82,
81
],
[
142,
85
],
[
81,
90
],
[
157,
92
],
[
95,
94
],
[
142,
97
],
[
142,
102
],
[
94,
104
],
[
81,
105
],
[
142,
111
],
[
94,
113
],
[
81,
118
],
[
157,
120
],
[
81,
125
],
[
157,
129
],
[
50,
133
],
[
142,
135
],
[
141,
142
],
[
144,
145
],
[
147,
148
],
[
150,
151
],
[
153,
154
],
[
156,
157
],
[
159,
160
]
] | [
"NL = input()\nNL = \"\".join(NL).rstrip(\"\\n\").split(\" \")\nN = int(NL[0])\nL = int(NL[1])\na = input()\na = \"\".join(a).split(\" \")\n\nfor s in range(N-1):\n\tif int(a[s])+int(a[s+1])>=L:\n\t\tLast = s+1\n\t\tprint(\"Possible\")\n\t\tfor s in range(N-1):\n\t\t\tif s+1>Last:\n\t\t\t\tfor j in range(N):\n\t\t\t\t\tif (N-1-j) ==s:\n\t\t\t\t\t\t#print(Last)\n\t\t\t\t\t\tbreak\n\t\t\t\t\tprint(N-1-j)\n\t\t\t\tbreak\n\t\t\tif s+1==Last:\n\t\t\t\tcontinue\n\t\t\tprint(s+1)\n\t\tprint(Last)\n\t\tbreak\n\tif s==N-2:\n\t\tprint(\"Impossible\")",
"NL = input()",
"NL",
"input()",
"input",
"NL = \"\".join(NL).rstrip(\"\\n\").split(\" \")",
"NL",
"\"\".join(NL).rstrip(\"\\n\").split(\" \")",
"\"\".join(NL).rstrip(\"\\n\").split",
"\"\".join(NL).rstrip(\"\\n\")",
"\"\".join(NL).rstrip",
"\"\".join(NL)",
"\"\".join",
"\"\"",
"join",
"NL",
"rstrip",
"\"\\n\"",
"split",
"\" \"",
"N = int(NL[0])",
"N",
"int(NL[0])",
"int",
"NL[0]",
"NL",
"0",
"L = int(NL[1])",
"L",
"int(NL[1])",
"int",
"NL[1]",
"NL",
"1",
"a = input()",
"a",
"input()",
"input",
"a = \"\".join(a).split(\" \")",
"a",
"\"\".join(a).split(\" \")",
"\"\".join(a).split",
"\"\".join(a)",
"\"\".join",
"\"\"",
"join",
"a",
"split",
"\" \"",
"for s in range(N-1):\n\tif int(a[s])+int(a[s+1])>=L:\n\t\tLast = s+1\n\t\tprint(\"Possible\")\n\t\tfor s in range(N-1):\n\t\t\tif s+1>Last:\n\t\t\t\tfor j in range(N):\n\t\t\t\t\tif (N-1-j) ==s:\n\t\t\t\t\t\t#print(Last)\n\t\t\t\t\t\tbreak\n\t\t\t\t\tprint(N-1-j)\n\t\t\t\tbreak\n\t\t\tif s+1==Last:\n\t\t\t\tcontinue\n\t\t\tprint(s+1)\n\t\tprint(Last)\n\t\tbreak\n\tif s==N-2:\n\t\tprint(\"Impossible\")",
"s",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if int(a[s])+int(a[s+1])>=L:\n\t\tLast = s+1\n\t\tprint(\"Possible\")\n\t\tfor s in range(N-1):\n\t\t\tif s+1>Last:\n\t\t\t\tfor j in range(N):\n\t\t\t\t\tif (N-1-j) ==s:\n\t\t\t\t\t\t#print(Last)\n\t\t\t\t\t\tbreak\n\t\t\t\t\tprint(N-1-j)\n\t\t\t\tbreak\n\t\t\tif s+1==Last:\n\t\t\t\tcontinue\n\t\t\tprint(s+1)\n\t\tprint(Last)\n\t\tbreak\n\t",
"int(a[s])+int(a[s+1])>=L",
"int(a[s])+int(a[s+1])",
"int(a[s])",
"int",
"a[s]",
"a",
"s",
"int(a[s+1])",
"int",
"a[s+1]",
"a",
"s+1",
"s",
"1",
"L",
"Last = s+1",
"Last",
"s+1",
"s",
"1",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for s in range(N-1):\n\t\t\tif s+1>Last:\n\t\t\t\tfor j in range(N):\n\t\t\t\t\tif (N-1-j) ==s:\n\t\t\t\t\t\t#print(Last)\n\t\t\t\t\t\tbreak\n\t\t\t\t\tprint(N-1-j)\n\t\t\t\tbreak\n\t\t\tif s+1==Last:\n\t\t\t\tcontinue\n\t\t\tprint(s+1)\n\t\t",
"s",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if s+1>Last:\n\t\t\t\tfor j in range(N):\n\t\t\t\t\tif (N-1-j) ==s:\n\t\t\t\t\t\t#print(Last)\n\t\t\t\t\t\tbreak\n\t\t\t\t\tprint(N-1-j)\n\t\t\t\tbreak\n\t\t\t",
"s+1>Last",
"s+1",
"s",
"1",
"Last",
"for j in range(N):\n\t\t\t\t\tif (N-1-j) ==s:\n\t\t\t\t\t\t#print(Last)\n\t\t\t\t\t\tbreak\n\t\t\t\t\tprint(N-1-j)\n\t\t\t\t",
"j",
"range(N)",
"range",
"N",
"if (N-1-j) ==s:\n\t\t\t\t\t\t#print(Last)\n\t\t\t\t\t\tbreak\n\t\t\t\t\t",
"(N-1-j) ==s",
"N-1-j",
"N-1",
"N",
"1",
"j",
"s",
"break",
"print(N-1-j)",
"print",
"N-1-j",
"N-1",
"N",
"1",
"j",
"break",
"if s+1==Last:\n\t\t\t\tcontinue\n\t\t\t",
"s+1==Last",
"s+1",
"s",
"1",
"Last",
"continue",
"print(s+1)",
"print",
"s+1",
"s",
"1",
"print(Last)",
"print",
"Last",
"break",
"if s==N-2:\n\t\tprint(\"Impossible\")",
"s==N-2",
"s",
"N-2",
"N",
"2",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"N = int(NL[0])",
"int(NL[0])",
"N",
"L = int(NL[1])",
"int(NL[1])",
"L",
"NL = input()",
"input()",
"NL",
"NL = \"\".join(NL).rstrip(\"\\n\").split(\" \")",
"\"\".join(NL).rstrip(\"\\n\").split(\" \")",
"NL",
"a = \"\".join(a).split(\" \")",
"\"\".join(a).split(\" \")",
"a",
"Last = s+1",
"s+1",
"Last",
"a = input()",
"input()",
"a"
] | NL = input()
NL = "".join(NL).rstrip("\n").split(" ")
N = int(NL[0])
L = int(NL[1])
a = input()
a = "".join(a).split(" ")
for s in range(N-1):
if int(a[s])+int(a[s+1])>=L:
Last = s+1
print("Possible")
for s in range(N-1):
if s+1>Last:
for j in range(N):
if (N-1-j) ==s:
#print(Last)
break
print(N-1-j)
break
if s+1==Last:
continue
print(s+1)
print(Last)
break
if s==N-2:
print("Impossible") |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
0,
13,
17,
14,
13,
4,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
13,
13,
4,
13,
2,
13,
17,
4,
13,
2,
2,
2,
13,
13,
13,
17,
4,
13,
17,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13
] | [
[
112,
2
],
[
112,
11
],
[
100,
13
],
[
94,
25
],
[
101,
28
],
[
106,
30
],
[
97,
33
],
[
37,
36
],
[
104,
40
],
[
101,
46
],
[
36,
47
],
[
101,
49
],
[
36,
51
],
[
113,
53
],
[
115,
55
],
[
36,
56
],
[
109,
58
],
[
67,
66
],
[
104,
70
],
[
116,
74
],
[
66,
75
],
[
66,
79
],
[
104,
86
],
[
116,
87
],
[
66,
88
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
112,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
36,
115
],
[
115,
116
]
] | [
"N,L=map(int,input().split())\nA=list(map(int,input().split()))\nsum_A=sum(A)\n\njunban=[]\nflg=False\n\nfor i in range(N-1):\n if A[i]+A[i+1]>=L:\n tmp=i\n flg=True\n\n\nif flg:\n print(\"Possible\")\n for i in range(N-1):\n if tmp>i:\n print(i+1)\n else:\n print(N+tmp-i-1)\nelse:\n print(\"Impossible\")",
"N,L=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"sum_A=sum(A)",
"sum_A",
"sum(A)",
"sum",
"A",
"junban=[]",
"junban",
"[]",
"flg=False",
"flg",
"False",
"for i in range(N-1):\n if A[i]+A[i+1]>=L:\n tmp=i\n flg=True",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i]+A[i+1]>=L:\n tmp=i\n flg=True",
"A[i]+A[i+1]>=L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"tmp=i",
"tmp",
"i",
"flg=True",
"flg",
"True",
"if flg:\n print(\"Possible\")\n for i in range(N-1):\n if tmp>i:\n print(i+1)\n else:\n print(N+tmp-i-1)\nelse:\n print(\"Impossible\")",
"flg",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(N-1):\n if tmp>i:\n print(i+1)\n else:\n print(N+tmp-i-1)",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if tmp>i:\n print(i+1)\n else:\n print(N+tmp-i-1)",
"tmp>i",
"tmp",
"i",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"print(N+tmp-i-1)",
"print",
"N+tmp-i-1",
"N+tmp-i",
"N+tmp",
"N",
"tmp",
"i",
"1",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"sum_A=sum(A)",
"sum(A)",
"sum_A",
"flg=False",
"False",
"flg",
"A=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"N,L=map(int,input().split())",
"map(int,input().split())",
"N",
"junban=[]",
"[]",
"junban",
"flg=True",
"True",
"flg",
"L=map(int,input().split())",
"map(int,input().split())",
"L",
"tmp=i",
"i",
"tmp"
] | N,L=map(int,input().split())
A=list(map(int,input().split()))
sum_A=sum(A)
junban=[]
flg=False
for i in range(N-1):
if A[i]+A[i+1]>=L:
tmp=i
flg=True
if flg:
print("Possible")
for i in range(N-1):
if tmp>i:
print(i+1)
else:
print(N+tmp-i-1)
else:
print("Impossible") |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
0,
13,
2,
13,
17,
3,
14,
13,
41,
28,
13,
4,
13,
17,
13,
4,
13,
0,
13,
2,
2,
13,
13,
39,
13,
4,
13,
17,
4,
13,
4,
18,
17,
13,
4,
13,
13,
13,
4,
13,
17,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] | [
[
109,
2
],
[
109,
11
],
[
106,
13
],
[
94,
25
],
[
97,
28
],
[
32,
31
],
[
104,
35
],
[
107,
41
],
[
31,
42
],
[
107,
44
],
[
31,
46
],
[
110,
48
],
[
115,
50
],
[
112,
53
],
[
31,
55
],
[
63,
62
],
[
113,
66
],
[
98,
66
],
[
62,
68
],
[
100,
70
],
[
101,
89
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
109,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
]
] | [
"N,L = map(int,input().split())\nA = list(map(int,input().split()))\n\nuntiable = False\nlastknot = None\n\nfor i in range(N-1):\n if A[i]+A[i+1] >= L:\n untiable = True\n lastknot = i+1\n break\n\nif untiable:\n ans = [i for i in range(1,lastknot)] + [i for i in range(lastknot+1,N)[::-1]] + [lastknot]\n print('Possible')\n print('\\n'.join(map(str,ans)))\n \nelse:\n print('Impossible')",
"N,L = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"untiable = False",
"untiable",
"False",
"lastknot = None",
"lastknot",
"None",
"for i in range(N-1):\n if A[i]+A[i+1] >= L:\n untiable = True\n lastknot = i+1\n break",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i]+A[i+1] >= L:\n untiable = True\n lastknot = i+1\n break",
"A[i]+A[i+1] >= L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"untiable = True",
"untiable",
"True",
"lastknot = i+1",
"lastknot",
"i+1",
"i",
"1",
"break",
"if untiable:\n ans = [i for i in range(1,lastknot)] + [i for i in range(lastknot+1,N)[::-1]] + [lastknot]\n print('Possible')\n print('\\n'.join(map(str,ans)))\n \nelse:\n print('Impossible')",
"untiable",
"i for i in range(1,lastknot)",
"for i in range(1,lastknot)",
"i",
"range(1,lastknot)",
"range",
"1",
"lastknot",
"for i in range(1,lastknot)",
"i",
"ans = [i for i in range(1,lastknot)] + [i for i in range(lastknot+1,N)[::-1]] + [lastknot]",
"ans",
"[i for i in range(1,lastknot)] + [i for i in range(lastknot+1,N)[::-1]] + [lastknot]",
"[i for i in range(1,lastknot)] + [i for i in range(lastknot+1,N)[::-1]]",
"[i for i in range(1,lastknot)]",
"[i for i in range(lastknot+1,N)[::-1]]",
"[lastknot]",
"lastknot",
"print('Possible')",
"print",
"'Possible'",
"print('\\n'.join(map(str,ans)))",
"print",
"'\\n'.join(map(str,ans))",
"'\\n'.join",
"'\\n'",
"join",
"map(str,ans)",
"map",
"str",
"ans",
"print('Impossible')",
"print",
"'Impossible'",
"untiable = False",
"False",
"untiable",
"lastknot = None",
"None",
"lastknot",
"ans = [i for i in range(1,lastknot)] + [i for i in range(lastknot+1,N)[::-1]] + [lastknot]",
"[i for i in range(1,lastknot)] + [i for i in range(lastknot+1,N)[::-1]] + [lastknot]",
"ans",
"N,L = map(int,input().split())",
"map(int,input().split())",
"N",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"L = map(int,input().split())",
"map(int,input().split())",
"L",
"lastknot = i+1",
"i+1",
"lastknot",
"untiable = True",
"True",
"untiable"
] | N,L = map(int,input().split())
A = list(map(int,input().split()))
untiable = False
lastknot = None
for i in range(N-1):
if A[i]+A[i+1] >= L:
untiable = True
lastknot = i+1
break
if untiable:
ans = [i for i in range(1,lastknot)] + [i for i in range(lastknot+1,N)[::-1]] + [lastknot]
print('Possible')
print('\n'.join(map(str,ans)))
else:
print('Impossible') |
[
7,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
0,
13,
4,
13,
13,
0,
13,
39,
0,
13,
17,
0,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
13,
13,
13,
4,
18,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
14,
2,
13,
13,
0,
13,
18,
13,
13,
4,
18,
13,
13,
13,
0,
13,
17,
0,
13,
18,
13,
13,
4,
18,
13,
13,
2,
13,
17,
0,
13,
17,
13,
28,
13,
13,
13,
2,
13,
17,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13
] | [
[
139,
4
],
[
139,
17
],
[
157,
19
],
[
133,
33
],
[
158,
36
],
[
127,
38
],
[
148,
41
],
[
151,
44
],
[
140,
46
],
[
50,
49
],
[
140,
53
],
[
134,
57
],
[
137,
57
],
[
155,
57
],
[
131,
58
],
[
163,
65
],
[
158,
68
],
[
149,
69
],
[
143,
69
],
[
158,
71
],
[
149,
73
],
[
143,
73
],
[
160,
76
],
[
158,
79
],
[
152,
80
],
[
146,
80
],
[
158,
82
],
[
152,
84
],
[
146,
84
],
[
164,
88
],
[
161,
89
],
[
154,
91
],
[
158,
93
],
[
149,
94
],
[
143,
94
],
[
128,
97
],
[
149,
99
],
[
143,
99
],
[
142,
101
],
[
136,
104
],
[
158,
106
],
[
152,
107
],
[
146,
107
],
[
128,
110
],
[
152,
113
],
[
146,
113
],
[
145,
116
],
[
121,
120
],
[
128,
120
],
[
120,
124
],
[
127,
128
],
[
139,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
]
] | [
"import sys\n\nN, L = map(int, sys.stdin.readline().split())\nAs = map(int, sys.stdin.readline().split())\n\ntot = sum(As)\n\nres = []\n\na = 0\nb = N-1\nfor _ in range(N-1):\n if tot < L:\n print \"Impossible\"\n sys.exit()\n\n na = As[a] + As[a+1]\n nb = As[b] + As[b-1]\n\n if na < nb:\n #tot -= na\n tot -= As[a]\n res.append(a)\n a += 1\n else:\n #tot -= nb\n tot -= As[b]\n res.append(b-1)\n b -= 1\n\nprint \"Possible\"\nfor a in res:\n print a+1\n",
"import sys",
"sys",
"N, L = map(int, sys.stdin.readline().split())",
"N",
"map(int, sys.stdin.readline().split())",
"map",
"int",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"L",
"As = map(int, sys.stdin.readline().split())",
"As",
"map(int, sys.stdin.readline().split())",
"map",
"int",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"tot = sum(As)",
"tot",
"sum(As)",
"sum",
"As",
"res = []",
"res",
"[]",
"a = 0",
"a",
"0",
"b = N-1",
"b",
"N-1",
"N",
"1",
"for _ in range(N-1):\n if tot < L:\n print \"Impossible\"\n sys.exit()\n\n na = As[a] + As[a+1]\n nb = As[b] + As[b-1]\n\n if na < nb:\n #tot -= na\n tot -= As[a]\n res.append(a)\n a += 1\n else:\n #tot -= nb\n tot -= As[b]\n res.append(b-1)\n b -= 1",
"_",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if tot < L:\n print \"Impossible\"\n sys.exit()\n\n ",
"tot < L",
"tot",
"L",
"print",
"sys.exit()",
"sys.exit",
"sys",
"exit",
"na = As[a] + As[a+1]",
"na",
"As[a] + As[a+1]",
"As[a]",
"As",
"a",
"As[a+1]",
"As",
"a+1",
"a",
"1",
"nb = As[b] + As[b-1]",
"nb",
"As[b] + As[b-1]",
"As[b]",
"As",
"b",
"As[b-1]",
"As",
"b-1",
"b",
"1",
"if na < nb:\n #tot -= na\n tot -= As[a]\n res.append(a)\n a += 1\n else:\n #tot -= nb\n tot -= As[b]\n res.append(b-1)\n b -= 1",
"na < nb",
"na",
"nb",
"tot -= As[a]",
"tot",
"As[a]",
"As",
"a",
"res.append(a)",
"res.append",
"res",
"append",
"a",
"a += 1",
"a",
"1",
"tot -= As[b]",
"tot",
"As[b]",
"As",
"b",
"res.append(b-1)",
"res.append",
"res",
"append",
"b-1",
"b",
"1",
"b -= 1",
"b",
"1",
"print",
"for a in res:\n print a+1",
"a",
"res",
"print",
"a+1",
"a",
"1",
"res = []",
"[]",
"res",
"L = map(int, sys.stdin.readline().split())",
"map(int, sys.stdin.readline().split())",
"L",
"tot = sum(As)",
"sum(As)",
"tot",
"tot -= As[b]",
"As[b]",
"tot",
"N, L = map(int, sys.stdin.readline().split())",
"map(int, sys.stdin.readline().split())",
"N",
"a += 1",
"1",
"a",
"b -= 1",
"1",
"b",
"a = 0",
"0",
"a",
"b = N-1",
"N-1",
"b",
"tot -= As[a]",
"As[a]",
"tot",
"As = map(int, sys.stdin.readline().split())",
"map(int, sys.stdin.readline().split())",
"As",
"nb = As[b] + As[b-1]",
"As[b] + As[b-1]",
"nb",
"na = As[a] + As[a+1]",
"As[a] + As[a+1]",
"na"
] | import sys
N, L = map(int, sys.stdin.readline().split())
As = map(int, sys.stdin.readline().split())
tot = sum(As)
res = []
a = 0
b = N-1
for _ in range(N-1):
if tot < L:
print "Impossible"
sys.exit()
na = As[a] + As[a+1]
nb = As[b] + As[b-1]
if na < nb:
#tot -= na
tot -= As[a]
res.append(a)
a += 1
else:
#tot -= nb
tot -= As[b]
res.append(b-1)
b -= 1
print "Possible"
for a in res:
print a+1
|
[
7,
15,
13,
6,
13,
12,
13,
29,
4,
13,
0,
13,
13,
13,
12,
13,
0,
13,
4,
18,
13,
13,
17,
13,
0,
13,
4,
18,
13,
13,
13,
29,
39,
13,
13,
0,
13,
13,
13,
12,
13,
29,
4,
18,
4,
18,
13,
13,
13,
0,
13,
13,
13,
12,
13,
29,
4,
13,
4,
18,
4,
18,
13,
13,
13,
0,
13,
13,
13,
12,
13,
29,
18,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
4,
18,
4,
18,
13,
13,
13,
39,
13,
23,
13,
0,
13,
13,
13,
13,
12,
13,
0,
13,
4,
18,
13,
13,
13,
0,
13,
4,
13,
13,
13,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
13,
4,
13,
13,
12,
13,
0,
13,
39,
28,
13,
4,
13,
2,
4,
13,
13,
17,
4,
18,
13,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
14,
2,
4,
13,
13,
13,
29,
17,
0,
13,
17,
0,
13,
39,
28,
13,
4,
13,
4,
13,
13,
14,
40,
18,
13,
13,
13,
0,
13,
2,
13,
17,
3,
0,
13,
39,
2,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
2,
13,
17,
17,
0,
13,
39,
2,
13,
17,
0,
13,
39,
13,
29,
13,
23,
13,
23,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
6,
13,
10,
12,
13
] | [
[
13,
6
],
[
13,
11
],
[
13,
13
],
[
38,
15
],
[
18,
17
],
[
18,
23
],
[
26,
25
],
[
17,
30
],
[
38,
36
],
[
38,
38
],
[
52,
40
],
[
13,
47
],
[
52,
50
],
[
52,
52
],
[
68,
54
],
[
13,
63
],
[
68,
66
],
[
68,
68
],
[
97,
70
],
[
13,
88
],
[
93,
93
],
[
97,
95
],
[
97,
97
],
[
103,
102
],
[
38,
106
],
[
103,
107
],
[
110,
109
],
[
102,
112
],
[
107,
113
],
[
109,
116
],
[
126,
125
],
[
109,
125
],
[
125,
129
],
[
134,
133
],
[
137,
136
],
[
224,
142
],
[
133,
146
],
[
224,
150
],
[
136,
151
],
[
224,
153
],
[
136,
155
],
[
133,
161
],
[
222,
162
],
[
167,
166
],
[
170,
169
],
[
173,
172
],
[
133,
177
],
[
133,
181
],
[
172,
182
],
[
222,
183
],
[
186,
185
],
[
172,
187
],
[
192,
191
],
[
172,
194
],
[
198,
197
],
[
133,
203
],
[
185,
206
],
[
166,
206
],
[
211,
210
],
[
197,
213
],
[
217,
216
],
[
216,
220
],
[
210,
220
],
[
191,
220
],
[
169,
220
],
[
222,
222
],
[
224,
224
],
[
233,
230
]
] | [
"import re\n\nclass IO_for_Contest(object):\n @staticmethod\n def my_input():\n #return raw_input()\n return input()\n\n @staticmethod\n def read_from_input():\n n, l = IO_for_Contest.read_n_int(2)\n a = IO_for_Contest.read_n_int(n)\n return l, a\n\n @staticmethod\n def read_line():\n return IO_for_Contest.my_input().strip()\n\n @staticmethod\n def read_int():\n return int(IO_for_Contest.my_input().strip())\n\n @staticmethod\n def read_n_int(n):\n return list(map(int, re.split('\\W+', IO_for_Contest.my_input().strip())))[ : n]\n\n\ndef solve():\n l, a = IO_for_Contest.read_from_input()\n result = find_way_how_to_split_ropes(l, a)\n if result is None:\n print('Impossible')\n else:\n print('Possible')\n for x in result:\n print(x)\n\ndef find_way_how_to_split_ropes(l, a):\n adjencent_sum = []\n for i in range(len(a) - 1):\n adjencent_sum.append(a[i] + a[i + 1])\n if max(adjencent_sum) < l:\n return None\n x = 0\n result = []\n for y in range(len(adjencent_sum)):\n if adjencent_sum[y] >= l:\n x = y + 1\n break\n result += [y + 1]\n for y in range(len(adjencent_sum) - 1, x - 1, -1):\n result += [y + 1]\n result += [x]\n return result\n\nif __name__ == '__main__':\n solve()",
"import re",
"re",
"class IO_for_Contest(object):\n @staticmethod\n def my_input():\n #return raw_input()\n return input()\n\n @staticmethod\n def read_from_input():\n n, l = IO_for_Contest.read_n_int(2)\n a = IO_for_Contest.read_n_int(n)\n return l, a\n\n @staticmethod\n def read_line():\n return IO_for_Contest.my_input().strip()\n\n @staticmethod\n def read_int():\n return int(IO_for_Contest.my_input().strip())\n\n @staticmethod\n def read_n_int(n):\n return list(map(int, re.split('\\W+', IO_for_Contest.my_input().strip())))[ : n]",
"IO_for_Contest",
"def my_input():\n #return raw_input()\n return input()\n\n ",
"my_input",
"return input()",
"input()",
"input",
"@staticmethod\n ",
"my_input",
"staticmethod",
"my_input",
"def read_from_input():\n n, l = IO_for_Contest.read_n_int(2)\n a = IO_for_Contest.read_n_int(n)\n return l, a\n\n ",
"read_from_input",
"n, l = IO_for_Contest.read_n_int(2)",
"n",
"IO_for_Contest.read_n_int(2)",
"IO_for_Contest.read_n_int",
"IO_for_Contest",
"read_n_int",
"2",
"l",
"a = IO_for_Contest.read_n_int(n)",
"a",
"IO_for_Contest.read_n_int(n)",
"IO_for_Contest.read_n_int",
"IO_for_Contest",
"read_n_int",
"n",
"return l, a",
"return l, a",
"l",
"a",
"@staticmethod\n ",
"read_from_input",
"staticmethod",
"read_from_input",
"def read_line():\n return IO_for_Contest.my_input().strip()\n\n ",
"read_line",
"return IO_for_Contest.my_input().strip()",
"IO_for_Contest.my_input().strip()",
"IO_for_Contest.my_input().strip",
"IO_for_Contest.my_input()",
"IO_for_Contest.my_input",
"IO_for_Contest",
"my_input",
"strip",
"@staticmethod\n ",
"read_line",
"staticmethod",
"read_line",
"def read_int():\n return int(IO_for_Contest.my_input().strip())\n\n ",
"read_int",
"return int(IO_for_Contest.my_input().strip())",
"int(IO_for_Contest.my_input().strip())",
"int",
"IO_for_Contest.my_input().strip()",
"IO_for_Contest.my_input().strip",
"IO_for_Contest.my_input()",
"IO_for_Contest.my_input",
"IO_for_Contest",
"my_input",
"strip",
"@staticmethod\n ",
"read_int",
"staticmethod",
"read_int",
"def read_n_int(n):\n return list(map(int, re.split('\\W+', IO_for_Contest.my_input().strip())))[ : n]",
"read_n_int",
"return list(map(int, re.split('\\W+', IO_for_Contest.my_input().strip())))[ : n]",
"list(map(int, re.split('\\W+', IO_for_Contest.my_input().strip())))[ : n]",
"(map(int, re.split('\\W+', IO_for_Contest.my_input().strip())))",
"list",
"map(int, re.split('\\W+', IO_for_Contest.my_input().strip()))",
"map",
"int",
"re.split('\\W+', IO_for_Contest.my_input().strip())",
"re.split",
"re",
"split",
"'\\W+'",
"IO_for_Contest.my_input().strip()",
"IO_for_Contest.my_input().strip",
"IO_for_Contest.my_input()",
"IO_for_Contest.my_input",
"IO_for_Contest",
"my_input",
"strip",
": n",
"n",
"n",
"n",
"@staticmethod\n ",
"read_n_int",
"staticmethod",
"read_n_int",
"object",
"def solve():\n l, a = IO_for_Contest.read_from_input()\n result = find_way_how_to_split_ropes(l, a)\n if result is None:\n print('Impossible')\n else:\n print('Possible')\n for x in result:\n print(x)",
"solve",
"l, a = IO_for_Contest.read_from_input()",
"l",
"IO_for_Contest.read_from_input()",
"IO_for_Contest.read_from_input",
"IO_for_Contest",
"read_from_input",
"a",
"result = find_way_how_to_split_ropes(l, a)",
"result",
"find_way_how_to_split_ropes(l, a)",
"find_way_how_to_split_ropes",
"l",
"a",
"if result is None:\n print('Impossible')\n else:\n print('Possible')\n for x in result:\n print(x)",
"result is None",
"result",
"None",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"for x in result:\n print(x)",
"x",
"result",
"print(x)",
"print",
"x",
"def find_way_how_to_split_ropes(l, a):\n adjencent_sum = []\n for i in range(len(a) - 1):\n adjencent_sum.append(a[i] + a[i + 1])\n if max(adjencent_sum) < l:\n return None\n x = 0\n result = []\n for y in range(len(adjencent_sum)):\n if adjencent_sum[y] >= l:\n x = y + 1\n break\n result += [y + 1]\n for y in range(len(adjencent_sum) - 1, x - 1, -1):\n result += [y + 1]\n result += [x]\n return result",
"find_way_how_to_split_ropes",
"adjencent_sum = []",
"adjencent_sum",
"[]",
"for i in range(len(a) - 1):\n adjencent_sum.append(a[i] + a[i + 1])\n ",
"i",
"range(len(a) - 1)",
"range",
"len(a) - 1",
"len(a)",
"len",
"a",
"1",
"adjencent_sum.append(a[i] + a[i + 1])",
"adjencent_sum.append",
"adjencent_sum",
"append",
"a[i] + a[i + 1]",
"a[i]",
"a",
"i",
"a[i + 1]",
"a",
"i + 1",
"i",
"1",
"if max(adjencent_sum) < l:\n return None\n ",
"max(adjencent_sum) < l",
"max(adjencent_sum)",
"max",
"adjencent_sum",
"l",
"return None",
"None",
"x = 0",
"x",
"0",
"result = []",
"result",
"[]",
"for y in range(len(adjencent_sum)):\n if adjencent_sum[y] >= l:\n x = y + 1\n break\n result += [y + 1]\n ",
"y",
"range(len(adjencent_sum))",
"range",
"len(adjencent_sum)",
"len",
"adjencent_sum",
"if adjencent_sum[y] >= l:\n x = y + 1\n break\n ",
"adjencent_sum[y] >= l",
"adjencent_sum[y]",
"adjencent_sum",
"y",
"l",
"x = y + 1",
"x",
"y + 1",
"y",
"1",
"break",
"result += [y + 1]",
"result",
"[y + 1]",
"y + 1",
"y",
"1",
"for y in range(len(adjencent_sum) - 1, x - 1, -1):\n result += [y + 1]\n ",
"y",
"range(len(adjencent_sum) - 1, x - 1, -1)",
"range",
"len(adjencent_sum) - 1",
"len(adjencent_sum)",
"len",
"adjencent_sum",
"1",
"x - 1",
"x",
"1",
"-1",
"result += [y + 1]",
"result",
"[y + 1]",
"y + 1",
"y",
"1",
"result += [x]",
"result",
"[x]",
"x",
"return result",
"result",
"l",
"l",
"a",
"a",
"if __name__ == '__main__':\n solve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"solve()",
"solve",
"def solve():\n l, a = IO_for_Contest.read_from_input()\n result = find_way_how_to_split_ropes(l, a)\n if result is None:\n print('Impossible')\n else:\n print('Possible')\n for x in result:\n print(x)",
"def solve():\n l, a = IO_for_Contest.read_from_input()\n result = find_way_how_to_split_ropes(l, a)\n if result is None:\n print('Impossible')\n else:\n print('Possible')\n for x in result:\n print(x)",
"solve",
"class IO_for_Contest(object):\n @staticmethod\n def my_input():\n #return raw_input()\n return input()\n\n @staticmethod\n def read_from_input():\n n, l = IO_for_Contest.read_n_int(2)\n a = IO_for_Contest.read_n_int(n)\n return l, a\n\n @staticmethod\n def read_line():\n return IO_for_Contest.my_input().strip()\n\n @staticmethod\n def read_int():\n return int(IO_for_Contest.my_input().strip())\n\n @staticmethod\n def read_n_int(n):\n return list(map(int, re.split('\\W+', IO_for_Contest.my_input().strip())))[ : n]",
"class IO_for_Contest(object):\n @staticmethod\n def my_input():\n #return raw_input()\n return input()\n\n @staticmethod\n def read_from_input():\n n, l = IO_for_Contest.read_n_int(2)\n a = IO_for_Contest.read_n_int(n)\n return l, a\n\n @staticmethod\n def read_line():\n return IO_for_Contest.my_input().strip()\n\n @staticmethod\n def read_int():\n return int(IO_for_Contest.my_input().strip())\n\n @staticmethod\n def read_n_int(n):\n return list(map(int, re.split('\\W+', IO_for_Contest.my_input().strip())))[ : n]",
"IO_for_Contest",
"def find_way_how_to_split_ropes(l, a):\n adjencent_sum = []\n for i in range(len(a) - 1):\n adjencent_sum.append(a[i] + a[i + 1])\n if max(adjencent_sum) < l:\n return None\n x = 0\n result = []\n for y in range(len(adjencent_sum)):\n if adjencent_sum[y] >= l:\n x = y + 1\n break\n result += [y + 1]\n for y in range(len(adjencent_sum) - 1, x - 1, -1):\n result += [y + 1]\n result += [x]\n return result",
"def find_way_how_to_split_ropes(l, a):\n adjencent_sum = []\n for i in range(len(a) - 1):\n adjencent_sum.append(a[i] + a[i + 1])\n if max(adjencent_sum) < l:\n return None\n x = 0\n result = []\n for y in range(len(adjencent_sum)):\n if adjencent_sum[y] >= l:\n x = y + 1\n break\n result += [y + 1]\n for y in range(len(adjencent_sum) - 1, x - 1, -1):\n result += [y + 1]\n result += [x]\n return result",
"find_way_how_to_split_ropes"
] | import re
class IO_for_Contest(object):
@staticmethod
def my_input():
#return raw_input()
return input()
@staticmethod
def read_from_input():
n, l = IO_for_Contest.read_n_int(2)
a = IO_for_Contest.read_n_int(n)
return l, a
@staticmethod
def read_line():
return IO_for_Contest.my_input().strip()
@staticmethod
def read_int():
return int(IO_for_Contest.my_input().strip())
@staticmethod
def read_n_int(n):
return list(map(int, re.split('\W+', IO_for_Contest.my_input().strip())))[ : n]
def solve():
l, a = IO_for_Contest.read_from_input()
result = find_way_how_to_split_ropes(l, a)
if result is None:
print('Impossible')
else:
print('Possible')
for x in result:
print(x)
def find_way_how_to_split_ropes(l, a):
adjencent_sum = []
for i in range(len(a) - 1):
adjencent_sum.append(a[i] + a[i + 1])
if max(adjencent_sum) < l:
return None
x = 0
result = []
for y in range(len(adjencent_sum)):
if adjencent_sum[y] >= l:
x = y + 1
break
result += [y + 1]
for y in range(len(adjencent_sum) - 1, x - 1, -1):
result += [y + 1]
result += [x]
return result
if __name__ == '__main__':
solve() |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
14,
2,
13,
17,
14,
40,
4,
13,
13,
13,
4,
13,
17,
4,
13,
17,
4,
13,
4,
13,
17,
4,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
28,
13,
4,
13,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
18,
13,
13,
13,
3,
14,
2,
4,
13,
13,
17,
4,
13,
17,
4,
13,
4,
18,
13,
13,
13,
4,
13,
17,
28,
13,
4,
13,
2,
13,
17,
4,
13,
2,
18,
13,
13,
17,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] | [
[
140,
2
],
[
140,
11
],
[
137,
13
],
[
141,
26
],
[
138,
32
],
[
135,
33
],
[
143,
48
],
[
52,
51
],
[
141,
55
],
[
138,
61
],
[
51,
62
],
[
138,
64
],
[
51,
66
],
[
135,
68
],
[
131,
70
],
[
51,
71
],
[
74,
73
],
[
51,
76
],
[
144,
79
],
[
73,
81
],
[
84,
83
],
[
141,
87
],
[
51,
89
],
[
144,
93
],
[
83,
95
],
[
144,
101
],
[
144,
110
],
[
132,
112
],
[
118,
117
],
[
141,
121
],
[
144,
127
],
[
117,
128
],
[
51,
131
],
[
131,
132
],
[
140,
135
],
[
137,
138
],
[
140,
141
],
[
143,
144
]
] | [
"N,L=map(int,input().split())\nA=list(map(int,input().split()))\n\nif N==2:\n if sum(A)>=L:\n print(\"Possible\")\n print(\"1\")\n exit()\n else:\n print(\"Impossible\")\n exit()\nans=[]\nfor i in range(N-1):\n if A[i]+A[i+1]>=L:\n last=i\n for j in range(i):\n ans.append(j)\n for j in range(N-2,i,-1):\n ans.append(j)\n break\n\nif len(ans)==0:\n print(\"Impossible\")\n exit()\n\nans.append(last)\n\nprint(\"Possible\")\nfor i in range(N-1):\n print(ans[i]+1)",
"N,L=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"if N==2:\n if sum(A)>=L:\n print(\"Possible\")\n print(\"1\")\n exit()\n else:\n print(\"Impossible\")\n exit()",
"N==2",
"N",
"2",
"if sum(A)>=L:\n print(\"Possible\")\n print(\"1\")\n exit()\n else:\n print(\"Impossible\")\n exit()",
"sum(A)>=L",
"sum(A)",
"sum",
"A",
"L",
"print(\"Possible\")",
"print",
"\"Possible\"",
"print(\"1\")",
"print",
"\"1\"",
"exit()",
"exit",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit()",
"exit",
"ans=[]",
"ans",
"[]",
"for i in range(N-1):\n if A[i]+A[i+1]>=L:\n last=i\n for j in range(i):\n ans.append(j)\n for j in range(N-2,i,-1):\n ans.append(j)\n break",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i]+A[i+1]>=L:\n last=i\n for j in range(i):\n ans.append(j)\n for j in range(N-2,i,-1):\n ans.append(j)\n break",
"A[i]+A[i+1]>=L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"last=i",
"last",
"i",
"for j in range(i):\n ans.append(j)\n ",
"j",
"range(i)",
"range",
"i",
"ans.append(j)",
"ans.append",
"ans",
"append",
"j",
"for j in range(N-2,i,-1):\n ans.append(j)\n ",
"j",
"range(N-2,i,-1)",
"range",
"N-2",
"N",
"2",
"i",
"-1",
"ans.append(j)",
"ans.append",
"ans",
"append",
"j",
"break",
"if len(ans)==0:\n print(\"Impossible\")\n exit()",
"len(ans)==0",
"len(ans)",
"len",
"ans",
"0",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit()",
"exit",
"ans.append(last)",
"ans.append",
"ans",
"append",
"last",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(N-1):\n print(ans[i]+1)",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"print(ans[i]+1)",
"print",
"ans[i]+1",
"ans[i]",
"ans",
"i",
"1",
"last=i",
"i",
"last",
"L=map(int,input().split())",
"map(int,input().split())",
"L",
"A=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"N,L=map(int,input().split())",
"map(int,input().split())",
"N",
"ans=[]",
"[]",
"ans"
] | N,L=map(int,input().split())
A=list(map(int,input().split()))
if N==2:
if sum(A)>=L:
print("Possible")
print("1")
exit()
else:
print("Impossible")
exit()
ans=[]
for i in range(N-1):
if A[i]+A[i+1]>=L:
last=i
for j in range(i):
ans.append(j)
for j in range(N-2,i,-1):
ans.append(j)
break
if len(ans)==0:
print("Impossible")
exit()
ans.append(last)
print("Possible")
for i in range(N-1):
print(ans[i]+1) |
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
13,
17,
3,
4,
13,
17,
4,
13,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
4,
13,
13,
17,
13,
17,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] | [
[
96,
3
],
[
96,
12
],
[
87,
14
],
[
27,
26
],
[
88,
32
],
[
88,
38
],
[
26,
39
],
[
88,
41
],
[
26,
43
],
[
91,
45
],
[
93,
47
],
[
26,
49
],
[
62,
61
],
[
94,
65
],
[
61,
68
],
[
71,
70
],
[
88,
76
],
[
94,
78
],
[
70,
82
],
[
94,
85
],
[
87,
88
],
[
96,
91
],
[
93,
94
],
[
96,
97
]
] | [
"from collections import deque\nN, L = map(int, input().split())\nc = list(map(int, input().split()))\nfor i in range(len(c)-1):\n if c[i] + c[i+1] >= L:\n pos = i + 1\n break\nelse:\n print(\"Impossible\")\n exit()\n\nprint(\"Possible\")\nfor i in range(1,pos):\n print(i)\nfor i in range(len(c) -1, pos, -1):\n print(i)\nprint(pos)",
"from collections import deque",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"c = list(map(int, input().split()))",
"c",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(len(c)-1):\n if c[i] + c[i+1] >= L:\n pos = i + 1\n break\nelse:\n print(\"Impossible\")\n exit()",
"i",
"range(len(c)-1)",
"range",
"len(c)-1",
"len(c)",
"len",
"c",
"1",
"if c[i] + c[i+1] >= L:\n pos = i + 1\n break",
"c[i] + c[i+1] >= L",
"c[i] + c[i+1]",
"c[i]",
"c",
"i",
"c[i+1]",
"c",
"i+1",
"i",
"1",
"L",
"pos = i + 1",
"pos",
"i + 1",
"i",
"1",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit()",
"exit",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(1,pos):\n print(i)",
"i",
"range(1,pos)",
"range",
"1",
"pos",
"print(i)",
"print",
"i",
"for i in range(len(c) -1, pos, -1):\n print(i)",
"i",
"range(len(c) -1, pos, -1)",
"range",
"len(c) -1",
"len(c)",
"len",
"c",
"1",
"pos",
"-1",
"print(i)",
"print",
"i",
"print(pos)",
"print",
"pos",
"c = list(map(int, input().split()))",
"list(map(int, input().split()))",
"c",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"pos = i + 1",
"i + 1",
"pos",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N"
] | from collections import deque
N, L = map(int, input().split())
c = list(map(int, input().split()))
for i in range(len(c)-1):
if c[i] + c[i+1] >= L:
pos = i + 1
break
else:
print("Impossible")
exit()
print("Possible")
for i in range(1,pos):
print(i)
for i in range(len(c) -1, pos, -1):
print(i)
print(pos) |
[
7,
12,
13,
0,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
29,
17,
0,
13,
2,
2,
4,
13,
4,
13,
13,
4,
13,
4,
13,
4,
13,
2,
13,
17,
2,
13,
17,
39,
13,
29,
13,
23,
13,
23,
13,
14,
2,
13,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
13,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
41,
28,
13,
13,
4,
2,
13,
17,
4,
13,
31,
13,
0,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
5,
4
],
[
59,
7
],
[
10,
9
],
[
4,
13
],
[
59,
19
],
[
9,
20
],
[
59,
22
],
[
9,
24
],
[
61,
26
],
[
29,
28
],
[
9,
29
],
[
35,
34
],
[
4,
52
],
[
34,
57
],
[
59,
59
],
[
61,
61
],
[
133,
67
],
[
133,
76
],
[
127,
78
],
[
121,
90
],
[
131,
92
],
[
128,
93
],
[
134,
94
],
[
122,
97
],
[
108,
107
],
[
122,
107
],
[
107,
111
],
[
119,
118
],
[
121,
122
],
[
133,
125
],
[
127,
128
],
[
133,
134
]
] | [
"def solve(A,L):\n N = len(A)\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n pro = i\n break\n else:\n return None\n\n res = list(range(i))+list(reversed(range(i+1,N-1)))+[i]\n return res\n\n\nif __name__ == '__main__':\n N,L = map(int,input().split())\n\n A = list(map(int,input().split()))\n\n res = solve(A,L)\n if res is None:\n print('Impossible')\n else:\n print('Possible')\n print(*(v+1 for v in res), sep='\\n')",
"def solve(A,L):\n N = len(A)\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n pro = i\n break\n else:\n return None\n\n res = list(range(i))+list(reversed(range(i+1,N-1)))+[i]\n return res",
"solve",
"N = len(A)",
"N",
"len(A)",
"len",
"A",
"for i in range(N-1):\n if A[i]+A[i+1] >= L:\n pro = i\n break\n else:\n return None\n\n ",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i]+A[i+1] >= L:\n pro = i\n break\n ",
"A[i]+A[i+1] >= L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"pro = i",
"pro",
"i",
"break",
"return None",
"None",
"res = list(range(i))+list(reversed(range(i+1,N-1)))+[i]",
"res",
"list(range(i))+list(reversed(range(i+1,N-1)))+[i]",
"list(range(i))+list(reversed(range(i+1,N-1)))",
"list(range(i))",
"list",
"range(i)",
"range",
"i",
"list(reversed(range(i+1,N-1)))",
"list",
"reversed(range(i+1,N-1))",
"reversed",
"range(i+1,N-1)",
"range",
"i+1",
"i",
"1",
"N-1",
"N",
"1",
"[i]",
"i",
"return res",
"res",
"A",
"A",
"L",
"L",
"if __name__ == '__main__':\n N,L = map(int,input().split())\n\n A = list(map(int,input().split()))\n\n res = solve(A,L)\n if res is None:\n print('Impossible')\n else:\n print('Possible')\n print(*(v+1 for v in res), sep='\\n')",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"N,L = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"res = solve(A,L)",
"res",
"solve(A,L)",
"solve",
"A",
"L",
"if res is None:\n print('Impossible')\n else:\n print('Possible')\n print(*(v+1 for v in res), sep='\\n')",
"res is None",
"res",
"None",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"v+1 for v in res",
"for v in res",
"v",
"res",
"for v in res",
"v+1",
"v",
"1",
"print(*(v+1 for v in res), sep='\\n')",
"print",
"*(v+1 for v in res)",
"(v+1 for v in res)",
"sep='\\n'",
"sep",
"'\\n'",
"res = solve(A,L)",
"solve(A,L)",
"res",
"N,L = map(int,input().split())",
"map(int,input().split())",
"N",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"def solve(A,L):\n N = len(A)\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n pro = i\n break\n else:\n return None\n\n res = list(range(i))+list(reversed(range(i+1,N-1)))+[i]\n return res",
"def solve(A,L):\n N = len(A)\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n pro = i\n break\n else:\n return None\n\n res = list(range(i))+list(reversed(range(i+1,N-1)))+[i]\n return res",
"solve",
"L = map(int,input().split())",
"map(int,input().split())",
"L"
] | def solve(A,L):
N = len(A)
for i in range(N-1):
if A[i]+A[i+1] >= L:
pro = i
break
else:
return None
res = list(range(i))+list(reversed(range(i+1,N-1)))+[i]
return res
if __name__ == '__main__':
N,L = map(int,input().split())
A = list(map(int,input().split()))
res = solve(A,L)
if res is None:
print('Impossible')
else:
print('Possible')
print(*(v+1 for v in res), sep='\n') |
[
7,
12,
13,
29,
4,
13,
4,
13,
12,
13,
29,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
4,
13,
29,
13,
23,
13,
12,
13,
29,
4,
18,
4,
18,
18,
13,
13,
13,
13,
12,
13,
29,
4,
18,
13,
13,
13,
13,
23,
13,
23,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
18,
13,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
39,
42,
2,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
13,
14,
40,
2,
13,
13,
4,
18,
13,
13,
13,
29,
4,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
39,
42,
2,
4,
13,
13,
13,
0,
13,
4,
13,
13,
13,
17,
14,
40,
2,
13,
13,
4,
18,
13,
13,
13,
29,
4,
13,
13,
23,
13,
23,
13,
23,
13,
15,
15,
15,
15,
15,
13,
15,
13,
15,
13,
15,
15,
15,
15,
15,
15,
13,
4,
18,
13,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
17,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
14,
2,
13,
13,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
13,
13,
10,
12,
13,
10,
17,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13
] | [
[
37,
36
],
[
48,
39
],
[
48,
48
],
[
71,
68
],
[
73,
69
],
[
71,
71
],
[
73,
73
],
[
79,
78
],
[
96,
81
],
[
92,
87
],
[
94,
88
],
[
92,
92
],
[
94,
94
],
[
96,
96
],
[
101,
100
],
[
100,
106
],
[
135,
107
],
[
110,
109
],
[
131,
114
],
[
133,
115
],
[
109,
119
],
[
100,
120
],
[
100,
123
],
[
109,
125
],
[
100,
129
],
[
131,
131
],
[
133,
133
],
[
135,
135
],
[
140,
139
],
[
139,
145
],
[
173,
146
],
[
149,
148
],
[
300,
150
],
[
169,
151
],
[
171,
152
],
[
148,
157
],
[
139,
158
],
[
139,
161
],
[
148,
163
],
[
139,
167
],
[
169,
169
],
[
171,
171
],
[
173,
173
],
[
308,
197
],
[
338,
204
],
[
324,
206
],
[
338,
207
],
[
326,
209
],
[
318,
211
],
[
329,
213
],
[
320,
215
],
[
219,
218
],
[
339,
222
],
[
327,
228
],
[
218,
229
],
[
327,
231
],
[
218,
233
],
[
321,
235
],
[
306,
235
],
[
314,
237
],
[
218,
238
],
[
305,
240
],
[
327,
243
],
[
218,
244
],
[
327,
246
],
[
218,
248
],
[
306,
252
],
[
321,
252
],
[
297,
253
],
[
262,
261
],
[
315,
264
],
[
330,
264
],
[
261,
268
],
[
272,
271
],
[
339,
275
],
[
315,
277
],
[
330,
277
],
[
271,
282
],
[
315,
287
],
[
330,
287
],
[
338,
297
],
[
305,
306
],
[
308,
309
],
[
218,
314
],
[
314,
315
],
[
320,
321
],
[
326,
327
],
[
329,
330
],
[
338,
339
]
] | [
"def getN():\n return int(input())\ndef getNM():\n return map(int, input().split())\ndef getList():\n return list(map(int, input().split()))\ndef getArray(intn):\n return [int(input()) for i in range(intn)]\ndef input():\n return sys.stdin.readline().rstrip()\ndef rand_N(ran1, ran2):\n return random.randint(ran1, ran2)\ndef rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]\ndef rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)\n\ndef rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)\n\nfrom collections import defaultdict, deque, Counter\nfrom sys import exit\nfrom decimal import *\nfrom heapq import heapify, heappop, heappush\nimport math\nimport random\nimport string\nfrom copy import deepcopy\nfrom itertools import combinations, permutations, product\nfrom operator import mul, itemgetter\nfrom functools import reduce\nfrom bisect import bisect_left, bisect_right\n\nimport sys\nsys.setrecursionlimit(1000000000)\nmod = 10 ** 9 + 7\n\n#############\n# Main Code #\n#############\n\nN, L = getNM()\nA = getList()\nmax_len_knot, max_len = -1, 0\nfor i in range(N - 1):\n if A[i] + A[i + 1] > max_len:\n max_len_knot = i\n max_len = A[i] + A[i + 1]\nif max_len < L:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(max_len_knot):\n print(i + 1)\n for i in range(N - 2, max_len_knot, -1):\n print(i + 1)\n print(max_len_knot + 1)",
"def getN():\n return int(input())",
"getN",
"return int(input())",
"int(input())",
"int",
"input()",
"input",
"def getNM():\n return map(int, input().split())",
"getNM",
"return map(int, input().split())",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def getList():\n return list(map(int, input().split()))",
"getList",
"return list(map(int, input().split()))",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def getArray(intn):\n return [int(input()) for i in range(intn)]",
"getArray",
"int(input()) for i in range(intn)",
"for i in range(intn)",
"i",
"range(intn)",
"range",
"intn",
"for i in range(intn)",
"int(input())",
"int",
"input()",
"input",
"return [int(input()) for i in range(intn)]",
"[int(input()) for i in range(intn)]",
"intn",
"intn",
"def input():\n return sys.stdin.readline().rstrip()",
"input",
"return sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"def rand_N(ran1, ran2):\n return random.randint(ran1, ran2)",
"rand_N",
"return random.randint(ran1, ran2)",
"random.randint(ran1, ran2)",
"random.randint",
"random",
"randint",
"ran1",
"ran2",
"ran1",
"ran1",
"ran2",
"ran2",
"def rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]",
"rand_List",
"random.randint(ran1, ran2) for i in range(rantime)",
"for i in range(rantime)",
"i",
"range(rantime)",
"range",
"rantime",
"for i in range(rantime)",
"random.randint(ran1, ran2)",
"random.randint",
"random",
"randint",
"ran1",
"ran2",
"return [random.randint(ran1, ran2) for i in range(rantime)]",
"[random.randint(ran1, ran2) for i in range(rantime)]",
"ran1",
"ran1",
"ran2",
"ran2",
"rantime",
"rantime",
"def rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)",
"rand_ints_nodup",
"ns = []",
"ns",
"[]",
"while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n ",
"len(ns) < rantime",
"len(ns)",
"len",
"ns",
"rantime",
"n = random.randint(ran1, ran2)",
"n",
"random.randint(ran1, ran2)",
"random.randint",
"random",
"randint",
"ran1",
"ran2",
"if not n in ns:\n ns.append(n)\n ",
"not n in ns",
"n in ns",
"n",
"ns",
"ns.append(n)",
"ns.append",
"ns",
"append",
"n",
"return sorted(ns)",
"sorted(ns)",
"sorted",
"ns",
"ran1",
"ran1",
"ran2",
"ran2",
"rantime",
"rantime",
"def rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)",
"rand_query",
"r_query = []",
"r_query",
"[]",
"while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n ",
"len(r_query) < rantime",
"len(r_query)",
"len",
"r_query",
"rantime",
"n_q = rand_ints_nodup(ran1, ran2, 2)",
"n_q",
"rand_ints_nodup(ran1, ran2, 2)",
"rand_ints_nodup",
"ran1",
"ran2",
"2",
"if not n_q in r_query:\n r_query.append(n_q)\n ",
"not n_q in r_query",
"n_q in r_query",
"n_q",
"r_query",
"r_query.append(n_q)",
"r_query.append",
"r_query",
"append",
"n_q",
"return sorted(r_query)",
"sorted(r_query)",
"sorted",
"r_query",
"ran1",
"ran1",
"ran2",
"ran2",
"rantime",
"rantime",
"from collections import defaultdict, deque, Counter",
"from sys import exit",
"from decimal import *",
"from heapq import heapify, heappop, heappush",
"import math",
"math",
"import random",
"random",
"import string",
"string",
"from copy import deepcopy",
"from itertools import combinations, permutations, product",
"from operator import mul, itemgetter",
"from functools import reduce",
"from bisect import bisect_left, bisect_right",
"import sys",
"sys",
"sys.setrecursionlimit(1000000000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"1000000000",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N, L = getNM()",
"N",
"getNM()",
"getNM",
"L",
"A = getList()",
"A",
"getList()",
"getList",
"max_len_knot, max_len = -1, 0",
"max_len_knot",
"-1",
"max_len",
"0",
"for i in range(N - 1):\n if A[i] + A[i + 1] > max_len:\n max_len_knot = i\n max_len = A[i] + A[i + 1]",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"if A[i] + A[i + 1] > max_len:\n max_len_knot = i\n max_len = A[i] + A[i + 1]",
"A[i] + A[i + 1] > max_len",
"A[i] + A[i + 1]",
"A[i]",
"A",
"i",
"A[i + 1]",
"A",
"i + 1",
"i",
"1",
"max_len",
"max_len_knot = i",
"max_len_knot",
"i",
"max_len = A[i] + A[i + 1]",
"max_len",
"A[i] + A[i + 1]",
"A[i]",
"A",
"i",
"A[i + 1]",
"A",
"i + 1",
"i",
"1",
"if max_len < L:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(max_len_knot):\n print(i + 1)\n for i in range(N - 2, max_len_knot, -1):\n print(i + 1)\n print(max_len_knot + 1)",
"max_len < L",
"max_len",
"L",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"for i in range(max_len_knot):\n print(i + 1)\n ",
"i",
"range(max_len_knot)",
"range",
"max_len_knot",
"print(i + 1)",
"print",
"i + 1",
"i",
"1",
"for i in range(N - 2, max_len_knot, -1):\n print(i + 1)\n ",
"i",
"range(N - 2, max_len_knot, -1)",
"range",
"N - 2",
"N",
"2",
"max_len_knot",
"-1",
"print(i + 1)",
"print",
"i + 1",
"i",
"1",
"print(max_len_knot + 1)",
"print",
"max_len_knot + 1",
"max_len_knot",
"1",
"def input():\n return sys.stdin.readline().rstrip()",
"def input():\n return sys.stdin.readline().rstrip()",
"input",
"def rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]",
"def rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]",
"rand_List",
"L = getNM()",
"getNM()",
"L",
"def rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)",
"def rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)",
"rand_ints_nodup",
"def rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)",
"def rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)",
"rand_query",
"max_len = A[i] + A[i + 1]",
"A[i] + A[i + 1]",
"max_len",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"def rand_N(ran1, ran2):\n return random.randint(ran1, ran2)",
"def rand_N(ran1, ran2):\n return random.randint(ran1, ran2)",
"rand_N",
"max_len_knot = i",
"i",
"max_len_knot",
"def getList():\n return list(map(int, input().split()))",
"def getList():\n return list(map(int, input().split()))",
"getList",
"max_len = -1, 0",
"0",
"max_len",
"def getNM():\n return map(int, input().split())",
"def getNM():\n return map(int, input().split())",
"getNM",
"A = getList()",
"getList()",
"A",
"max_len_knot, max_len = -1, 0",
"-1",
"max_len_knot",
"def getArray(intn):\n return [int(input()) for i in range(intn)]",
"def getArray(intn):\n return [int(input()) for i in range(intn)]",
"getArray",
"def getN():\n return int(input())",
"def getN():\n return int(input())",
"getN",
"N, L = getNM()",
"getNM()",
"N"
] | def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
from heapq import heapify, heappop, heappush
import math
import random
import string
from copy import deepcopy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
N, L = getNM()
A = getList()
max_len_knot, max_len = -1, 0
for i in range(N - 1):
if A[i] + A[i + 1] > max_len:
max_len_knot = i
max_len = A[i] + A[i + 1]
if max_len < L:
print('Impossible')
else:
print('Possible')
for i in range(max_len_knot):
print(i + 1)
for i in range(N - 2, max_len_knot, -1):
print(i + 1)
print(max_len_knot + 1)
|
[
7,
15,
0,
13,
12,
4,
18,
13,
13,
4,
13,
13,
23,
0,
13,
12,
4,
13,
4,
13,
0,
13,
12,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
12,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
12,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
14,
13,
4,
13,
13,
23,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
2,
13,
17,
4,
13,
4,
13,
17,
10,
12,
13,
10,
17,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13
] | [
[
137,
3
],
[
164,
14
],
[
167,
21
],
[
143,
34
],
[
146,
45
],
[
140,
53
],
[
158,
56
],
[
170,
59
],
[
73,
71
],
[
73,
73
],
[
155,
75
],
[
144,
77
],
[
155,
78
],
[
161,
80
],
[
168,
82
],
[
85,
84
],
[
156,
88
],
[
162,
94
],
[
84,
95
],
[
162,
97
],
[
84,
99
],
[
150,
101
],
[
107,
106
],
[
84,
109
],
[
106,
113
],
[
117,
116
],
[
156,
120
],
[
84,
123
],
[
116,
129
],
[
137,
138
],
[
140,
141
],
[
143,
144
],
[
146,
147
],
[
155,
150
],
[
155,
156
],
[
158,
159
],
[
161,
162
],
[
164,
165
],
[
167,
168
],
[
170,
171
]
] | [
"from sys import stdout\nprintn = lambda x: stdout.write(str(x))\ninn = lambda : int(input())\ninl = lambda: list(map(int, input().split()))\ninm = lambda: map(int, input().split())\nins = lambda : input().strip()\nDBG = True # and False\nBIG = 999999999\nR = 10**9 + 7\n\ndef ddprint(x):\n if DBG:\n print(x)\n\nn,l = inm()\na = inl()\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n print('Possible')\n for j in range(i):\n print(j+1)\n for j in range(n-2,i-1,-1):\n print(j+1)\n exit()\nprint('Impossible')",
"from sys import stdout",
"printn = lambda x: stdout.write(str(x))",
"printn",
"lambda x: stdout.write(str(x))",
"stdout.write(str(x))",
"stdout.write",
"stdout",
"write",
"str(x)",
"str",
"x",
"x",
"inn = lambda : int(input())",
"inn",
"lambda : int(input())",
"int(input())",
"int",
"input()",
"input",
"inl = lambda: list(map(int, input().split()))",
"inl",
"lambda: list(map(int, input().split()))",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"inm = lambda: map(int, input().split())",
"inm",
"lambda: map(int, input().split())",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ins = lambda : input().strip()",
"ins",
"lambda : input().strip()",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"DBG = True",
"DBG",
"True",
"BIG = 999999999",
"BIG",
"999999999",
"R = 10**9 + 7",
"R",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"def ddprint(x):\n if DBG:\n print(x)",
"ddprint",
"if DBG:\n print(x)",
"DBG",
"print(x)",
"print",
"x",
"x",
"x",
"n,l = inm()",
"n",
"inm()",
"inm",
"l",
"a = inl()",
"a",
"inl()",
"inl",
"for i in range(n-1):\n if a[i]+a[i+1]>=l:\n print('Possible')\n for j in range(i):\n print(j+1)\n for j in range(n-2,i-1,-1):\n print(j+1)\n exit()",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1]>=l:\n print('Possible')\n for j in range(i):\n print(j+1)\n for j in range(n-2,i-1,-1):\n print(j+1)\n exit()",
"a[i]+a[i+1]>=l",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"print('Possible')",
"print",
"'Possible'",
"for j in range(i):\n print(j+1)\n ",
"j",
"range(i)",
"range",
"i",
"print(j+1)",
"print",
"j+1",
"j",
"1",
"for j in range(n-2,i-1,-1):\n print(j+1)\n ",
"j",
"range(n-2,i-1,-1)",
"range",
"n-2",
"n",
"2",
"i-1",
"i",
"1",
"-1",
"print(j+1)",
"print",
"j+1",
"j",
"1",
"exit()",
"exit",
"print('Impossible')",
"print",
"'Impossible'",
"printn = lambda x: stdout.write(str(x))",
"lambda x: stdout.write(str(x))",
"printn",
"DBG = True",
"True",
"DBG",
"inm = lambda: map(int, input().split())",
"lambda: map(int, input().split())",
"inm",
"ins = lambda : input().strip()",
"lambda : input().strip()",
"ins",
"l = inm()",
"inm()",
"l",
"def ddprint(x):\n if DBG:\n print(x)",
"def ddprint(x):\n if DBG:\n print(x)",
"ddprint",
"n,l = inm()",
"inm()",
"n",
"BIG = 999999999",
"999999999",
"BIG",
"a = inl()",
"inl()",
"a",
"inn = lambda : int(input())",
"lambda : int(input())",
"inn",
"inl = lambda: list(map(int, input().split()))",
"lambda: list(map(int, input().split()))",
"inl",
"R = 10**9 + 7",
"10**9 + 7",
"R"
] | from sys import stdout
printn = lambda x: stdout.write(str(x))
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 999999999
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
n,l = inm()
a = inl()
for i in range(n-1):
if a[i]+a[i+1]>=l:
print('Possible')
for j in range(i):
print(j+1)
for j in range(n-2,i-1,-1):
print(j+1)
exit()
print('Impossible')
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
13,
0,
13,
4,
13,
4,
13,
13,
0,
13,
12,
18,
13,
17,
23,
13,
14,
40,
13,
13,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
4,
13,
13,
2,
13,
17,
4,
13,
2,
13,
17,
4,
13,
17,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
108,
2
],
[
108,
11
],
[
111,
13
],
[
27,
26
],
[
109,
30
],
[
112,
35
],
[
26,
36
],
[
112,
38
],
[
26,
40
],
[
99,
43
],
[
102,
46
],
[
100,
51
],
[
54,
53
],
[
102,
59
],
[
97,
62
],
[
106,
63
],
[
69,
68
],
[
103,
71
],
[
68,
75
],
[
79,
78
],
[
103,
83
],
[
109,
85
],
[
78,
90
],
[
102,
97
],
[
99,
100
],
[
102,
103
],
[
108,
106
],
[
108,
109
],
[
111,
112
]
] | [
"#!/usr/bin/env python3\n\nN, L = map(int, input().split())\na = list(map(int, input().split()))\n\nsums = [a[i]+a[i+1] for i in range(N-1)]\n\nmaxind, maxval = max(enumerate(sums), key=lambda x:x[1])\nif maxval >= L:\n print(\"Possible\")\n for i in range(maxind):\n print(i+1)\n for j in reversed(range(maxind, N-1)):\n print(j+1)\nelse:\n print(\"Impossible\")",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a[i]+a[i+1] for i in range(N-1)",
"for i in range(N-1)",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"for i in range(N-1)",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"sums = [a[i]+a[i+1] for i in range(N-1)]",
"sums",
"[a[i]+a[i+1] for i in range(N-1)]",
"maxind, maxval = max(enumerate(sums), key=lambda x:x[1])",
"maxind",
"max(enumerate(sums), key=lambda x:x[1])",
"max",
"enumerate(sums)",
"enumerate",
"sums",
"key=lambda x:x[1]",
"key",
"lambda x:x[1]",
"x[1]",
"x",
"1",
"x",
"maxval",
"if maxval >= L:\n print(\"Possible\")\n for i in range(maxind):\n print(i+1)\n for j in reversed(range(maxind, N-1)):\n print(j+1)\nelse:\n print(\"Impossible\")",
"maxval >= L",
"maxval",
"L",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(maxind):\n print(i+1)\n ",
"i",
"range(maxind)",
"range",
"maxind",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for j in reversed(range(maxind, N-1)):\n print(j+1)",
"j",
"reversed(range(maxind, N-1))",
"reversed",
"range(maxind, N-1)",
"range",
"maxind",
"N-1",
"N",
"1",
"print(j+1)",
"print",
"j+1",
"j",
"1",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"maxval = max(enumerate(sums), key=lambda x:x[1])",
"max(enumerate(sums), key=lambda x:x[1])",
"maxval",
"sums = [a[i]+a[i+1] for i in range(N-1)]",
"[a[i]+a[i+1] for i in range(N-1)]",
"sums",
"maxind, maxval = max(enumerate(sums), key=lambda x:x[1])",
"max(enumerate(sums), key=lambda x:x[1])",
"maxind",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a"
] | #!/usr/bin/env python3
N, L = map(int, input().split())
a = list(map(int, input().split()))
sums = [a[i]+a[i+1] for i in range(N-1)]
maxind, maxval = max(enumerate(sums), key=lambda x:x[1])
if maxval >= L:
print("Possible")
for i in range(maxind):
print(i+1)
for j in reversed(range(maxind, N-1)):
print(j+1)
else:
print("Impossible")
|
[
7,
15,
12,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
17,
29,
4,
13,
13,
13,
23,
13,
12,
13,
28,
13,
13,
4,
13,
4,
13,
13,
17,
14,
40,
4,
13,
13,
13,
3,
29,
39,
0,
13,
39,
28,
13,
4,
13,
17,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
14,
2,
13,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
13,
13,
14,
13,
4,
13,
17,
4,
13,
31,
13,
0,
13,
17,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13
] | [
[
7,
6
],
[
21,
9
],
[
7,
10
],
[
10,
13
],
[
6,
18
],
[
10,
19
],
[
21,
21
],
[
137,
30
],
[
79,
31
],
[
77,
38
],
[
44,
43
],
[
47,
46
],
[
43,
53
],
[
46,
55
],
[
58,
57
],
[
75,
61
],
[
43,
69
],
[
57,
71
],
[
43,
73
],
[
75,
75
],
[
77,
77
],
[
79,
79
],
[
142,
85
],
[
142,
94
],
[
139,
96
],
[
133,
108
],
[
146,
110
],
[
143,
111
],
[
131,
112
],
[
140,
113
],
[
134,
122
],
[
125,
124
],
[
142,
131
],
[
133,
134
],
[
139,
140
],
[
142,
143
]
] | [
"# 解説見た\n\nfrom itertools import tee\n\n\ndef pairwise(iterable):\n \"s -> (s0,s1), (s1,s2), (s2, s3), ...\"\n a, b = tee(iterable)\n next(b, None)\n return zip(a, b)\n\n\ndef solve(N, L, a):\n for knot, pair in enumerate(pairwise(a), 1):\n if sum(pair) >= L:\n break\n else:\n return []\n # 隣接和は全てL未満のため、最後の一つを外せない\n\n ans = []\n for i in range(1, knot):\n ans.append(i)\n for i in range(N - 1, knot - 1, - 1):\n ans.append(i)\n return ans\n\n\nif __name__ == '__main__':\n N, L = map(int, input().split())\n a = tuple(map(int, input().split()))\n ans = solve(N, L, a)\n if ans:\n print('Possible')\n print(*ans, sep='\\n')\n else:\n print('Impossible')",
"from itertools import tee",
"def pairwise(iterable):\n \"s -> (s0,s1), (s1,s2), (s2, s3), ...\"\n a, b = tee(iterable)\n next(b, None)\n return zip(a, b)",
"pairwise",
"\"s -> (s0,s1), (s1,s2), (s2, s3), ...\"",
"a, b = tee(iterable)",
"a",
"tee(iterable)",
"tee",
"iterable",
"b",
"next(b, None)",
"next",
"b",
"None",
"return zip(a, b)",
"zip(a, b)",
"zip",
"a",
"b",
"iterable",
"iterable",
"def solve(N, L, a):\n for knot, pair in enumerate(pairwise(a), 1):\n if sum(pair) >= L:\n break\n else:\n return []\n # 隣接和は全てL未満のため、最後の一つを外せない\n\n ans = []\n for i in range(1, knot):\n ans.append(i)\n for i in range(N - 1, knot - 1, - 1):\n ans.append(i)\n return ans",
"solve",
"for knot, pair in enumerate(pairwise(a), 1):\n if sum(pair) >= L:\n break\n else:\n return []\n # 隣接和は全てL未満のため、最後の一つを外せない\n\n ",
"knot",
"pair",
"enumerate(pairwise(a), 1)",
"enumerate",
"pairwise(a)",
"pairwise",
"a",
"1",
"if sum(pair) >= L:\n break\n ",
"sum(pair) >= L",
"sum(pair)",
"sum",
"pair",
"L",
"break",
"return []",
"[]",
"ans = []",
"ans",
"[]",
"for i in range(1, knot):\n ans.append(i)\n ",
"i",
"range(1, knot)",
"range",
"1",
"knot",
"ans.append(i)",
"ans.append",
"ans",
"append",
"i",
"for i in range(N - 1, knot - 1, - 1):\n ans.append(i)\n ",
"i",
"range(N - 1, knot - 1, - 1)",
"range",
"N - 1",
"N",
"1",
"knot - 1",
"knot",
"1",
"- 1",
"ans.append(i)",
"ans.append",
"ans",
"append",
"i",
"return ans",
"ans",
"N",
"N",
"L",
"L",
"a",
"a",
"if __name__ == '__main__':\n N, L = map(int, input().split())\n a = tuple(map(int, input().split()))\n ans = solve(N, L, a)\n if ans:\n print('Possible')\n print(*ans, sep='\\n')\n else:\n print('Impossible')",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"a = tuple(map(int, input().split()))",
"a",
"tuple(map(int, input().split()))",
"tuple",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = solve(N, L, a)",
"ans",
"solve(N, L, a)",
"solve",
"N",
"L",
"a",
"if ans:\n print('Possible')\n print(*ans, sep='\\n')\n else:\n print('Impossible')",
"ans",
"print('Possible')",
"print",
"'Possible'",
"print(*ans, sep='\\n')",
"print",
"*ans",
"ans",
"sep='\\n'",
"sep",
"'\\n'",
"print('Impossible')",
"print",
"'Impossible'",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"ans = solve(N, L, a)",
"solve(N, L, a)",
"ans",
"def pairwise(iterable):\n \"s -> (s0,s1), (s1,s2), (s2, s3), ...\"\n a, b = tee(iterable)\n next(b, None)\n return zip(a, b)",
"def pairwise(iterable):\n \"s -> (s0,s1), (s1,s2), (s2, s3), ...\"\n a, b = tee(iterable)\n next(b, None)\n return zip(a, b)",
"pairwise",
"a = tuple(map(int, input().split()))",
"tuple(map(int, input().split()))",
"a",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"def solve(N, L, a):\n for knot, pair in enumerate(pairwise(a), 1):\n if sum(pair) >= L:\n break\n else:\n return []\n # 隣接和は全てL未満のため、最後の一つを外せない\n\n ans = []\n for i in range(1, knot):\n ans.append(i)\n for i in range(N - 1, knot - 1, - 1):\n ans.append(i)\n return ans",
"def solve(N, L, a):\n for knot, pair in enumerate(pairwise(a), 1):\n if sum(pair) >= L:\n break\n else:\n return []\n # 隣接和は全てL未満のため、最後の一つを外せない\n\n ans = []\n for i in range(1, knot):\n ans.append(i)\n for i in range(N - 1, knot - 1, - 1):\n ans.append(i)\n return ans",
"solve"
] | # 解説見た
from itertools import tee
def pairwise(iterable):
"s -> (s0,s1), (s1,s2), (s2, s3), ..."
a, b = tee(iterable)
next(b, None)
return zip(a, b)
def solve(N, L, a):
for knot, pair in enumerate(pairwise(a), 1):
if sum(pair) >= L:
break
else:
return []
# 隣接和は全てL未満のため、最後の一つを外せない
ans = []
for i in range(1, knot):
ans.append(i)
for i in range(N - 1, knot - 1, - 1):
ans.append(i)
return ans
if __name__ == '__main__':
N, L = map(int, input().split())
a = tuple(map(int, input().split()))
ans = solve(N, L, a)
if ans:
print('Possible')
print(*ans, sep='\n')
else:
print('Impossible')
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
4,
13,
2,
2,
13,
17,
13,
4,
13,
2,
2,
13,
17,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
100,
2
],
[
100,
11
],
[
106,
13
],
[
103,
25
],
[
29,
28
],
[
92,
32
],
[
107,
38
],
[
28,
39
],
[
107,
41
],
[
28,
43
],
[
101,
45
],
[
94,
47
],
[
97,
50
],
[
28,
51
],
[
95,
55
],
[
104,
55
],
[
65,
64
],
[
98,
69
],
[
64,
73
],
[
76,
75
],
[
92,
80
],
[
98,
82
],
[
92,
87
],
[
75,
89
],
[
100,
92
],
[
94,
95
],
[
28,
97
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
]
] | [
"n,l=map(int,input().split())\na=list(map(int,input().split()))\nfailflag=1\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n failflag=0\n k=i\n break\nif failflag==1:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,k+1):\n print(i)\n for i in range(n-1-k):\n print(n-1-i)",
"n,l=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"failflag=1",
"failflag",
"1",
"for i in range(n-1):\n if a[i]+a[i+1]>=l:\n failflag=0\n k=i\n break",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1]>=l:\n failflag=0\n k=i\n break",
"a[i]+a[i+1]>=l",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"failflag=0",
"failflag",
"0",
"k=i",
"k",
"i",
"break",
"if failflag==1:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,k+1):\n print(i)\n for i in range(n-1-k):\n print(n-1-i)",
"failflag==1",
"failflag",
"1",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"for i in range(1,k+1):\n print(i)\n ",
"i",
"range(1,k+1)",
"range",
"1",
"k+1",
"k",
"1",
"print(i)",
"print",
"i",
"for i in range(n-1-k):\n print(n-1-i)",
"i",
"range(n-1-k)",
"range",
"n-1-k",
"n-1",
"n",
"1",
"k",
"print(n-1-i)",
"print",
"n-1-i",
"n-1",
"n",
"1",
"i",
"n,l=map(int,input().split())",
"map(int,input().split())",
"n",
"failflag=0",
"0",
"failflag",
"k=i",
"i",
"k",
"l=map(int,input().split())",
"map(int,input().split())",
"l",
"failflag=1",
"1",
"failflag",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a"
] | n,l=map(int,input().split())
a=list(map(int,input().split()))
failflag=1
for i in range(n-1):
if a[i]+a[i+1]>=l:
failflag=0
k=i
break
if failflag==1:
print('Impossible')
else:
print('Possible')
for i in range(1,k+1):
print(i)
for i in range(n-1-k):
print(n-1-i) |
[
7,
12,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
13,
4,
13,
13,
18,
13,
39,
17,
4,
2,
13,
13,
0,
13,
13,
28,
13,
39,
13,
13,
4,
13,
4,
13,
13,
18,
13,
39,
17,
17,
14,
40,
2,
13,
13,
13,
41,
28,
13,
4,
13,
17,
13,
4,
13,
0,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
0,
13,
2,
13,
39,
13,
4,
13,
17,
4,
13,
31,
13,
0,
13,
17,
3,
4,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
15
],
[
18,
17
],
[
17,
34
],
[
17,
36
],
[
45,
44
],
[
17,
55
],
[
17,
57
],
[
15,
66
],
[
70,
69
],
[
69,
73
],
[
69,
75
],
[
78,
77
],
[
82,
81
],
[
4,
85
],
[
81,
87
],
[
81,
90
],
[
93,
92
],
[
92,
103
],
[
77,
103
],
[
106,
105
],
[
119,
116
]
] | [
"# AGC002C - Knot Puzzle\ndef main():\n N, L = tuple(map(int, input().split()))\n A = tuple(map(int, input().split()))\n B = [i + j for i, j in zip(A, A[1:])]\n for i, (a, b) in enumerate(zip(A, A[1:]), 1):\n if a + b >= L:\n ans = [i for i in range(1, i)]\n ans += [i for i in range(N - 1, i, -1)] + [i]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")\n break\n else:\n print(\"Impossible\")\n\n\nif __name__ == \"__main__\":\n main()",
"def main():\n N, L = tuple(map(int, input().split()))\n A = tuple(map(int, input().split()))\n B = [i + j for i, j in zip(A, A[1:])]\n for i, (a, b) in enumerate(zip(A, A[1:]), 1):\n if a + b >= L:\n ans = [i for i in range(1, i)]\n ans += [i for i in range(N - 1, i, -1)] + [i]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")\n break\n else:\n print(\"Impossible\")",
"main",
"N, L = tuple(map(int, input().split()))",
"N",
"tuple(map(int, input().split()))",
"tuple",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = tuple(map(int, input().split()))",
"A",
"tuple(map(int, input().split()))",
"tuple",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"i + j for i, j in zip(A, A[1:])",
"for i, j in zip(A, A[1:])",
"i",
"j",
"zip(A, A[1:])",
"zip",
"A",
"A[1:]",
"A",
"1:",
"1",
"for i, j in zip(A, A[1:])",
"i + j",
"i",
"j",
"B = [i + j for i, j in zip(A, A[1:])]",
"B",
"[i + j for i, j in zip(A, A[1:])]",
"for i, (a, b) in enumerate(zip(A, A[1:]), 1):\n if a + b >= L:\n ans = [i for i in range(1, i)]\n ans += [i for i in range(N - 1, i, -1)] + [i]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")\n break\n else:\n print(\"Impossible\")",
"i",
"(a, b)",
"a",
"b",
"enumerate(zip(A, A[1:]), 1)",
"enumerate",
"zip(A, A[1:])",
"zip",
"A",
"A[1:]",
"A",
"1:",
"1",
"1",
"if a + b >= L:\n ans = [i for i in range(1, i)]\n ans += [i for i in range(N - 1, i, -1)] + [i]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")\n break\n ",
"a + b >= L",
"a + b",
"a",
"b",
"L",
"i for i in range(1, i)",
"for i in range(1, i)",
"i",
"range(1, i)",
"range",
"1",
"i",
"for i in range(1, i)",
"i",
"ans = [i for i in range(1, i)]",
"ans",
"[i for i in range(1, i)]",
"i for i in range(N - 1, i, -1)",
"for i in range(N - 1, i, -1)",
"i",
"range(N - 1, i, -1)",
"range",
"N - 1",
"N",
"1",
"i",
"-1",
"for i in range(N - 1, i, -1)",
"i",
"ans += [i for i in range(N - 1, i, -1)] + [i]",
"ans",
"[i for i in range(N - 1, i, -1)] + [i]",
"[i for i in range(N - 1, i, -1)]",
"[i]",
"i",
"print(\"Possible\")",
"print",
"\"Possible\"",
"print(*ans, sep=\"\\n\")",
"print",
"*ans",
"ans",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n N, L = tuple(map(int, input().split()))\n A = tuple(map(int, input().split()))\n B = [i + j for i, j in zip(A, A[1:])]\n for i, (a, b) in enumerate(zip(A, A[1:]), 1):\n if a + b >= L:\n ans = [i for i in range(1, i)]\n ans += [i for i in range(N - 1, i, -1)] + [i]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")\n break\n else:\n print(\"Impossible\")",
"def main():\n N, L = tuple(map(int, input().split()))\n A = tuple(map(int, input().split()))\n B = [i + j for i, j in zip(A, A[1:])]\n for i, (a, b) in enumerate(zip(A, A[1:]), 1):\n if a + b >= L:\n ans = [i for i in range(1, i)]\n ans += [i for i in range(N - 1, i, -1)] + [i]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")\n break\n else:\n print(\"Impossible\")",
"main"
] | # AGC002C - Knot Puzzle
def main():
N, L = tuple(map(int, input().split()))
A = tuple(map(int, input().split()))
B = [i + j for i, j in zip(A, A[1:])]
for i, (a, b) in enumerate(zip(A, A[1:]), 1):
if a + b >= L:
ans = [i for i in range(1, i)]
ans += [i for i in range(N - 1, i, -1)] + [i]
print("Possible")
print(*ans, sep="\n")
break
else:
print("Impossible")
if __name__ == "__main__":
main() |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
14,
40,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
0,
13,
17,
0,
13,
2,
13,
17,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
13,
17,
13,
4,
13,
2,
2,
13,
13,
17,
10,
17,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] | [
[
109,
2
],
[
109,
11
],
[
15,
14
],
[
14,
23
],
[
103,
25
],
[
97,
28
],
[
112,
31
],
[
35,
34
],
[
110,
38
],
[
104,
43
],
[
34,
45
],
[
104,
48
],
[
34,
49
],
[
107,
50
],
[
100,
52
],
[
115,
55
],
[
34,
57
],
[
101,
62
],
[
98,
62
],
[
72,
71
],
[
116,
74
],
[
113,
74
],
[
71,
78
],
[
82,
81
],
[
110,
86
],
[
116,
88
],
[
113,
88
],
[
110,
93
],
[
81,
94
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
109,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
]
] | [
"N,L=map(int,input().split())\nA=[int(x) for x in input().split()]\n\npsbl=False\nans=0\nfor i in range(1,N):\n if A[i-1]+A[i]>=L:\n psbl=True\n ans=i-1\n break\nif psbl==False:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(ans):\n print(i+1)\n for j in range(N-1-ans):\n print(N-j-1)",
"N,L=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"int(x) for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"int(x)",
"int",
"x",
"A=[int(x) for x in input().split()]",
"A",
"[int(x) for x in input().split()]",
"psbl=False",
"psbl",
"False",
"ans=0",
"ans",
"0",
"for i in range(1,N):\n if A[i-1]+A[i]>=L:\n psbl=True\n ans=i-1\n break",
"i",
"range(1,N)",
"range",
"1",
"N",
"if A[i-1]+A[i]>=L:\n psbl=True\n ans=i-1\n break",
"A[i-1]+A[i]>=L",
"A[i-1]+A[i]",
"A[i-1]",
"A",
"i-1",
"i",
"1",
"A[i]",
"A",
"i",
"L",
"psbl=True",
"psbl",
"True",
"ans=i-1",
"ans",
"i-1",
"i",
"1",
"break",
"if psbl==False:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(ans):\n print(i+1)\n for j in range(N-1-ans):\n print(N-j-1)",
"psbl==False",
"psbl",
"False",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(ans):\n print(i+1)\n ",
"i",
"range(ans)",
"range",
"ans",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for j in range(N-1-ans):\n print(N-j-1)",
"j",
"range(N-1-ans)",
"range",
"N-1-ans",
"N-1",
"N",
"1",
"ans",
"print(N-j-1)",
"print",
"N-j-1",
"N-j",
"N",
"j",
"1",
"psbl=False",
"False",
"psbl",
"psbl=True",
"True",
"psbl",
"A=[int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"A",
"L=map(int,input().split())",
"map(int,input().split())",
"L",
"N,L=map(int,input().split())",
"map(int,input().split())",
"N",
"ans=0",
"0",
"ans",
"ans=i-1",
"i-1",
"ans"
] | N,L=map(int,input().split())
A=[int(x) for x in input().split()]
psbl=False
ans=0
for i in range(1,N):
if A[i-1]+A[i]>=L:
psbl=True
ans=i-1
break
if psbl==False:
print("Impossible")
else:
print("Possible")
for i in range(ans):
print(i+1)
for j in range(N-1-ans):
print(N-j-1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
4,
13,
2,
13,
17,
2,
13,
17,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
104,
2
],
[
104,
11
],
[
107,
13
],
[
98,
25
],
[
29,
28
],
[
105,
32
],
[
108,
38
],
[
28,
39
],
[
108,
41
],
[
28,
43
],
[
102,
45
],
[
95,
47
],
[
28,
48
],
[
96,
52
],
[
99,
52
],
[
64,
63
],
[
96,
66
],
[
99,
66
],
[
63,
70
],
[
74,
73
],
[
96,
79
],
[
99,
79
],
[
105,
82
],
[
73,
87
],
[
96,
92
],
[
99,
92
],
[
28,
95
],
[
95,
96
],
[
98,
99
],
[
104,
102
],
[
104,
105
],
[
107,
108
]
] | [
"n, l = map(int, input().split())\na = list(map(int, input().split()))\n\npos = -1\n\nfor i in range(n-1):\n if a[i] + a[i+1] >= l:\n pos = i\n break\nif pos == -1:\n print('Impossible')\n exit()\n\nprint('Possible')\nfor i in range(pos):\n print(i+1)\n\nfor i in reversed(range(pos+1,n-1)):\n print(i+1)\n\nprint(pos+1)\n",
"n, l = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"pos = -1",
"pos",
"-1",
"for i in range(n-1):\n if a[i] + a[i+1] >= l:\n pos = i\n break",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i] + a[i+1] >= l:\n pos = i\n break",
"a[i] + a[i+1] >= l",
"a[i] + a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"pos = i",
"pos",
"i",
"break",
"if pos == -1:\n print('Impossible')\n exit()",
"pos == -1",
"pos",
"-1",
"print('Impossible')",
"print",
"'Impossible'",
"exit()",
"exit",
"print('Possible')",
"print",
"'Possible'",
"for i in range(pos):\n print(i+1)",
"i",
"range(pos)",
"range",
"pos",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for i in reversed(range(pos+1,n-1)):\n print(i+1)",
"i",
"reversed(range(pos+1,n-1))",
"reversed",
"range(pos+1,n-1)",
"range",
"pos+1",
"pos",
"1",
"n-1",
"n",
"1",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"print(pos+1)",
"print",
"pos+1",
"pos",
"1",
"pos = i",
"i",
"pos",
"pos = -1",
"-1",
"pos",
"l = map(int, input().split())",
"map(int, input().split())",
"l",
"n, l = map(int, input().split())",
"map(int, input().split())",
"n",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a"
] | n, l = map(int, input().split())
a = list(map(int, input().split()))
pos = -1
for i in range(n-1):
if a[i] + a[i+1] >= l:
pos = i
break
if pos == -1:
print('Impossible')
exit()
print('Possible')
for i in range(pos):
print(i+1)
for i in reversed(range(pos+1,n-1)):
print(i+1)
print(pos+1)
|
[
7,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
0,
13,
18,
18,
13,
13,
13,
4,
18,
13,
13,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
13,
12,
13,
23,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
13,
12,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
13,
4,
13,
0,
13,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
0,
13,
18,
13,
13,
14,
2,
13,
39,
17,
17,
0,
18,
18,
13,
13,
13,
8,
2,
13,
39,
17,
17,
17,
17,
14,
2,
13,
39,
17,
17,
14,
2,
13,
39,
17,
17,
29,
17,
0,
18,
18,
13,
13,
13,
17,
14,
2,
13,
39,
17,
17,
14,
2,
13,
39,
17,
17,
29,
17,
0,
18,
18,
13,
13,
13,
17,
0,
18,
18,
13,
13,
13,
8,
2,
13,
39,
17,
17,
17,
17,
29,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
4,
13,
17,
29,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
2,
13,
17,
14,
2,
13,
17,
4,
13,
10,
18,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
280,
16
],
[
283,
28
],
[
43,
42
],
[
308,
48
],
[
52,
52
],
[
56,
55
],
[
64,
64
],
[
66,
66
],
[
70,
69
],
[
78,
78
],
[
80,
80
],
[
82,
82
],
[
87,
86
],
[
200,
89
],
[
93,
92
],
[
86,
95
],
[
100,
99
],
[
103,
102
],
[
86,
105
],
[
108,
107
],
[
86,
110
],
[
113,
112
],
[
200,
114
],
[
102,
115
],
[
118,
117
],
[
202,
119
],
[
107,
120
],
[
117,
123
],
[
133,
128
],
[
99,
130
],
[
102,
131
],
[
107,
132
],
[
112,
135
],
[
117,
143
],
[
112,
149
],
[
161,
156
],
[
99,
158
],
[
102,
159
],
[
107,
160
],
[
117,
164
],
[
112,
170
],
[
182,
177
],
[
99,
179
],
[
102,
180
],
[
107,
181
],
[
189,
184
],
[
99,
186
],
[
102,
187
],
[
107,
188
],
[
112,
191
],
[
99,
198
],
[
200,
200
],
[
202,
202
],
[
207,
206
],
[
293,
208
],
[
207,
209
],
[
212,
211
],
[
308,
213
],
[
216,
215
],
[
219,
218
],
[
206,
222
],
[
211,
228
],
[
218,
229
],
[
211,
231
],
[
218,
233
],
[
209,
235
],
[
238,
237
],
[
218,
238
],
[
249,
248
],
[
237,
251
],
[
215,
251
],
[
248,
255
],
[
259,
258
],
[
206,
262
],
[
237,
265
],
[
215,
265
],
[
258,
271
],
[
305,
278
],
[
280,
281
],
[
283,
284
]
] | [
"import bisect\nimport copy\nimport heapq\nimport sys\nimport itertools\nimport math\nimport queue\ninput = sys.stdin.readline\nsys.setrecursionlimit(1000000)\nmod = 10 ** 9 + 7\n\ndef read_values(): return map(int, input().split())\ndef read_index(): return map(lambda x: int(x) - 1, input().split())\ndef read_list(): return list(read_values())\ndef read_lists(N): return [read_list() for n in range(N)]\ndef init_dp1(init, N): return [init for _ in range(N)]\ndef init_dp2(init, N, M): return [[init for _ in range(M)] for _ in range(N)]\n\n\ndef f(S, T):\n N = len(S)\n F = [[0 for _ in range(N)] for __ in range(N)]\n \n for i in range(N):\n for j in range(N):\n SS = S[i]\n TT = T[j]\n if TT == (0, 0):\n F[i][j] = 1 if SS == (0, 1) else 0\n elif TT == (0, 1):\n if SS == (1, 0):\n return None\n F[i][j] = 1\n elif TT == (1, 0):\n if SS == (0, 1):\n return None\n F[i][j] = 0\n else:\n F[i][j] = 0 if SS == (1, 0) else 1\n\n return F\n\n\ndef main():\n N, L = read_values()\n A = read_list()\n\n r = 0\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n r = i\n break\n else:\n print(\"Impossible\")\n return\n\n print(\"Possible\")\n \n for i in range(r):\n print(i + 1)\n for i in range(N - 2, r - 1, -1):\n print(i + 1)\n\n\nif __name__ == \"__main__\":\n main()",
"import bisect",
"bisect",
"import copy",
"copy",
"import heapq",
"heapq",
"import sys",
"sys",
"import itertools",
"itertools",
"import math",
"math",
"import queue",
"queue",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"sys.setrecursionlimit(1000000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"1000000",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def read_values(): return map(int, input().split())",
"read_values",
"def read_index(): return map(lambda x: int(x) - 1, input().split())",
"read_index",
"def read_list(): return list(read_values())",
"read_list",
"read_list() for n in range(N)",
"for n in range(N)",
"n",
"range(N)",
"range",
"N",
"for n in range(N)",
"read_list()",
"read_list",
"def read_lists(N): return [read_list() for n in range(N)]",
"read_lists",
"N",
"N",
"init for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"init",
"def init_dp1(init, N): return [init for _ in range(N)]",
"init_dp1",
"init",
"init",
"N",
"N",
"[init for _ in range(M)] for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"[init for _ in range(M)]",
"def init_dp2(init, N, M): return [[init for _ in range(M)] for _ in range(N)]",
"init_dp2",
"init",
"init",
"N",
"N",
"M",
"M",
"def f(S, T):\n N = len(S)\n F = [[0 for _ in range(N)] for __ in range(N)]\n \n for i in range(N):\n for j in range(N):\n SS = S[i]\n TT = T[j]\n if TT == (0, 0):\n F[i][j] = 1 if SS == (0, 1) else 0\n elif TT == (0, 1):\n if SS == (1, 0):\n return None\n F[i][j] = 1\n elif TT == (1, 0):\n if SS == (0, 1):\n return None\n F[i][j] = 0\n else:\n F[i][j] = 0 if SS == (1, 0) else 1\n\n return F",
"f",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"[0 for _ in range(N)] for __ in range(N)",
"for __ in range(N)",
"__",
"range(N)",
"range",
"N",
"for __ in range(N)",
"[0 for _ in range(N)]",
"F = [[0 for _ in range(N)] for __ in range(N)]",
"F",
"[[0 for _ in range(N)] for __ in range(N)]",
"for i in range(N):\n for j in range(N):\n SS = S[i]\n TT = T[j]\n if TT == (0, 0):\n F[i][j] = 1 if SS == (0, 1) else 0\n elif TT == (0, 1):\n if SS == (1, 0):\n return None\n F[i][j] = 1\n elif TT == (1, 0):\n if SS == (0, 1):\n return None\n F[i][j] = 0\n else:\n F[i][j] = 0 if SS == (1, 0) else 1\n\n ",
"i",
"range(N)",
"range",
"N",
"for j in range(N):\n SS = S[i]\n TT = T[j]\n if TT == (0, 0):\n F[i][j] = 1 if SS == (0, 1) else 0\n elif TT == (0, 1):\n if SS == (1, 0):\n return None\n F[i][j] = 1\n elif TT == (1, 0):\n if SS == (0, 1):\n return None\n F[i][j] = 0\n else:\n F[i][j] = 0 if SS == (1, 0) else 1\n\n ",
"j",
"range(N)",
"range",
"N",
"SS = S[i]",
"SS",
"S[i]",
"S",
"i",
"TT = T[j]",
"TT",
"T[j]",
"T",
"j",
"if TT == (0, 0):\n F[i][j] = 1 if SS == (0, 1) else 0\n elif TT == (0, 1):\n if SS == (1, 0):\n return None\n F[i][j] = 1\n elif TT == (1, 0):\n if SS == (0, 1):\n return None\n F[i][j] = 0\n else:\n F[i][j] = 0 if SS == (1, 0) else 1\n\n ",
"TT == (0, 0)",
"TT",
"(0, 0)",
"0",
"0",
"F[i][j] = 1 if SS == (0, 1) else 0",
"F[i][j]",
"[i]",
"F",
"i",
"j",
"1 if SS == (0, 1) else 0",
"SS == (0, 1)",
"SS",
"(0, 1)",
"0",
"1",
"1",
"0",
"elif TT == (0, 1):\n if SS == (1, 0):\n return None\n F[i][j] = 1\n ",
"TT == (0, 1)",
"TT",
"(0, 1)",
"0",
"1",
"if SS == (1, 0):\n return None\n ",
"SS == (1, 0)",
"SS",
"(1, 0)",
"1",
"0",
"return None",
"None",
"F[i][j] = 1",
"F[i][j]",
"[i]",
"F",
"i",
"j",
"1",
"elif TT == (1, 0):\n if SS == (0, 1):\n return None\n F[i][j] = 0\n ",
"TT == (1, 0)",
"TT",
"(1, 0)",
"1",
"0",
"if SS == (0, 1):\n return None\n ",
"SS == (0, 1)",
"SS",
"(0, 1)",
"0",
"1",
"return None",
"None",
"F[i][j] = 0",
"F[i][j]",
"[i]",
"F",
"i",
"j",
"0",
"F[i][j] = 0 if SS == (1, 0) else 1",
"F[i][j]",
"[i]",
"F",
"i",
"j",
"0 if SS == (1, 0) else 1",
"SS == (1, 0)",
"SS",
"(1, 0)",
"1",
"0",
"0",
"1",
"return F",
"F",
"S",
"S",
"T",
"T",
"def main():\n N, L = read_values()\n A = read_list()\n\n r = 0\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n r = i\n break\n else:\n print(\"Impossible\")\n return\n\n print(\"Possible\")\n \n for i in range(r):\n print(i + 1)\n for i in range(N - 2, r - 1, -1):\n print(i + 1)",
"main",
"N, L = read_values()",
"N",
"read_values()",
"read_values",
"L",
"A = read_list()",
"A",
"read_list()",
"read_list",
"r = 0",
"r",
"0",
"for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n r = i\n break\n else:\n print(\"Impossible\")\n return\n\n ",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"if A[i] + A[i + 1] >= L:\n r = i\n break\n ",
"A[i] + A[i + 1] >= L",
"A[i] + A[i + 1]",
"A[i]",
"A",
"i",
"A[i + 1]",
"A",
"i + 1",
"i",
"1",
"L",
"r = i",
"r",
"i",
"break",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"return",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(r):\n print(i + 1)\n ",
"i",
"range(r)",
"range",
"r",
"print(i + 1)",
"print",
"i + 1",
"i",
"1",
"for i in range(N - 2, r - 1, -1):\n print(i + 1)",
"i",
"range(N - 2, r - 1, -1)",
"range",
"N - 2",
"N",
"2",
"r - 1",
"r",
"1",
"-1",
"print(i + 1)",
"print",
"i + 1",
"i",
"1",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"def init_dp1(init, N): return [init for _ in range(N)]",
"def init_dp1(init, N): return [init for _ in range(N)]",
"init_dp1",
"def f(S, T):\n N = len(S)\n F = [[0 for _ in range(N)] for __ in range(N)]\n \n for i in range(N):\n for j in range(N):\n SS = S[i]\n TT = T[j]\n if TT == (0, 0):\n F[i][j] = 1 if SS == (0, 1) else 0\n elif TT == (0, 1):\n if SS == (1, 0):\n return None\n F[i][j] = 1\n elif TT == (1, 0):\n if SS == (0, 1):\n return None\n F[i][j] = 0\n else:\n F[i][j] = 0 if SS == (1, 0) else 1\n\n return F",
"def f(S, T):\n N = len(S)\n F = [[0 for _ in range(N)] for __ in range(N)]\n \n for i in range(N):\n for j in range(N):\n SS = S[i]\n TT = T[j]\n if TT == (0, 0):\n F[i][j] = 1 if SS == (0, 1) else 0\n elif TT == (0, 1):\n if SS == (1, 0):\n return None\n F[i][j] = 1\n elif TT == (1, 0):\n if SS == (0, 1):\n return None\n F[i][j] = 0\n else:\n F[i][j] = 0 if SS == (1, 0) else 1\n\n return F",
"f",
"def read_values(): return map(int, input().split())",
"def read_values(): return map(int, input().split())",
"read_values",
"def read_index(): return map(lambda x: int(x) - 1, input().split())",
"def read_index(): return map(lambda x: int(x) - 1, input().split())",
"read_index",
"def read_lists(N): return [read_list() for n in range(N)]",
"def read_lists(N): return [read_list() for n in range(N)]",
"read_lists",
"def init_dp2(init, N, M): return [[init for _ in range(M)] for _ in range(N)]",
"def init_dp2(init, N, M): return [[init for _ in range(M)] for _ in range(N)]",
"init_dp2",
"def main():\n N, L = read_values()\n A = read_list()\n\n r = 0\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n r = i\n break\n else:\n print(\"Impossible\")\n return\n\n print(\"Possible\")\n \n for i in range(r):\n print(i + 1)\n for i in range(N - 2, r - 1, -1):\n print(i + 1)",
"def main():\n N, L = read_values()\n A = read_list()\n\n r = 0\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n r = i\n break\n else:\n print(\"Impossible\")\n return\n\n print(\"Possible\")\n \n for i in range(r):\n print(i + 1)\n for i in range(N - 2, r - 1, -1):\n print(i + 1)",
"main",
"def read_list(): return list(read_values())",
"def read_list(): return list(read_values())",
"read_list"
] | import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7
def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
def init_dp1(init, N): return [init for _ in range(N)]
def init_dp2(init, N, M): return [[init for _ in range(M)] for _ in range(N)]
def f(S, T):
N = len(S)
F = [[0 for _ in range(N)] for __ in range(N)]
for i in range(N):
for j in range(N):
SS = S[i]
TT = T[j]
if TT == (0, 0):
F[i][j] = 1 if SS == (0, 1) else 0
elif TT == (0, 1):
if SS == (1, 0):
return None
F[i][j] = 1
elif TT == (1, 0):
if SS == (0, 1):
return None
F[i][j] = 0
else:
F[i][j] = 0 if SS == (1, 0) else 1
return F
def main():
N, L = read_values()
A = read_list()
r = 0
for i in range(N - 1):
if A[i] + A[i + 1] >= L:
r = i
break
else:
print("Impossible")
return
print("Possible")
for i in range(r):
print(i + 1)
for i in range(N - 2, r - 1, -1):
print(i + 1)
if __name__ == "__main__":
main()
|
[
7,
12,
13,
0,
13,
4,
13,
13,
14,
2,
13,
17,
0,
13,
17,
4,
13,
13,
29,
14,
40,
13,
17,
0,
13,
17,
0,
13,
2,
13,
13,
14,
2,
2,
13,
17,
17,
0,
13,
17,
0,
13,
17,
4,
13,
13,
29,
12,
13,
0,
13,
4,
13,
13,
0,
13,
2,
39,
17,
13,
0,
13,
4,
13,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
18,
13,
2,
13,
17,
17,
0,
18,
13,
2,
13,
17,
17,
14,
18,
13,
2,
13,
17,
0,
18,
13,
2,
13,
17,
17,
14,
2,
18,
13,
2,
13,
17,
17,
0,
18,
13,
2,
13,
17,
17,
0,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
29,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
0,
13,
13,
3,
4,
13,
13,
14,
2,
13,
17,
29,
0,
13,
39,
28,
13,
4,
13,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
18,
13,
13,
13,
4,
18,
13,
13,
13,
28,
13,
13,
4,
13,
2,
13,
17,
29,
15,
13,
13,
13,
13,
13,
13,
15,
15,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
7
],
[
4,
10
],
[
14,
13
],
[
13,
17
],
[
7,
21
],
[
25,
24
],
[
28,
27
],
[
7,
29
],
[
4,
30
],
[
27,
34
],
[
39,
38
],
[
42,
41
],
[
41,
45
],
[
38,
45
],
[
24,
45
],
[
13,
45
],
[
51,
50
],
[
51,
53
],
[
56,
55
],
[
50,
59
],
[
62,
61
],
[
69,
66
],
[
61,
67
],
[
72,
71
],
[
53,
74
],
[
77,
76
],
[
77,
79
],
[
86,
81
],
[
55,
82
],
[
76,
84
],
[
93,
88
],
[
55,
89
],
[
79,
91
],
[
61,
96
],
[
76,
98
],
[
106,
101
],
[
61,
102
],
[
79,
104
],
[
55,
110
],
[
76,
112
],
[
121,
116
],
[
61,
117
],
[
76,
119
],
[
124,
123
],
[
61,
128
],
[
123,
132
],
[
138,
137
],
[
138,
140
],
[
143,
142
],
[
147,
146
],
[
150,
149
],
[
153,
152
],
[
137,
156
],
[
142,
162
],
[
152,
163
],
[
142,
165
],
[
152,
167
],
[
140,
169
],
[
172,
171
],
[
175,
174
],
[
152,
175
],
[
171,
179
],
[
149,
179
],
[
174,
182
],
[
146,
182
],
[
187,
186
],
[
190,
189
],
[
174,
192
],
[
146,
192
],
[
186,
195
],
[
189,
197
],
[
200,
199
],
[
137,
203
],
[
174,
205
],
[
146,
205
],
[
186,
209
],
[
199,
211
],
[
186,
214
],
[
174,
216
],
[
146,
216
],
[
219,
218
],
[
186,
218
],
[
218,
223
],
[
270,
246
],
[
276,
253
],
[
292,
262
],
[
270,
271
],
[
276,
277
]
] | [
"def examA():\n a, b = LI()\n if a>0:\n ans = \"Positive\"\n print(ans)\n return\n if b>=0:\n ans = \"Zero\"\n else:\n judge = b-a\n if judge%2==1:\n ans = \"Positive\"\n else:\n ans = \"Negative\"\n print(ans)\n return\n\ndef examB():\n N, M = LI()\n boal = [1]*N\n d = defaultdict(bool)\n d[0] = True\n for _ in range(M):\n x,y = LI()\n boal[x-1] -=1\n boal[y-1] +=1\n if d[x-1]:\n d[y-1] = True\n if boal[x-1]==0:\n d[x-1] = False\n ans = sum(d.values())\n print(ans)\n return\n\ndef examC():\n N, L = LI()\n A = LI(); cur = -1\n ans = \"Impossible\"\n for i in range(N-1):\n if A[i]+A[i+1]>=L:\n ans = \"Possible\"\n cur = i\n break\n print(ans)\n if cur==-1:\n return\n ansC = []\n for i in range(cur):\n ansC.append(i)\n for i in range(N-2,cur,-1):\n ansC.append(i)\n ansC.append(cur)\n for v in ansC:\n print(v+1)\n return\n\nimport sys,copy,bisect,itertools,heapq,math\nfrom heapq import heappop,heappush,heapify\nfrom collections import Counter,defaultdict,deque\ndef I(): return int(sys.stdin.readline())\ndef LI(): return list(map(int,sys.stdin.readline().split()))\ndef LSI(): return list(map(str,sys.stdin.readline().split()))\ndef LS(): return sys.stdin.readline().split()\ndef SI(): return sys.stdin.readline().strip()\nmod = 10**9 + 7\ninf = float('inf')\n\nif __name__ == '__main__':\n examC()",
"def examA():\n a, b = LI()\n if a>0:\n ans = \"Positive\"\n print(ans)\n return\n if b>=0:\n ans = \"Zero\"\n else:\n judge = b-a\n if judge%2==1:\n ans = \"Positive\"\n else:\n ans = \"Negative\"\n print(ans)\n return",
"examA",
"a, b = LI()",
"a",
"LI()",
"LI",
"b",
"if a>0:\n ans = \"Positive\"\n print(ans)\n return\n ",
"a>0",
"a",
"0",
"ans = \"Positive\"",
"ans",
"\"Positive\"",
"print(ans)",
"print",
"ans",
"return",
"if b>=0:\n ans = \"Zero\"\n else:\n judge = b-a\n if judge%2==1:\n ans = \"Positive\"\n else:\n ans = \"Negative\"\n ",
"b>=0",
"b",
"0",
"ans = \"Zero\"",
"ans",
"\"Zero\"",
"judge = b-a",
"judge",
"b-a",
"b",
"a",
"if judge%2==1:\n ans = \"Positive\"\n else:\n ans = \"Negative\"\n ",
"judge%2==1",
"judge%2",
"judge",
"2",
"1",
"ans = \"Positive\"",
"ans",
"\"Positive\"",
"ans = \"Negative\"",
"ans",
"\"Negative\"",
"print(ans)",
"print",
"ans",
"return",
"def examB():\n N, M = LI()\n boal = [1]*N\n d = defaultdict(bool)\n d[0] = True\n for _ in range(M):\n x,y = LI()\n boal[x-1] -=1\n boal[y-1] +=1\n if d[x-1]:\n d[y-1] = True\n if boal[x-1]==0:\n d[x-1] = False\n ans = sum(d.values())\n print(ans)\n return",
"examB",
"N, M = LI()",
"N",
"LI()",
"LI",
"M",
"boal = [1]*N",
"boal",
"[1]*N",
"[1]",
"1",
"N",
"d = defaultdict(bool)",
"d",
"defaultdict(bool)",
"defaultdict",
"bool",
"d[0] = True",
"d[0]",
"d",
"0",
"True",
"for _ in range(M):\n x,y = LI()\n boal[x-1] -=1\n boal[y-1] +=1\n if d[x-1]:\n d[y-1] = True\n if boal[x-1]==0:\n d[x-1] = False\n ",
"_",
"range(M)",
"range",
"M",
"x,y = LI()",
"x",
"LI()",
"LI",
"y",
"boal[x-1] -=1",
"boal[x-1]",
"boal",
"x-1",
"x",
"1",
"1",
"boal[y-1] +=1",
"boal[y-1]",
"boal",
"y-1",
"y",
"1",
"1",
"if d[x-1]:\n d[y-1] = True\n ",
"d[x-1]",
"d",
"x-1",
"x",
"1",
"d[y-1] = True",
"d[y-1]",
"d",
"y-1",
"y",
"1",
"True",
"if boal[x-1]==0:\n d[x-1] = False\n ",
"boal[x-1]==0",
"boal[x-1]",
"boal",
"x-1",
"x",
"1",
"0",
"d[x-1] = False",
"d[x-1]",
"d",
"x-1",
"x",
"1",
"False",
"ans = sum(d.values())",
"ans",
"sum(d.values())",
"sum",
"d.values()",
"d.values",
"d",
"values",
"print(ans)",
"print",
"ans",
"return",
"def examC():\n N, L = LI()\n A = LI(); cur = -1\n ans = \"Impossible\"\n for i in range(N-1):\n if A[i]+A[i+1]>=L:\n ans = \"Possible\"\n cur = i\n break\n print(ans)\n if cur==-1:\n return\n ansC = []\n for i in range(cur):\n ansC.append(i)\n for i in range(N-2,cur,-1):\n ansC.append(i)\n ansC.append(cur)\n for v in ansC:\n print(v+1)\n return",
"examC",
"N, L = LI()",
"N",
"LI()",
"LI",
"L",
"A = LI()",
"A",
"LI()",
"LI",
"cur = -1",
"cur",
"-1",
"ans = \"Impossible\"",
"ans",
"\"Impossible\"",
"for i in range(N-1):\n if A[i]+A[i+1]>=L:\n ans = \"Possible\"\n cur = i\n break\n ",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i]+A[i+1]>=L:\n ans = \"Possible\"\n cur = i\n break\n ",
"A[i]+A[i+1]>=L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"ans = \"Possible\"",
"ans",
"\"Possible\"",
"cur = i",
"cur",
"i",
"break",
"print(ans)",
"print",
"ans",
"if cur==-1:\n return\n ",
"cur==-1",
"cur",
"-1",
"return",
"ansC = []",
"ansC",
"[]",
"for i in range(cur):\n ansC.append(i)\n ",
"i",
"range(cur)",
"range",
"cur",
"ansC.append(i)",
"ansC.append",
"ansC",
"append",
"i",
"for i in range(N-2,cur,-1):\n ansC.append(i)\n ",
"i",
"range(N-2,cur,-1)",
"range",
"N-2",
"N",
"2",
"cur",
"-1",
"ansC.append(i)",
"ansC.append",
"ansC",
"append",
"i",
"ansC.append(cur)",
"ansC.append",
"ansC",
"append",
"cur",
"for v in ansC:\n print(v+1)\n ",
"v",
"ansC",
"print(v+1)",
"print",
"v+1",
"v",
"1",
"return",
"import sys,copy,bisect,itertools,heapq,math",
"sys",
"copy",
"bisect",
"itertools",
"heapq",
"math",
"from heapq import heappop,heappush,heapify",
"from collections import Counter,defaultdict,deque",
"def I(): return int(sys.stdin.readline())",
"I",
"def LI(): return list(map(int,sys.stdin.readline().split()))",
"LI",
"def LSI(): return list(map(str,sys.stdin.readline().split()))",
"LSI",
"def LS(): return sys.stdin.readline().split()",
"LS",
"def SI(): return sys.stdin.readline().strip()",
"SI",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"inf = float('inf')",
"inf",
"float('inf')",
"float",
"'inf'",
"if __name__ == '__main__':\n examC()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"examC()",
"examC",
"def examA():\n a, b = LI()\n if a>0:\n ans = \"Positive\"\n print(ans)\n return\n if b>=0:\n ans = \"Zero\"\n else:\n judge = b-a\n if judge%2==1:\n ans = \"Positive\"\n else:\n ans = \"Negative\"\n print(ans)\n return",
"def examA():\n a, b = LI()\n if a>0:\n ans = \"Positive\"\n print(ans)\n return\n if b>=0:\n ans = \"Zero\"\n else:\n judge = b-a\n if judge%2==1:\n ans = \"Positive\"\n else:\n ans = \"Negative\"\n print(ans)\n return",
"examA",
"def LSI(): return list(map(str,sys.stdin.readline().split()))",
"def LSI(): return list(map(str,sys.stdin.readline().split()))",
"LSI",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"def I(): return int(sys.stdin.readline())",
"def I(): return int(sys.stdin.readline())",
"I",
"inf = float('inf')",
"float('inf')",
"inf",
"def examB():\n N, M = LI()\n boal = [1]*N\n d = defaultdict(bool)\n d[0] = True\n for _ in range(M):\n x,y = LI()\n boal[x-1] -=1\n boal[y-1] +=1\n if d[x-1]:\n d[y-1] = True\n if boal[x-1]==0:\n d[x-1] = False\n ans = sum(d.values())\n print(ans)\n return",
"def examB():\n N, M = LI()\n boal = [1]*N\n d = defaultdict(bool)\n d[0] = True\n for _ in range(M):\n x,y = LI()\n boal[x-1] -=1\n boal[y-1] +=1\n if d[x-1]:\n d[y-1] = True\n if boal[x-1]==0:\n d[x-1] = False\n ans = sum(d.values())\n print(ans)\n return",
"examB",
"def LS(): return sys.stdin.readline().split()",
"def LS(): return sys.stdin.readline().split()",
"LS",
"def SI(): return sys.stdin.readline().strip()",
"def SI(): return sys.stdin.readline().strip()",
"SI",
"def LI(): return list(map(int,sys.stdin.readline().split()))",
"def LI(): return list(map(int,sys.stdin.readline().split()))",
"LI",
"def examC():\n N, L = LI()\n A = LI(); cur = -1\n ans = \"Impossible\"\n for i in range(N-1):\n if A[i]+A[i+1]>=L:\n ans = \"Possible\"\n cur = i\n break\n print(ans)\n if cur==-1:\n return\n ansC = []\n for i in range(cur):\n ansC.append(i)\n for i in range(N-2,cur,-1):\n ansC.append(i)\n ansC.append(cur)\n for v in ansC:\n print(v+1)\n return",
"def examC():\n N, L = LI()\n A = LI(); cur = -1\n ans = \"Impossible\"\n for i in range(N-1):\n if A[i]+A[i+1]>=L:\n ans = \"Possible\"\n cur = i\n break\n print(ans)\n if cur==-1:\n return\n ansC = []\n for i in range(cur):\n ansC.append(i)\n for i in range(N-2,cur,-1):\n ansC.append(i)\n ansC.append(cur)\n for v in ansC:\n print(v+1)\n return",
"examC"
] | def examA():
a, b = LI()
if a>0:
ans = "Positive"
print(ans)
return
if b>=0:
ans = "Zero"
else:
judge = b-a
if judge%2==1:
ans = "Positive"
else:
ans = "Negative"
print(ans)
return
def examB():
N, M = LI()
boal = [1]*N
d = defaultdict(bool)
d[0] = True
for _ in range(M):
x,y = LI()
boal[x-1] -=1
boal[y-1] +=1
if d[x-1]:
d[y-1] = True
if boal[x-1]==0:
d[x-1] = False
ans = sum(d.values())
print(ans)
return
def examC():
N, L = LI()
A = LI(); cur = -1
ans = "Impossible"
for i in range(N-1):
if A[i]+A[i+1]>=L:
ans = "Possible"
cur = i
break
print(ans)
if cur==-1:
return
ansC = []
for i in range(cur):
ansC.append(i)
for i in range(N-2,cur,-1):
ansC.append(i)
ansC.append(cur)
for v in ansC:
print(v+1)
return
import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')
if __name__ == '__main__':
examC()
|
[
7,
15,
15,
13,
13,
13,
13,
13,
13,
13,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
17,
17,
12,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
0,
13,
2,
13,
17,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
109,
19
],
[
124,
24
],
[
112,
31
],
[
139,
40
],
[
137,
42
],
[
139,
43
],
[
127,
45
],
[
137,
47
],
[
121,
49
],
[
53,
52
],
[
134,
56
],
[
128,
62
],
[
52,
63
],
[
128,
65
],
[
52,
67
],
[
140,
69
],
[
118,
71
],
[
130,
74
],
[
52,
76
],
[
119,
80
],
[
122,
80
],
[
90,
89
],
[
131,
93
],
[
89,
96
],
[
99,
98
],
[
131,
103
],
[
134,
104
],
[
98,
107
],
[
109,
110
],
[
112,
113
],
[
118,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
139,
134
],
[
139,
140
]
] | [
"from collections import defaultdict,deque\nimport sys,heapq,bisect,math,itertools,string,queue,datetime\nsys.setrecursionlimit(10**8)\nINF = float('inf')\nmod = 10**9+7\neps = 10**-7\ndef inpl(): return list(map(int, input().split()))\ndef inpl_s(): return list(input().split())\n\nN,L = inpl()\naa = inpl()\ntmp = 0\nfor i in range(N-1):\n\tif aa[i] + aa[i+1] >= L:\n\t\ttmp += 1\n\t\tind = i+1\n\nif tmp == 0:\n\tprint('Impossible')\nelse:\n\tprint('Possible')\n\tfor i in range(1,ind):\n\t\tprint(i)\n\tfor i in reversed(range(ind,N)):\n\t\tprint(i)",
"from collections import defaultdict,deque",
"import sys,heapq,bisect,math,itertools,string,queue,datetime",
"sys",
"heapq",
"bisect",
"math",
"itertools",
"string",
"queue",
"datetime",
"sys.setrecursionlimit(10**8)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**8",
"10",
"8",
"INF = float('inf')",
"INF",
"float('inf')",
"float",
"'inf'",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"eps = 10**-7",
"eps",
"10**-7",
"10",
"-7",
"def inpl(): return list(map(int, input().split()))",
"inpl",
"def inpl_s(): return list(input().split())",
"inpl_s",
"N,L = inpl()",
"N",
"inpl()",
"inpl",
"L",
"aa = inpl()",
"aa",
"inpl()",
"inpl",
"tmp = 0",
"tmp",
"0",
"for i in range(N-1):\n\tif aa[i] + aa[i+1] >= L:\n\t\ttmp += 1\n\t\tind = i+1",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if aa[i] + aa[i+1] >= L:\n\t\ttmp += 1\n\t\tind = i+1",
"aa[i] + aa[i+1] >= L",
"aa[i] + aa[i+1]",
"aa[i]",
"aa",
"i",
"aa[i+1]",
"aa",
"i+1",
"i",
"1",
"L",
"tmp += 1",
"tmp",
"1",
"ind = i+1",
"ind",
"i+1",
"i",
"1",
"if tmp == 0:\n\tprint('Impossible')\nelse:\n\tprint('Possible')\n\tfor i in range(1,ind):\n\t\tprint(i)\n\tfor i in reversed(range(ind,N)):\n\t\tprint(i)",
"tmp == 0",
"tmp",
"0",
"print('Impossible')",
"print",
"'Impossible'",
"print('Possible')",
"print",
"'Possible'",
"for i in range(1,ind):\n\t\tprint(i)\n\t",
"i",
"range(1,ind)",
"range",
"1",
"ind",
"print(i)",
"print",
"i",
"for i in reversed(range(ind,N)):\n\t\tprint(i)",
"i",
"reversed(range(ind,N))",
"reversed",
"range(ind,N)",
"range",
"ind",
"N",
"print(i)",
"print",
"i",
"INF = float('inf')",
"float('inf')",
"INF",
"eps = 10**-7",
"10**-7",
"eps",
"def inpl_s(): return list(input().split())",
"def inpl_s(): return list(input().split())",
"inpl_s",
"tmp += 1",
"1",
"tmp",
"tmp = 0",
"0",
"tmp",
"mod = 10**9+7",
"10**9+7",
"mod",
"aa = inpl()",
"inpl()",
"aa",
"ind = i+1",
"i+1",
"ind",
"N,L = inpl()",
"inpl()",
"N",
"def inpl(): return list(map(int, input().split()))",
"def inpl(): return list(map(int, input().split()))",
"inpl",
"L = inpl()",
"inpl()",
"L"
] | from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())
N,L = inpl()
aa = inpl()
tmp = 0
for i in range(N-1):
if aa[i] + aa[i+1] >= L:
tmp += 1
ind = i+1
if tmp == 0:
print('Impossible')
else:
print('Possible')
for i in range(1,ind):
print(i)
for i in reversed(range(ind,N)):
print(i)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
2,
13,
17,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
93,
2
],
[
93,
11
],
[
96,
13
],
[
87,
25
],
[
29,
28
],
[
91,
32
],
[
97,
38
],
[
28,
39
],
[
97,
41
],
[
28,
43
],
[
94,
45
],
[
99,
47
],
[
28,
48
],
[
100,
52
],
[
88,
52
],
[
62,
61
],
[
100,
64
],
[
88,
64
],
[
61,
68
],
[
72,
71
],
[
91,
75
],
[
100,
78
],
[
88,
78
],
[
71,
84
],
[
87,
88
],
[
93,
91
],
[
93,
94
],
[
96,
97
],
[
28,
99
],
[
99,
100
]
] | [
"n, l = map(int,input().split())\nA = list(map(int,input().split()))\n\nlast = -1\nfor i in range(n-1):\n if A[i] + A[i+1] >= l:\n last = i\n break\n\nif last == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(last):\n print(i+1)\n for i in range(n-2, last-1, -1):\n print(i+1)",
"n, l = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"last = -1",
"last",
"-1",
"for i in range(n-1):\n if A[i] + A[i+1] >= l:\n last = i\n break",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if A[i] + A[i+1] >= l:\n last = i\n break",
"A[i] + A[i+1] >= l",
"A[i] + A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"l",
"last = i",
"last",
"i",
"break",
"if last == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(last):\n print(i+1)\n for i in range(n-2, last-1, -1):\n print(i+1)",
"last == -1",
"last",
"-1",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(last):\n print(i+1)\n ",
"i",
"range(last)",
"range",
"last",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for i in range(n-2, last-1, -1):\n print(i+1)",
"i",
"range(n-2, last-1, -1)",
"range",
"n-2",
"n",
"2",
"last-1",
"last",
"1",
"-1",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"last = -1",
"-1",
"last",
"n, l = map(int,input().split())",
"map(int,input().split())",
"n",
"l = map(int,input().split())",
"map(int,input().split())",
"l",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"last = i",
"i",
"last"
] | n, l = map(int,input().split())
A = list(map(int,input().split()))
last = -1
for i in range(n-1):
if A[i] + A[i+1] >= l:
last = i
break
if last == -1:
print("Impossible")
else:
print("Possible")
for i in range(last):
print(i+1)
for i in range(n-2, last-1, -1):
print(i+1)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
13,
31,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
13,
2,
13,
17,
3,
14,
13,
4,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
79,
2
],
[
79,
15
],
[
79,
16
],
[
73,
19
],
[
23,
22
],
[
80,
26
],
[
22,
33
],
[
22,
37
],
[
77,
39
],
[
70,
41
],
[
22,
42
],
[
82,
43
],
[
22,
45
],
[
55,
54
],
[
71,
57
],
[
60,
59
],
[
80,
63
],
[
71,
66
],
[
22,
70
],
[
70,
71
],
[
73,
74
],
[
79,
77
],
[
79,
80
],
[
82,
83
]
] | [
"n, L, *a = map(int, open(0).read().split())\n\ncant = 0\nfor i in range(n-1):\n if a[i]+a[i+1]>=L:\n l, r = i, i+1\n break\nelse: cant = 1\n\nif cant: print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(l): print(i+1)\n for i in range(n-2, l-1, -1): print(i+1)",
"n, L, *a = map(int, open(0).read().split())",
"n",
"map(int, open(0).read().split())",
"map",
"int",
"open(0).read().split()",
"(0).read().split",
"(0).read()",
"(0).read",
"(0)",
"open",
"0",
"read",
"split",
"L",
"*a",
"a",
"cant = 0",
"cant",
"0",
"for i in range(n-1):\n if a[i]+a[i+1]>=L:\n l, r = i, i+1\n break\nelse: cant = 1",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1]>=L:\n l, r = i, i+1\n break",
"a[i]+a[i+1]>=L",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"L",
"l, r = i, i+1",
"l",
"i",
"r",
"i+1",
"i",
"1",
"break",
"if cant: print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(l): print(i+1)\n for i in range(n-2, l-1, -1): print(i+1)",
"cant",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(l): print(i+1)\n ",
"i",
"range(l)",
"range",
"l",
"for i in range(n-2, l-1, -1): print(i+1)",
"i",
"range(n-2, l-1, -1)",
"range",
"n-2",
"n",
"2",
"l-1",
"l",
"1",
"-1",
"l, r = i, i+1",
"i",
"l",
"cant = 0",
"0",
"cant",
"L, *a = map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"L",
"n, L, *a = map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"n",
"r = i, i+1",
"i+1",
"r"
] | n, L, *a = map(int, open(0).read().split())
cant = 0
for i in range(n-1):
if a[i]+a[i+1]>=L:
l, r = i, i+1
break
else: cant = 1
if cant: print("Impossible")
else:
print("Possible")
for i in range(l): print(i+1)
for i in range(n-2, l-1, -1): print(i+1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
39,
13,
2,
13,
17,
0,
13,
17,
3,
14,
13,
4,
13,
17,
28,
13,
4,
13,
18,
13,
17,
4,
13,
2,
13,
17,
0,
13,
39,
28,
13,
4,
13,
2,
18,
13,
17,
17,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
28,
13,
13,
4,
13,
13,
4,
13,
18,
13,
17,
4,
13,
17,
10,
4,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
17,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13
] | [
[
135,
2
],
[
135,
11
],
[
123,
13
],
[
126,
25
],
[
117,
28
],
[
32,
31
],
[
136,
35
],
[
124,
41
],
[
31,
42
],
[
124,
44
],
[
31,
46
],
[
115,
48
],
[
120,
50
],
[
31,
54
],
[
132,
57
],
[
67,
66
],
[
121,
70
],
[
127,
70
],
[
66,
75
],
[
129,
78
],
[
82,
81
],
[
121,
86
],
[
127,
86
],
[
136,
89
],
[
130,
92
],
[
81,
94
],
[
130,
97
],
[
101,
100
],
[
130,
100
],
[
100,
104
],
[
121,
108
],
[
127,
108
],
[
135,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
],
[
126,
127
],
[
129,
130
],
[
132,
133
],
[
135,
136
]
] | [
"n,l = map(int,input().split())\narr = list(map(int,input().split()))\n\nkey = 0\nflag = False\nfor i in range(n-1):\n if arr[i] + arr[i+1] >= l:\n key = [i,i+1]\n flag = True\n break\n\n# print(key)\nif flag:\n print(\"Possible\")\n for i in range(key[0]):\n print(i+1)\n temp = []\n for i in range(key[1]+1,n):\n temp.append(i)\n temp.reverse()\n for t in temp:\n print(t)\n print(key[1])\n\nelse:\n print(\"Impossible\")\n\n",
"n,l = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"arr = list(map(int,input().split()))",
"arr",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"key = 0",
"key",
"0",
"flag = False",
"flag",
"False",
"for i in range(n-1):\n if arr[i] + arr[i+1] >= l:\n key = [i,i+1]\n flag = True\n break\n\n# print(key)",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if arr[i] + arr[i+1] >= l:\n key = [i,i+1]\n flag = True\n break\n\n# print(key)",
"arr[i] + arr[i+1] >= l",
"arr[i] + arr[i+1]",
"arr[i]",
"arr",
"i",
"arr[i+1]",
"arr",
"i+1",
"i",
"1",
"l",
"key = [i,i+1]",
"key",
"[i,i+1]",
"i",
"i+1",
"i",
"1",
"flag = True",
"flag",
"True",
"break",
"if flag:\n print(\"Possible\")\n for i in range(key[0]):\n print(i+1)\n temp = []\n for i in range(key[1]+1,n):\n temp.append(i)\n temp.reverse()\n for t in temp:\n print(t)\n print(key[1])\n\nelse:\n print(\"Impossible\")",
"flag",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(key[0]):\n print(i+1)\n ",
"i",
"range(key[0])",
"range",
"key[0]",
"key",
"0",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"temp = []",
"temp",
"[]",
"for i in range(key[1]+1,n):\n temp.append(i)\n ",
"i",
"range(key[1]+1,n)",
"range",
"key[1]+1",
"key[1]",
"key",
"1",
"1",
"n",
"temp.append(i)",
"temp.append",
"temp",
"append",
"i",
"temp.reverse()",
"temp.reverse",
"temp",
"reverse",
"for t in temp:\n print(t)\n ",
"t",
"temp",
"print(t)",
"print",
"t",
"print(key[1])",
"print",
"key[1]",
"key",
"1",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"l = map(int,input().split())",
"map(int,input().split())",
"l",
"flag = False",
"False",
"flag",
"key = [i,i+1]",
"[i,i+1]",
"key",
"arr = list(map(int,input().split()))",
"list(map(int,input().split()))",
"arr",
"key = 0",
"0",
"key",
"temp = []",
"[]",
"temp",
"flag = True",
"True",
"flag",
"n,l = map(int,input().split())",
"map(int,input().split())",
"n"
] | n,l = map(int,input().split())
arr = list(map(int,input().split()))
key = 0
flag = False
for i in range(n-1):
if arr[i] + arr[i+1] >= l:
key = [i,i+1]
flag = True
break
# print(key)
if flag:
print("Possible")
for i in range(key[0]):
print(i+1)
temp = []
for i in range(key[1]+1,n):
temp.append(i)
temp.reverse()
for t in temp:
print(t)
print(key[1])
else:
print("Impossible")
|
[
7,
15,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
13,
14,
40,
13,
13,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
18,
4,
13,
2,
13,
17,
2,
13,
17,
39,
17,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13
] | [
[
120,
9
],
[
120,
18
],
[
123,
20
],
[
111,
32
],
[
126,
35
],
[
39,
38
],
[
121,
42
],
[
124,
48
],
[
38,
49
],
[
124,
51
],
[
38,
53
],
[
112,
55
],
[
118,
55
],
[
117,
57
],
[
124,
60
],
[
38,
61
],
[
124,
63
],
[
38,
65
],
[
129,
68
],
[
38,
69
],
[
118,
72
],
[
112,
72
],
[
115,
73
],
[
79,
78
],
[
130,
81
],
[
127,
81
],
[
78,
85
],
[
89,
88
],
[
130,
93
],
[
127,
93
],
[
121,
96
],
[
88,
103
],
[
130,
108
],
[
127,
108
],
[
111,
112
],
[
120,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
],
[
126,
127
],
[
38,
129
],
[
129,
130
]
] | [
"import sys\nsys.setrecursionlimit(200000)\nn,l=map(int,input().split())\nr=list(map(int,input().split()))\nlast=0;tiepoint=0\nfor i in range(n-1):\n if r[i]+r[i+1]>last:\n last=r[i]+r[i+1]\n tiepoint=i\nif last>=l:\n print(\"Possible\")\n for i in range(tiepoint):\n print(i+1)\n for i in range(tiepoint+1,n-1)[::-1]:\n print(i+1)\n print(tiepoint+1)\nelse:print(\"Impossible\")",
"import sys",
"sys",
"sys.setrecursionlimit(200000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"200000",
"n,l=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"r=list(map(int,input().split()))",
"r",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"last=0",
"last",
"0",
"tiepoint=0",
"tiepoint",
"0",
"for i in range(n-1):\n if r[i]+r[i+1]>last:\n last=r[i]+r[i+1]\n tiepoint=i",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if r[i]+r[i+1]>last:\n last=r[i]+r[i+1]\n tiepoint=i",
"r[i]+r[i+1]>last",
"r[i]+r[i+1]",
"r[i]",
"r",
"i",
"r[i+1]",
"r",
"i+1",
"i",
"1",
"last",
"last=r[i]+r[i+1]",
"last",
"r[i]+r[i+1]",
"r[i]",
"r",
"i",
"r[i+1]",
"r",
"i+1",
"i",
"1",
"tiepoint=i",
"tiepoint",
"i",
"if last>=l:\n print(\"Possible\")\n for i in range(tiepoint):\n print(i+1)\n for i in range(tiepoint+1,n-1)[::-1]:\n print(i+1)\n print(tiepoint+1)\nelse:print(\"Impossible\")",
"last>=l",
"last",
"l",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(tiepoint):\n print(i+1)\n ",
"i",
"range(tiepoint)",
"range",
"tiepoint",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for i in range(tiepoint+1,n-1)[::-1]:\n print(i+1)\n ",
"i",
"range(tiepoint+1,n-1)[::-1]",
"(tiepoint+1,n-1)",
"range",
"tiepoint+1",
"tiepoint",
"1",
"n-1",
"n",
"1",
"::-1",
"-1",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"print(tiepoint+1)",
"print",
"tiepoint+1",
"tiepoint",
"1",
"last=0",
"0",
"last",
"l=map(int,input().split())",
"map(int,input().split())",
"l",
"last=r[i]+r[i+1]",
"r[i]+r[i+1]",
"last",
"n,l=map(int,input().split())",
"map(int,input().split())",
"n",
"r=list(map(int,input().split()))",
"list(map(int,input().split()))",
"r",
"tiepoint=0",
"0",
"tiepoint",
"tiepoint=i",
"i",
"tiepoint"
] | import sys
sys.setrecursionlimit(200000)
n,l=map(int,input().split())
r=list(map(int,input().split()))
last=0;tiepoint=0
for i in range(n-1):
if r[i]+r[i+1]>last:
last=r[i]+r[i+1]
tiepoint=i
if last>=l:
print("Possible")
for i in range(tiepoint):
print(i+1)
for i in range(tiepoint+1,n-1)[::-1]:
print(i+1)
print(tiepoint+1)
else:print("Impossible")
|
[
7,
15,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
12,
13,
23,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
14,
2,
13,
17,
4,
13,
17,
4,
13,
4,
13,
17,
0,
13,
39,
28,
13,
4,
13,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
18,
13,
13,
13,
4,
18,
13,
13,
13,
28,
13,
13,
4,
13,
2,
13,
17,
10,
12,
13,
10,
4,
13,
10,
39,
13,
10,
13,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13
] | [
[
132,
4
],
[
15,
15
],
[
135,
17
],
[
133,
24
],
[
135,
26
],
[
129,
28
],
[
133,
37
],
[
138,
40
],
[
44,
43
],
[
136,
47
],
[
130,
53
],
[
43,
54
],
[
130,
56
],
[
43,
58
],
[
121,
60
],
[
126,
62
],
[
43,
63
],
[
127,
66
],
[
139,
66
],
[
123,
77
],
[
81,
80
],
[
127,
83
],
[
139,
83
],
[
124,
86
],
[
80,
88
],
[
91,
90
],
[
136,
94
],
[
127,
96
],
[
139,
96
],
[
124,
100
],
[
90,
102
],
[
124,
105
],
[
127,
107
],
[
139,
107
],
[
110,
109
],
[
124,
109
],
[
109,
114
],
[
135,
121
],
[
123,
124
],
[
43,
126
],
[
126,
127
],
[
129,
130
],
[
132,
133
],
[
135,
136
],
[
138,
139
]
] | [
"import sys\nreadline = sys.stdin.buffer.readline\ndef even(n): return 1 if n%2==0 else 0\n\nn,l = map(int,readline().split())\nlst1 = list(map(int,readline().split()))\n\nres = -1\n\nfor i in range(n-1):\n if lst1[i]+lst1[i+1] >= l:\n res = i\n\nif res == -1:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")\n\nans = []\nfor i in range(res):\n ans.append(i)\nfor j in range(n-2,res,-1):\n ans.append(j)\nans.append(res)\n\nfor i in ans:\n print(i+1)",
"import sys",
"sys",
"readline = sys.stdin.buffer.readline",
"readline",
"sys.stdin.buffer.readline",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readline",
"def even(n): return 1 if n%2==0 else 0",
"even",
"n",
"n",
"n,l = map(int,readline().split())",
"n",
"map(int,readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"l",
"lst1 = list(map(int,readline().split()))",
"lst1",
"list(map(int,readline().split()))",
"list",
"map(int,readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"res = -1",
"res",
"-1",
"for i in range(n-1):\n if lst1[i]+lst1[i+1] >= l:\n res = i",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if lst1[i]+lst1[i+1] >= l:\n res = i",
"lst1[i]+lst1[i+1] >= l",
"lst1[i]+lst1[i+1]",
"lst1[i]",
"lst1",
"i",
"lst1[i+1]",
"lst1",
"i+1",
"i",
"1",
"l",
"res = i",
"res",
"i",
"if res == -1:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")",
"res == -1",
"res",
"-1",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"exit()",
"exit",
"print(\"Possible\")",
"print",
"\"Possible\"",
"ans = []",
"ans",
"[]",
"for i in range(res):\n ans.append(i)",
"i",
"range(res)",
"range",
"res",
"ans.append(i)",
"ans.append",
"ans",
"append",
"i",
"for j in range(n-2,res,-1):\n ans.append(j)",
"j",
"range(n-2,res,-1)",
"range",
"n-2",
"n",
"2",
"res",
"-1",
"ans.append(j)",
"ans.append",
"ans",
"append",
"j",
"ans.append(res)",
"ans.append",
"ans",
"append",
"res",
"for i in ans:\n print(i+1)",
"i",
"ans",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"def even(n): return 1 if n%2==0 else 0",
"def even(n): return 1 if n%2==0 else 0",
"even",
"l = map(int,readline().split())",
"map(int,readline().split())",
"l",
"ans = []",
"[]",
"ans",
"res = i",
"i",
"res",
"lst1 = list(map(int,readline().split()))",
"list(map(int,readline().split()))",
"lst1",
"readline = sys.stdin.buffer.readline",
"sys.stdin.buffer.readline",
"readline",
"n,l = map(int,readline().split())",
"map(int,readline().split())",
"n",
"res = -1",
"-1",
"res"
] | import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
n,l = map(int,readline().split())
lst1 = list(map(int,readline().split()))
res = -1
for i in range(n-1):
if lst1[i]+lst1[i+1] >= l:
res = i
if res == -1:
print("Impossible")
exit()
else:
print("Possible")
ans = []
for i in range(res):
ans.append(i)
for j in range(n-2,res,-1):
ans.append(j)
ans.append(res)
for i in ans:
print(i+1)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
13,
31,
13,
28,
13,
39,
13,
13,
4,
13,
4,
13,
13,
18,
13,
39,
17,
14,
40,
2,
13,
13,
13,
4,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
13,
4,
18,
17,
13,
4,
13,
13,
2,
18,
13,
39,
17,
2,
13,
17,
18,
13,
39,
13,
13,
17,
4,
13,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
83,
2
],
[
83,
15
],
[
83,
16
],
[
81,
37
],
[
77,
42
],
[
84,
47
],
[
78,
59
],
[
78,
66
],
[
77,
78
],
[
83,
81
],
[
83,
84
]
] | [
"n,l,*a=map(int,open(0).read().split())\nfor i,(x,y) in enumerate(zip(a,a[1:])):\n\tif x+y>=l:\n\t\tprint(\"Possible\")\n\t\tr=list(range(n))\n\t\tprint(\"\\n\".join(map(str,r[1:i+1]+r[n:i:-1])))\n\t\texit()\nprint(\"Impossible\")",
"n,l,*a=map(int,open(0).read().split())",
"n",
"map(int,open(0).read().split())",
"map",
"int",
"open(0).read().split()",
"(0).read().split",
"(0).read()",
"(0).read",
"(0)",
"open",
"0",
"read",
"split",
"l",
"*a",
"a",
"for i,(x,y) in enumerate(zip(a,a[1:])):\n\tif x+y>=l:\n\t\tprint(\"Possible\")\n\t\tr=list(range(n))\n\t\tprint(\"\\n\".join(map(str,r[1:i+1]+r[n:i:-1])))\n\t\texit()",
"i",
"(x,y)",
"x",
"y",
"enumerate(zip(a,a[1:]))",
"enumerate",
"zip(a,a[1:])",
"zip",
"a",
"a[1:]",
"a",
"1:",
"1",
"if x+y>=l:\n\t\tprint(\"Possible\")\n\t\tr=list(range(n))\n\t\tprint(\"\\n\".join(map(str,r[1:i+1]+r[n:i:-1])))\n\t\texit()",
"x+y>=l",
"x+y",
"x",
"y",
"l",
"print(\"Possible\")",
"print",
"\"Possible\"",
"r=list(range(n))",
"r",
"list(range(n))",
"list",
"range(n)",
"range",
"n",
"print(\"\\n\".join(map(str,r[1:i+1]+r[n:i:-1])))",
"print",
"\"\\n\".join(map(str,r[1:i+1]+r[n:i:-1]))",
"\"\\n\".join",
"\"\\n\"",
"join",
"map(str,r[1:i+1]+r[n:i:-1])",
"map",
"str",
"r[1:i+1]+r[n:i:-1]",
"r[1:i+1]",
"r",
"1:i+1",
"1",
"i+1",
"i",
"1",
"r[n:i:-1]",
"r",
"n:i:-1",
"n",
"i",
"-1",
"exit()",
"exit",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"r=list(range(n))",
"list(range(n))",
"r",
"l,*a=map(int,open(0).read().split())",
"map(int,open(0).read().split())",
"l",
"n,l,*a=map(int,open(0).read().split())",
"map(int,open(0).read().split())",
"n"
] | n,l,*a=map(int,open(0).read().split())
for i,(x,y) in enumerate(zip(a,a[1:])):
if x+y>=l:
print("Possible")
r=list(range(n))
print("\n".join(map(str,r[1:i+1]+r[n:i:-1])))
exit()
print("Impossible") |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
0,
13,
2,
13,
17,
3,
14,
13,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
13,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13
] | [
[
109,
2
],
[
109,
11
],
[
94,
13
],
[
100,
25
],
[
103,
28
],
[
32,
31
],
[
92,
35
],
[
95,
41
],
[
31,
42
],
[
95,
44
],
[
31,
46
],
[
110,
48
],
[
97,
50
],
[
106,
53
],
[
31,
55
],
[
65,
64
],
[
107,
68
],
[
104,
68
],
[
64,
71
],
[
74,
73
],
[
92,
77
],
[
107,
79
],
[
104,
79
],
[
73,
83
],
[
107,
86
],
[
104,
86
],
[
109,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
]
] | [
"n,l = map(int,input().split())\nL = list(map(int,input().split()))\nflag = False\ncur = 0\nfor i in range(n-1):\n if L[i]+L[i+1] >= l:\n flag = True\n cur = i+1\n break\nif flag:\n print('Possible')\n for i in range(1,cur):\n print(i)\n for i in range(n-1,cur,-1):\n print(i)\n print(cur)\nelse:\n print('Impossible')",
"n,l = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"L = list(map(int,input().split()))",
"L",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"flag = False",
"flag",
"False",
"cur = 0",
"cur",
"0",
"for i in range(n-1):\n if L[i]+L[i+1] >= l:\n flag = True\n cur = i+1\n break",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if L[i]+L[i+1] >= l:\n flag = True\n cur = i+1\n break",
"L[i]+L[i+1] >= l",
"L[i]+L[i+1]",
"L[i]",
"L",
"i",
"L[i+1]",
"L",
"i+1",
"i",
"1",
"l",
"flag = True",
"flag",
"True",
"cur = i+1",
"cur",
"i+1",
"i",
"1",
"break",
"if flag:\n print('Possible')\n for i in range(1,cur):\n print(i)\n for i in range(n-1,cur,-1):\n print(i)\n print(cur)\nelse:\n print('Impossible')",
"flag",
"print('Possible')",
"print",
"'Possible'",
"for i in range(1,cur):\n print(i)\n ",
"i",
"range(1,cur)",
"range",
"1",
"cur",
"print(i)",
"print",
"i",
"for i in range(n-1,cur,-1):\n print(i)\n ",
"i",
"range(n-1,cur,-1)",
"range",
"n-1",
"n",
"1",
"cur",
"-1",
"print(i)",
"print",
"i",
"print(cur)",
"print",
"cur",
"print('Impossible')",
"print",
"'Impossible'",
"n,l = map(int,input().split())",
"map(int,input().split())",
"n",
"L = list(map(int,input().split()))",
"list(map(int,input().split()))",
"L",
"flag = True",
"True",
"flag",
"flag = False",
"False",
"flag",
"cur = 0",
"0",
"cur",
"cur = i+1",
"i+1",
"cur",
"l = map(int,input().split())",
"map(int,input().split())",
"l"
] | n,l = map(int,input().split())
L = list(map(int,input().split()))
flag = False
cur = 0
for i in range(n-1):
if L[i]+L[i+1] >= l:
flag = True
cur = i+1
break
if flag:
print('Possible')
for i in range(1,cur):
print(i)
for i in range(n-1,cur,-1):
print(i)
print(cur)
else:
print('Impossible') |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
13,
31,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
14,
40,
13,
17,
4,
13,
17,
28,
13,
18,
4,
13,
2,
13,
17,
2,
13,
17,
39,
17,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
4,
13,
17,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13
] | [
[
90,
2
],
[
90,
15
],
[
90,
16
],
[
93,
19
],
[
23,
22
],
[
91,
26
],
[
22,
33
],
[
22,
37
],
[
85,
39
],
[
87,
41
],
[
22,
42
],
[
88,
45
],
[
94,
45
],
[
52,
51
],
[
88,
56
],
[
94,
56
],
[
91,
59
],
[
51,
66
],
[
70,
69
],
[
88,
73
],
[
94,
73
],
[
69,
78
],
[
90,
85
],
[
22,
87
],
[
87,
88
],
[
90,
91
],
[
93,
94
]
] | [
"N,L,*A=map(int,open(0).read().split())\nk=-1\nfor i in range(N-1):\n\tif A[i]+A[i+1]>=L:\n\t\tk=i\nif k>=0:\n\tprint('Possible')\n\tfor i in range(k+1,N-1)[::-1]:\n\t\tprint(i+1)\n\tfor i in range(k+1):\n\t\tprint(i+1)\nelse:\n\tprint('Impossible')",
"N,L,*A=map(int,open(0).read().split())",
"N",
"map(int,open(0).read().split())",
"map",
"int",
"open(0).read().split()",
"(0).read().split",
"(0).read()",
"(0).read",
"(0)",
"open",
"0",
"read",
"split",
"L",
"*A",
"A",
"k=-1",
"k",
"-1",
"for i in range(N-1):\n\tif A[i]+A[i+1]>=L:\n\t\tk=i",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i]+A[i+1]>=L:\n\t\tk=i",
"A[i]+A[i+1]>=L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"k=i",
"k",
"i",
"if k>=0:\n\tprint('Possible')\n\tfor i in range(k+1,N-1)[::-1]:\n\t\tprint(i+1)\n\tfor i in range(k+1):\n\t\tprint(i+1)\nelse:\n\tprint('Impossible')",
"k>=0",
"k",
"0",
"print('Possible')",
"print",
"'Possible'",
"for i in range(k+1,N-1)[::-1]:\n\t\tprint(i+1)\n\t",
"i",
"range(k+1,N-1)[::-1]",
"(k+1,N-1)",
"range",
"k+1",
"k",
"1",
"N-1",
"N",
"1",
"::-1",
"-1",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for i in range(k+1):\n\t\tprint(i+1)",
"i",
"range(k+1)",
"range",
"k+1",
"k",
"1",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"print('Impossible')",
"print",
"'Impossible'",
"L,*A=map(int,open(0).read().split())",
"map(int,open(0).read().split())",
"L",
"k=i",
"i",
"k",
"N,L,*A=map(int,open(0).read().split())",
"map(int,open(0).read().split())",
"N",
"k=-1",
"-1",
"k"
] | N,L,*A=map(int,open(0).read().split())
k=-1
for i in range(N-1):
if A[i]+A[i+1]>=L:
k=i
if k>=0:
print('Possible')
for i in range(k+1,N-1)[::-1]:
print(i+1)
for i in range(k+1):
print(i+1)
else:
print('Impossible')
|
[
7,
12,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
3,
14,
40,
13,
4,
13,
17,
29,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
4,
13,
4,
13,
2,
13,
17,
13,
4,
13,
13,
4,
13,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
6,
5
],
[
5,
14
],
[
17,
16
],
[
17,
18
],
[
22,
21
],
[
21,
30
],
[
33,
32
],
[
36,
35
],
[
39,
38
],
[
16,
42
],
[
32,
48
],
[
38,
49
],
[
32,
51
],
[
38,
53
],
[
18,
55
],
[
58,
57
],
[
57,
62
],
[
35,
62
],
[
72,
71
],
[
71,
80
],
[
83,
82
],
[
16,
90
],
[
82,
93
],
[
103,
100
]
] | [
"def main():\n N,L = [int(n) for n in input().split()]\n A = [int(n) for n in input().split()]\n flg = False\n for i in range(N-1):\n if(A[i]+A[i+1] >= L):\n flg = True\n break\n if not flg:\n print(\"Impossible\")\n return\n print(\"Possible\")\n for j in range(1,i+1):\n print(j)\n for j in reversed(range(i+2,N)):\n print(j)\n print(i+1)\nmain()",
"def main():\n N,L = [int(n) for n in input().split()]\n A = [int(n) for n in input().split()]\n flg = False\n for i in range(N-1):\n if(A[i]+A[i+1] >= L):\n flg = True\n break\n if not flg:\n print(\"Impossible\")\n return\n print(\"Possible\")\n for j in range(1,i+1):\n print(j)\n for j in reversed(range(i+2,N)):\n print(j)\n print(i+1)",
"main",
"int(n) for n in input().split()",
"for n in input().split()",
"n",
"input().split()",
"().split",
"()",
"input",
"split",
"for n in input().split()",
"int(n)",
"int",
"n",
"N,L = [int(n) for n in input().split()]",
"N",
"[int(n) for n in input().split()]",
"L",
"int(n) for n in input().split()",
"for n in input().split()",
"n",
"input().split()",
"().split",
"()",
"input",
"split",
"for n in input().split()",
"int(n)",
"int",
"n",
"A = [int(n) for n in input().split()]",
"A",
"[int(n) for n in input().split()]",
"flg = False",
"flg",
"False",
"for i in range(N-1):\n if(A[i]+A[i+1] >= L):\n flg = True\n break\n ",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if(A[i]+A[i+1] >= L):\n flg = True\n break\n ",
"A[i]+A[i+1] >= L",
"A[i]+A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"L",
"flg = True",
"flg",
"True",
"break",
"if not flg:\n print(\"Impossible\")\n return\n ",
"not flg",
"flg",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"return",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for j in range(1,i+1):\n print(j)\n ",
"j",
"range(1,i+1)",
"range",
"1",
"i+1",
"i",
"1",
"print(j)",
"print",
"j",
"for j in reversed(range(i+2,N)):\n print(j)\n ",
"j",
"reversed(range(i+2,N))",
"reversed",
"range(i+2,N)",
"range",
"i+2",
"i",
"2",
"N",
"print(j)",
"print",
"j",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"main()",
"main",
"def main():\n N,L = [int(n) for n in input().split()]\n A = [int(n) for n in input().split()]\n flg = False\n for i in range(N-1):\n if(A[i]+A[i+1] >= L):\n flg = True\n break\n if not flg:\n print(\"Impossible\")\n return\n print(\"Possible\")\n for j in range(1,i+1):\n print(j)\n for j in reversed(range(i+2,N)):\n print(j)\n print(i+1)",
"def main():\n N,L = [int(n) for n in input().split()]\n A = [int(n) for n in input().split()]\n flg = False\n for i in range(N-1):\n if(A[i]+A[i+1] >= L):\n flg = True\n break\n if not flg:\n print(\"Impossible\")\n return\n print(\"Possible\")\n for j in range(1,i+1):\n print(j)\n for j in reversed(range(i+2,N)):\n print(j)\n print(i+1)",
"main"
] | def main():
N,L = [int(n) for n in input().split()]
A = [int(n) for n in input().split()]
flg = False
for i in range(N-1):
if(A[i]+A[i+1] >= L):
flg = True
break
if not flg:
print("Impossible")
return
print("Possible")
for j in range(1,i+1):
print(j)
for j in reversed(range(i+2,N)):
print(j)
print(i+1)
main()
|
[
7,
15,
13,
15,
13,
12,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
17,
13,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
13,
4,
13,
4,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
9,
8
],
[
18,
17
],
[
25,
24
],
[
8,
33
],
[
25,
35
],
[
38,
37
],
[
8,
50
],
[
54,
53
],
[
24,
57
],
[
37,
62
],
[
53,
63
],
[
37,
65
],
[
53,
67
],
[
35,
69
],
[
75,
74
],
[
53,
78
],
[
74,
81
],
[
84,
83
],
[
24,
87
],
[
53,
89
],
[
83,
93
],
[
53,
96
],
[
110,
107
]
] | [
"import sys\nimport collections\n\n\ndef solve():\n readline = sys.stdin.buffer.readline\n mod = 10 ** 9 + 7\n n, l = list(map(int, readline().split()))\n a = collections.deque(list(map(int, readline().split())))\n for i in range(1, n):\n if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(n - 1, i, -1):\n print(j)\n print(i)\n exit()\n print(\"Impossible\")\n\n\nif __name__ == '__main__':\n solve()",
"import sys",
"sys",
"import collections",
"collections",
"def solve():\n readline = sys.stdin.buffer.readline\n mod = 10 ** 9 + 7\n n, l = list(map(int, readline().split()))\n a = collections.deque(list(map(int, readline().split())))\n for i in range(1, n):\n if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(n - 1, i, -1):\n print(j)\n print(i)\n exit()\n print(\"Impossible\")",
"solve",
"readline = sys.stdin.buffer.readline",
"readline",
"sys.stdin.buffer.readline",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readline",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"n, l = list(map(int, readline().split()))",
"n",
"list(map(int, readline().split()))",
"list",
"map(int, readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"l",
"a = collections.deque(list(map(int, readline().split())))",
"a",
"collections.deque(list(map(int, readline().split())))",
"collections.deque",
"collections",
"deque",
"list(map(int, readline().split()))",
"list",
"map(int, readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"for i in range(1, n):\n if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(n - 1, i, -1):\n print(j)\n print(i)\n exit()\n ",
"i",
"range(1, n)",
"range",
"1",
"n",
"if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(n - 1, i, -1):\n print(j)\n print(i)\n exit()\n ",
"a[i] + a[i-1] >= l",
"a[i] + a[i-1]",
"a[i]",
"a",
"i",
"a[i-1]",
"a",
"i-1",
"i",
"1",
"l",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for j in range(1, i):\n print(j)\n ",
"j",
"range(1, i)",
"range",
"1",
"i",
"print(j)",
"print",
"j",
"for j in range(n - 1, i, -1):\n print(j)\n ",
"j",
"range(n - 1, i, -1)",
"range",
"n - 1",
"n",
"1",
"i",
"-1",
"print(j)",
"print",
"j",
"print(i)",
"print",
"i",
"exit()",
"exit",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"if __name__ == '__main__':\n solve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"solve()",
"solve",
"def solve():\n readline = sys.stdin.buffer.readline\n mod = 10 ** 9 + 7\n n, l = list(map(int, readline().split()))\n a = collections.deque(list(map(int, readline().split())))\n for i in range(1, n):\n if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(n - 1, i, -1):\n print(j)\n print(i)\n exit()\n print(\"Impossible\")",
"def solve():\n readline = sys.stdin.buffer.readline\n mod = 10 ** 9 + 7\n n, l = list(map(int, readline().split()))\n a = collections.deque(list(map(int, readline().split())))\n for i in range(1, n):\n if a[i] + a[i-1] >= l:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(n - 1, i, -1):\n print(j)\n print(i)\n exit()\n print(\"Impossible\")",
"solve"
] | import sys
import collections
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n, l = list(map(int, readline().split()))
a = collections.deque(list(map(int, readline().split())))
for i in range(1, n):
if a[i] + a[i-1] >= l:
print("Possible")
for j in range(1, i):
print(j)
for j in range(n - 1, i, -1):
print(j)
print(i)
exit()
print("Impossible")
if __name__ == '__main__':
solve()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
13,
31,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
13,
17,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
4,
13,
2,
13,
17,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13
] | [
[
88,
2
],
[
88,
15
],
[
88,
16
],
[
85,
19
],
[
23,
22
],
[
83,
26
],
[
22,
33
],
[
22,
37
],
[
89,
39
],
[
91,
41
],
[
22,
43
],
[
92,
48
],
[
86,
48
],
[
58,
57
],
[
92,
61
],
[
86,
61
],
[
57,
64
],
[
67,
66
],
[
92,
72
],
[
86,
72
],
[
83,
74
],
[
66,
77
],
[
92,
80
],
[
86,
80
],
[
88,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
]
] | [
"N, L, *A = map(int, open(0).read().split())\n\nk = -1\nfor i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n k = i + 1\n break\n\nif k == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for j in range(1, k):\n print(j)\n for j in reversed(range(k + 1, N)):\n print(j)\n print(k)",
"N, L, *A = map(int, open(0).read().split())",
"N",
"map(int, open(0).read().split())",
"map",
"int",
"open(0).read().split()",
"(0).read().split",
"(0).read()",
"(0).read",
"(0)",
"open",
"0",
"read",
"split",
"L",
"*A",
"A",
"k = -1",
"k",
"-1",
"for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n k = i + 1\n break",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"if A[i] + A[i + 1] >= L:\n k = i + 1\n break",
"A[i] + A[i + 1] >= L",
"A[i] + A[i + 1]",
"A[i]",
"A",
"i",
"A[i + 1]",
"A",
"i + 1",
"i",
"1",
"L",
"k = i + 1",
"k",
"i + 1",
"i",
"1",
"break",
"if k == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for j in range(1, k):\n print(j)\n for j in reversed(range(k + 1, N)):\n print(j)\n print(k)",
"k == -1",
"k",
"-1",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for j in range(1, k):\n print(j)\n ",
"j",
"range(1, k)",
"range",
"1",
"k",
"print(j)",
"print",
"j",
"for j in reversed(range(k + 1, N)):\n print(j)\n ",
"j",
"reversed(range(k + 1, N))",
"reversed",
"range(k + 1, N)",
"range",
"k + 1",
"k",
"1",
"N",
"print(j)",
"print",
"j",
"print(k)",
"print",
"k",
"N, L, *A = map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"N",
"k = -1",
"-1",
"k",
"L, *A = map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"L",
"k = i + 1",
"i + 1",
"k"
] | N, L, *A = map(int, open(0).read().split())
k = -1
for i in range(N - 1):
if A[i] + A[i + 1] >= L:
k = i + 1
break
if k == -1:
print("Impossible")
else:
print("Possible")
for j in range(1, k):
print(j)
for j in reversed(range(k + 1, N)):
print(j)
print(k) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
14,
40,
13,
13,
0,
13,
13,
0,
13,
17,
3,
14,
2,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
13,
4,
13,
17,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13,
10,
17,
13
] | [
[
102,
2
],
[
102,
11
],
[
96,
13
],
[
114,
25
],
[
99,
28
],
[
32,
31
],
[
94,
35
],
[
105,
37
],
[
97,
40
],
[
31,
42
],
[
97,
45
],
[
31,
46
],
[
106,
49
],
[
103,
50
],
[
111,
52
],
[
31,
53
],
[
108,
55
],
[
109,
60
],
[
100,
60
],
[
67,
66
],
[
112,
70
],
[
115,
70
],
[
66,
73
],
[
76,
75
],
[
94,
79
],
[
112,
81
],
[
115,
81
],
[
75,
85
],
[
112,
88
],
[
115,
88
],
[
102,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
31,
111
],
[
111,
112
],
[
114,
115
]
] | [
"n,l = map(int,input().split())\nr = list(map(int,input().split()))\no = 0\nflag = 1\nfor i in range(1,n):\n lr = r[i-1] +r[i]\n if lr >= l:\n o = i\n flag = 0\n break\nif flag == 0:\n print('Possible')\n for j in range(1,o):\n print(j)\n for k in range(n-1,o,-1):\n print(k)\n print(o)\nelse:\n print('Impossible')",
"n,l = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"r = list(map(int,input().split()))",
"r",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"o = 0",
"o",
"0",
"flag = 1",
"flag",
"1",
"for i in range(1,n):\n lr = r[i-1] +r[i]\n if lr >= l:\n o = i\n flag = 0\n break",
"i",
"range(1,n)",
"range",
"1",
"n",
"lr = r[i-1] +r[i]",
"lr",
"r[i-1] +r[i]",
"r[i-1]",
"r",
"i-1",
"i",
"1",
"r[i]",
"r",
"i",
"if lr >= l:\n o = i\n flag = 0\n break",
"lr >= l",
"lr",
"l",
"o = i",
"o",
"i",
"flag = 0",
"flag",
"0",
"break",
"if flag == 0:\n print('Possible')\n for j in range(1,o):\n print(j)\n for k in range(n-1,o,-1):\n print(k)\n print(o)\nelse:\n print('Impossible')",
"flag == 0",
"flag",
"0",
"print('Possible')",
"print",
"'Possible'",
"for j in range(1,o):\n print(j)\n ",
"j",
"range(1,o)",
"range",
"1",
"o",
"print(j)",
"print",
"j",
"for k in range(n-1,o,-1):\n print(k)\n ",
"k",
"range(n-1,o,-1)",
"range",
"n-1",
"n",
"1",
"o",
"-1",
"print(k)",
"print",
"k",
"print(o)",
"print",
"o",
"print('Impossible')",
"print",
"'Impossible'",
"n,l = map(int,input().split())",
"map(int,input().split())",
"n",
"r = list(map(int,input().split()))",
"list(map(int,input().split()))",
"r",
"flag = 1",
"1",
"flag",
"l = map(int,input().split())",
"map(int,input().split())",
"l",
"lr = r[i-1] +r[i]",
"r[i-1] +r[i]",
"lr",
"flag = 0",
"0",
"flag",
"o = i",
"i",
"o",
"o = 0",
"0",
"o"
] | n,l = map(int,input().split())
r = list(map(int,input().split()))
o = 0
flag = 1
for i in range(1,n):
lr = r[i-1] +r[i]
if lr >= l:
o = i
flag = 0
break
if flag == 0:
print('Possible')
for j in range(1,o):
print(j)
for k in range(n-1,o,-1):
print(k)
print(o)
else:
print('Impossible') |
[
7,
15,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
12,
4,
13,
4,
13,
0,
13,
12,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
12,
4,
18,
4,
18,
4,
13,
13,
13,
17,
0,
13,
12,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
0,
13,
12,
13,
23,
41,
28,
13,
4,
13,
40,
13,
4,
13,
17,
4,
2,
13,
4,
13,
17,
0,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
0,
13,
12,
13,
23,
0,
13,
12,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
14,
2,
13,
13,
0,
13,
13,
0,
13,
13,
14,
40,
13,
13,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
4,
13,
17,
14,
2,
13,
17,
4,
13,
10,
18,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
18,
13,
10,
18,
13,
10,
12,
13,
10,
12,
13
] | [
[
244,
4
],
[
241,
13
],
[
217,
22
],
[
250,
31
],
[
242,
36
],
[
220,
38
],
[
242,
46
],
[
238,
49
],
[
242,
56
],
[
226,
61
],
[
242,
71
],
[
76,
75
],
[
227,
81
],
[
223,
83
],
[
90,
89
],
[
242,
91
],
[
89,
93
],
[
89,
99
],
[
235,
104
],
[
110,
109
],
[
236,
115
],
[
232,
117
],
[
247,
122
],
[
245,
130
],
[
136,
135
],
[
221,
137
],
[
136,
138
],
[
141,
140
],
[
227,
142
],
[
145,
144
],
[
148,
147
],
[
151,
150
],
[
135,
154
],
[
158,
157
],
[
140,
160
],
[
150,
161
],
[
140,
163
],
[
150,
165
],
[
144,
169
],
[
175,
169
],
[
157,
170
],
[
173,
172
],
[
150,
173
],
[
176,
175
],
[
157,
176
],
[
175,
179
],
[
144,
179
],
[
138,
180
],
[
186,
185
],
[
172,
190
],
[
147,
190
],
[
185,
194
],
[
197,
196
],
[
135,
200
],
[
172,
202
],
[
147,
202
],
[
196,
206
],
[
230,
215
],
[
217,
218
],
[
220,
221
],
[
223,
224
],
[
226,
227
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
241,
242
],
[
244,
245
],
[
247,
248
],
[
250,
251
]
] | [
"import sys\n\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\n\nin_n = lambda: int(readline())\nin_nn = lambda: map(int, readline().split())\nin_s = lambda: readline().rstrip().decode('utf-8')\nin_nl = lambda: list(map(int, readline().split()))\nin_nl2 = lambda H: [in_nl() for _ in range(H)]\nin_map = lambda: [s == ord('.') for s in readline() if s != ord('\\n')]\nin_map2 = lambda H: [in_map() for _ in range(H)]\nin_all = lambda: map(int, read().split())\n\n\ndef main():\n\n N, L = in_nn()\n A = in_nl()\n\n max_l = 0\n ind = -1\n for i in range(N - 1):\n t = A[i] + A[i + 1]\n if max_l < t:\n ind = i\n max_l = t\n\n if max_l >= L:\n print(\"Possible\")\n for i in range(1, ind + 1):\n print(i)\n for i in range(N - 1, ind, -1):\n print(i)\n else:\n print(\"Impossible\")\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"read = sys.stdin.buffer.read",
"read",
"sys.stdin.buffer.read",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"read",
"readline = sys.stdin.buffer.readline",
"readline",
"sys.stdin.buffer.readline",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readline",
"readlines = sys.stdin.buffer.readlines",
"readlines",
"sys.stdin.buffer.readlines",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readlines",
"in_n = lambda: int(readline())",
"in_n",
"lambda: int(readline())",
"int(readline())",
"int",
"readline()",
"readline",
"in_nn = lambda: map(int, readline().split())",
"in_nn",
"lambda: map(int, readline().split())",
"map(int, readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"in_s = lambda: readline().rstrip().decode('utf-8')",
"in_s",
"lambda: readline().rstrip().decode('utf-8')",
"readline().rstrip().decode('utf-8')",
"().rstrip().decode",
"().rstrip()",
"().rstrip",
"()",
"readline",
"rstrip",
"decode",
"'utf-8'",
"in_nl = lambda: list(map(int, readline().split()))",
"in_nl",
"lambda: list(map(int, readline().split()))",
"list(map(int, readline().split()))",
"list",
"map(int, readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"in_nl() for _ in range(H)",
"for _ in range(H)",
"_",
"range(H)",
"range",
"H",
"for _ in range(H)",
"in_nl()",
"in_nl",
"in_nl2 = lambda H: [in_nl() for _ in range(H)]",
"in_nl2",
"lambda H: [in_nl() for _ in range(H)]",
"[in_nl() for _ in range(H)]",
"H",
"s == ord('.') for s in readline() if s != ord('\\n')",
"for s in readline() if s != ord('\\n')",
"s",
"readline()",
"readline",
"s != ord('\\n')",
"s",
"ord('\\n')",
"ord",
"'\\n'",
"if s != ord('\\n')",
"s == ord('.')",
"s",
"ord('.')",
"ord",
"'.'",
"in_map = lambda: [s == ord('.') for s in readline() if s != ord('\\n')]",
"in_map",
"lambda: [s == ord('.') for s in readline() if s != ord('\\n')]",
"[s == ord('.') for s in readline() if s != ord('\\n')]",
"in_map() for _ in range(H)",
"for _ in range(H)",
"_",
"range(H)",
"range",
"H",
"for _ in range(H)",
"in_map()",
"in_map",
"in_map2 = lambda H: [in_map() for _ in range(H)]",
"in_map2",
"lambda H: [in_map() for _ in range(H)]",
"[in_map() for _ in range(H)]",
"H",
"in_all = lambda: map(int, read().split())",
"in_all",
"lambda: map(int, read().split())",
"map(int, read().split())",
"map",
"int",
"read().split()",
"().split",
"()",
"read",
"split",
"def main():\n\n N, L = in_nn()\n A = in_nl()\n\n max_l = 0\n ind = -1\n for i in range(N - 1):\n t = A[i] + A[i + 1]\n if max_l < t:\n ind = i\n max_l = t\n\n if max_l >= L:\n print(\"Possible\")\n for i in range(1, ind + 1):\n print(i)\n for i in range(N - 1, ind, -1):\n print(i)\n else:\n print(\"Impossible\")",
"main",
"N, L = in_nn()",
"N",
"in_nn()",
"in_nn",
"L",
"A = in_nl()",
"A",
"in_nl()",
"in_nl",
"max_l = 0",
"max_l",
"0",
"ind = -1",
"ind",
"-1",
"for i in range(N - 1):\n t = A[i] + A[i + 1]\n if max_l < t:\n ind = i\n max_l = t\n\n ",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"t = A[i] + A[i + 1]",
"t",
"A[i] + A[i + 1]",
"A[i]",
"A",
"i",
"A[i + 1]",
"A",
"i + 1",
"i",
"1",
"if max_l < t:\n ind = i\n max_l = t\n\n ",
"max_l < t",
"max_l",
"t",
"ind = i",
"ind",
"i",
"max_l = t",
"max_l",
"t",
"if max_l >= L:\n print(\"Possible\")\n for i in range(1, ind + 1):\n print(i)\n for i in range(N - 1, ind, -1):\n print(i)\n else:\n print(\"Impossible\")",
"max_l >= L",
"max_l",
"L",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(1, ind + 1):\n print(i)\n ",
"i",
"range(1, ind + 1)",
"range",
"1",
"ind + 1",
"ind",
"1",
"print(i)",
"print",
"i",
"for i in range(N - 1, ind, -1):\n print(i)\n ",
"i",
"range(N - 1, ind, -1)",
"range",
"N - 1",
"N",
"1",
"ind",
"-1",
"print(i)",
"print",
"i",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"readlines = sys.stdin.buffer.readlines",
"sys.stdin.buffer.readlines",
"readlines",
"in_nn = lambda: map(int, readline().split())",
"lambda: map(int, readline().split())",
"in_nn",
"in_nl2 = lambda H: [in_nl() for _ in range(H)]",
"lambda H: [in_nl() for _ in range(H)]",
"in_nl2",
"in_nl = lambda: list(map(int, readline().split()))",
"lambda: list(map(int, readline().split()))",
"in_nl",
"def main():\n\n N, L = in_nn()\n A = in_nl()\n\n max_l = 0\n ind = -1\n for i in range(N - 1):\n t = A[i] + A[i + 1]\n if max_l < t:\n ind = i\n max_l = t\n\n if max_l >= L:\n print(\"Possible\")\n for i in range(1, ind + 1):\n print(i)\n for i in range(N - 1, ind, -1):\n print(i)\n else:\n print(\"Impossible\")",
"def main():\n\n N, L = in_nn()\n A = in_nl()\n\n max_l = 0\n ind = -1\n for i in range(N - 1):\n t = A[i] + A[i + 1]\n if max_l < t:\n ind = i\n max_l = t\n\n if max_l >= L:\n print(\"Possible\")\n for i in range(1, ind + 1):\n print(i)\n for i in range(N - 1, ind, -1):\n print(i)\n else:\n print(\"Impossible\")",
"main",
"in_map2 = lambda H: [in_map() for _ in range(H)]",
"lambda H: [in_map() for _ in range(H)]",
"in_map2",
"in_map = lambda: [s == ord('.') for s in readline() if s != ord('\\n')]",
"lambda: [s == ord('.') for s in readline() if s != ord('\\n')]",
"in_map",
"in_s = lambda: readline().rstrip().decode('utf-8')",
"lambda: readline().rstrip().decode('utf-8')",
"in_s",
"readline = sys.stdin.buffer.readline",
"sys.stdin.buffer.readline",
"readline",
"read = sys.stdin.buffer.read",
"sys.stdin.buffer.read",
"read",
"in_all = lambda: map(int, read().split())",
"lambda: map(int, read().split())",
"in_all",
"in_n = lambda: int(readline())",
"lambda: int(readline())",
"in_n"
] | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: map(int, read().split())
def main():
N, L = in_nn()
A = in_nl()
max_l = 0
ind = -1
for i in range(N - 1):
t = A[i] + A[i + 1]
if max_l < t:
ind = i
max_l = t
if max_l >= L:
print("Possible")
for i in range(1, ind + 1):
print(i)
for i in range(N - 1, ind, -1):
print(i)
else:
print("Impossible")
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
13,
31,
13,
0,
13,
17,
28,
13,
13,
4,
13,
13,
18,
13,
39,
17,
4,
13,
17,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
41,
2
],
[
41,
15
],
[
41,
16
],
[
38,
19
],
[
41,
36
],
[
38,
39
],
[
41,
42
]
] | [
"n,l,*a=map(int,open(0).read().split())\ni=0\nfor a,b in zip(a,a[1:]):i+=1;a+b>=l>exit(print('Possible',*range(1,i),*range(n-1,i-1,-1)))\nprint('Impossible')",
"n,l,*a=map(int,open(0).read().split())",
"n",
"map(int,open(0).read().split())",
"map",
"int",
"open(0).read().split()",
"(0).read().split",
"(0).read()",
"(0).read",
"(0)",
"open",
"0",
"read",
"split",
"l",
"*a",
"a",
"i=0",
"i",
"0",
"for a,b in zip(a,a[1:]):i+=1;a+b>=l>exit(print('Possible',*range(1,i),*range(n-1,i-1,-1)))",
"a",
"b",
"zip(a,a[1:])",
"zip",
"a",
"a[1:]",
"a",
"1:",
"1",
"print('Impossible')",
"print",
"'Impossible'",
"n,l,*a=map(int,open(0).read().split())",
"map(int,open(0).read().split())",
"n",
"i=0",
"0",
"i",
"l,*a=map(int,open(0).read().split())",
"map(int,open(0).read().split())",
"l"
] | n,l,*a=map(int,open(0).read().split())
i=0
for a,b in zip(a,a[1:]):i+=1;a+b>=l>exit(print('Possible',*range(1,i),*range(n-1,i-1,-1)))
print('Impossible') |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
0,
13,
39,
28,
13,
4,
13,
13,
4,
18,
13,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
18,
13,
13,
13,
28,
13,
13,
4,
13,
4,
13,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] | [
[
119,
2
],
[
119,
11
],
[
107,
13
],
[
110,
25
],
[
29,
28
],
[
120,
32
],
[
108,
38
],
[
28,
39
],
[
108,
41
],
[
28,
43
],
[
117,
45
],
[
101,
47
],
[
113,
50
],
[
28,
51
],
[
102,
55
],
[
111,
55
],
[
104,
64
],
[
68,
67
],
[
114,
70
],
[
105,
73
],
[
67,
76
],
[
80,
79
],
[
120,
83
],
[
114,
85
],
[
105,
89
],
[
79,
91
],
[
94,
93
],
[
105,
93
],
[
93,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
28,
113
],
[
113,
114
],
[
119,
117
],
[
119,
120
]
] | [
"N, L = map(int, input().split())\na = list(map(int, input().split()))\n\nf = 0\nfor i in range(N-1):\n if a[i] + a[i+1] >= L:\n f = 1\n t = i\n break\n#print(t)\nif f == 0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n ans = []\n for i in range(t):\n ans.append(i+1)\n for i in range(N-1, t, -1):\n ans.append(i)\n #print(ans)\n for x in ans:\n print(str(x))",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"f = 0",
"f",
"0",
"for i in range(N-1):\n if a[i] + a[i+1] >= L:\n f = 1\n t = i\n break\n#print(t)",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if a[i] + a[i+1] >= L:\n f = 1\n t = i\n break\n#print(t)",
"a[i] + a[i+1] >= L",
"a[i] + a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"L",
"f = 1",
"f",
"1",
"t = i",
"t",
"i",
"break",
"if f == 0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n ans = []\n for i in range(t):\n ans.append(i+1)\n for i in range(N-1, t, -1):\n ans.append(i)\n #print(ans)\n for x in ans:\n print(str(x))",
"f == 0",
"f",
"0",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"ans = []",
"ans",
"[]",
"for i in range(t):\n ans.append(i+1)\n ",
"i",
"range(t)",
"range",
"t",
"ans.append(i+1)",
"ans.append",
"ans",
"append",
"i+1",
"i",
"1",
"for i in range(N-1, t, -1):\n ans.append(i)\n #print(ans)\n ",
"i",
"range(N-1, t, -1)",
"range",
"N-1",
"N",
"1",
"t",
"-1",
"ans.append(i)",
"ans.append",
"ans",
"append",
"i",
"for x in ans:\n print(str(x))",
"x",
"ans",
"print(str(x))",
"print",
"str(x)",
"str",
"x",
"f = 1",
"1",
"f",
"ans = []",
"[]",
"ans",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"f = 0",
"0",
"f",
"t = i",
"i",
"t",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N"
] | N, L = map(int, input().split())
a = list(map(int, input().split()))
f = 0
for i in range(N-1):
if a[i] + a[i+1] >= L:
f = 1
t = i
break
#print(t)
if f == 0:
print("Impossible")
else:
print("Possible")
ans = []
for i in range(t):
ans.append(i+1)
for i in range(N-1, t, -1):
ans.append(i)
#print(ans)
for x in ans:
print(str(x))
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
2,
17,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
13,
13,
4,
13,
2,
13,
17,
3,
4,
13,
17,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13
] | [
[
101,
2
],
[
101,
11
],
[
15,
14
],
[
14,
23
],
[
95,
25
],
[
104,
28
],
[
98,
33
],
[
37,
36
],
[
102,
40
],
[
96,
46
],
[
36,
47
],
[
96,
49
],
[
36,
51
],
[
93,
53
],
[
59,
58
],
[
36,
63
],
[
58,
67
],
[
70,
69
],
[
102,
73
],
[
36,
76
],
[
69,
81
],
[
36,
85
],
[
101,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
]
] | [
"N, L = map(int, input().split())\na = [int(c) for c in input().split()]\nm = 10**9\nj = -1\nfor i in range(N-1):\n if a[i]+a[i+1]>=L:\n print('Possible')\n for j in range(1,i+1):\n print(j)\n for j in range(N-1, i+1, -1):\n print(j)\n print(i+1)\n break\nelse:\n print('Impossible')",
"N, L = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"int(c) for c in input().split()",
"for c in input().split()",
"c",
"input().split()",
"().split",
"()",
"input",
"split",
"for c in input().split()",
"int(c)",
"int",
"c",
"a = [int(c) for c in input().split()]",
"a",
"[int(c) for c in input().split()]",
"m = 10**9",
"m",
"10**9",
"10",
"9",
"j = -1",
"j",
"-1",
"for i in range(N-1):\n if a[i]+a[i+1]>=L:\n print('Possible')\n for j in range(1,i+1):\n print(j)\n for j in range(N-1, i+1, -1):\n print(j)\n print(i+1)\n break\nelse:\n print('Impossible')",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if a[i]+a[i+1]>=L:\n print('Possible')\n for j in range(1,i+1):\n print(j)\n for j in range(N-1, i+1, -1):\n print(j)\n print(i+1)\n break",
"a[i]+a[i+1]>=L",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"L",
"print('Possible')",
"print",
"'Possible'",
"for j in range(1,i+1):\n print(j)\n ",
"j",
"range(1,i+1)",
"range",
"1",
"i+1",
"i",
"1",
"print(j)",
"print",
"j",
"for j in range(N-1, i+1, -1):\n print(j)\n ",
"j",
"range(N-1, i+1, -1)",
"range",
"N-1",
"N",
"1",
"i+1",
"i",
"1",
"-1",
"print(j)",
"print",
"j",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"break",
"print('Impossible')",
"print",
"'Impossible'",
"L = map(int, input().split())",
"map(int, input().split())",
"L",
"a = [int(c) for c in input().split()]",
"[int(c) for c in input().split()]",
"a",
"j = -1",
"-1",
"j",
"N, L = map(int, input().split())",
"map(int, input().split())",
"N",
"m = 10**9",
"10**9",
"m"
] | N, L = map(int, input().split())
a = [int(c) for c in input().split()]
m = 10**9
j = -1
for i in range(N-1):
if a[i]+a[i+1]>=L:
print('Possible')
for j in range(1,i+1):
print(j)
for j in range(N-1, i+1, -1):
print(j)
print(i+1)
break
else:
print('Impossible')
|
[
7,
0,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
13,
17,
3,
14,
2,
13,
17,
4,
13,
17,
29,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
4,
18,
13,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
17,
4,
18,
13,
13,
2,
13,
17,
4,
18,
13,
13,
13,
4,
13,
17,
4,
13,
4,
18,
17,
13,
4,
13,
13,
13,
14,
2,
13,
17,
4,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13
] | [
[
140,
2
],
[
134,
7
],
[
17,
16
],
[
17,
25
],
[
28,
27
],
[
40,
39
],
[
43,
42
],
[
16,
46
],
[
27,
52
],
[
42,
53
],
[
27,
55
],
[
42,
57
],
[
25,
59
],
[
62,
61
],
[
42,
63
],
[
61,
68
],
[
39,
68
],
[
76,
75
],
[
79,
78
],
[
61,
82
],
[
39,
82
],
[
75,
86
],
[
78,
89
],
[
93,
92
],
[
16,
96
],
[
61,
99
],
[
39,
99
],
[
75,
104
],
[
92,
107
],
[
75,
111
],
[
61,
113
],
[
39,
113
],
[
75,
126
],
[
138,
132
],
[
134,
135
],
[
140,
141
]
] | [
"INF = 10 ** 15\nMOD = 10 ** 9 + 7 \ndef main():\n N,L = map(int,input().split())\n A = list(map(int,input().split()))\n point = -1\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n point = i + 1\n break\n if point == - 1:\n print('Impossible')\n return\n ans = []\n for i in range(point - 1):\n ans.append(i + 1)\n for i in range(N - 2,point - 1,-1):\n ans.append(i + 1)\n ans.append(point)\n print('Possible')\n print('\\n'.join(map(str,ans)))\nif __name__ == '__main__':\n main()",
"INF = 10 ** 15",
"INF",
"10 ** 15",
"10",
"15",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def main():\n N,L = map(int,input().split())\n A = list(map(int,input().split()))\n point = -1\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n point = i + 1\n break\n if point == - 1:\n print('Impossible')\n return\n ans = []\n for i in range(point - 1):\n ans.append(i + 1)\n for i in range(N - 2,point - 1,-1):\n ans.append(i + 1)\n ans.append(point)\n print('Possible')\n print('\\n'.join(map(str,ans)))",
"main",
"N,L = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"point = -1",
"point",
"-1",
"for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n point = i + 1\n break\n ",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"if A[i] + A[i + 1] >= L:\n point = i + 1\n break\n ",
"A[i] + A[i + 1] >= L",
"A[i] + A[i + 1]",
"A[i]",
"A",
"i",
"A[i + 1]",
"A",
"i + 1",
"i",
"1",
"L",
"point = i + 1",
"point",
"i + 1",
"i",
"1",
"break",
"if point == - 1:\n print('Impossible')\n return\n ",
"point == - 1",
"point",
"- 1",
"print('Impossible')",
"print",
"'Impossible'",
"return",
"ans = []",
"ans",
"[]",
"for i in range(point - 1):\n ans.append(i + 1)\n ",
"i",
"range(point - 1)",
"range",
"point - 1",
"point",
"1",
"ans.append(i + 1)",
"ans.append",
"ans",
"append",
"i + 1",
"i",
"1",
"for i in range(N - 2,point - 1,-1):\n ans.append(i + 1)\n ",
"i",
"range(N - 2,point - 1,-1)",
"range",
"N - 2",
"N",
"2",
"point - 1",
"point",
"1",
"-1",
"ans.append(i + 1)",
"ans.append",
"ans",
"append",
"i + 1",
"i",
"1",
"ans.append(point)",
"ans.append",
"ans",
"append",
"point",
"print('Possible')",
"print",
"'Possible'",
"print('\\n'.join(map(str,ans)))",
"print",
"'\\n'.join(map(str,ans))",
"'\\n'.join",
"'\\n'",
"join",
"map(str,ans)",
"map",
"str",
"ans",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"def main():\n N,L = map(int,input().split())\n A = list(map(int,input().split()))\n point = -1\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n point = i + 1\n break\n if point == - 1:\n print('Impossible')\n return\n ans = []\n for i in range(point - 1):\n ans.append(i + 1)\n for i in range(N - 2,point - 1,-1):\n ans.append(i + 1)\n ans.append(point)\n print('Possible')\n print('\\n'.join(map(str,ans)))",
"def main():\n N,L = map(int,input().split())\n A = list(map(int,input().split()))\n point = -1\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n point = i + 1\n break\n if point == - 1:\n print('Impossible')\n return\n ans = []\n for i in range(point - 1):\n ans.append(i + 1)\n for i in range(N - 2,point - 1,-1):\n ans.append(i + 1)\n ans.append(point)\n print('Possible')\n print('\\n'.join(map(str,ans)))",
"main",
"INF = 10 ** 15",
"10 ** 15",
"INF"
] | INF = 10 ** 15
MOD = 10 ** 9 + 7
def main():
N,L = map(int,input().split())
A = list(map(int,input().split()))
point = -1
for i in range(N - 1):
if A[i] + A[i + 1] >= L:
point = i + 1
break
if point == - 1:
print('Impossible')
return
ans = []
for i in range(point - 1):
ans.append(i + 1)
for i in range(N - 2,point - 1,-1):
ans.append(i + 1)
ans.append(point)
print('Possible')
print('\n'.join(map(str,ans)))
if __name__ == '__main__':
main() |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
3,
14,
2,
13,
17,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13
] | [
[
86,
2
],
[
86,
11
],
[
95,
13
],
[
89,
25
],
[
29,
28
],
[
87,
32
],
[
96,
38
],
[
28,
39
],
[
96,
41
],
[
28,
43
],
[
84,
45
],
[
92,
47
],
[
28,
48
],
[
93,
52
],
[
90,
52
],
[
62,
61
],
[
93,
64
],
[
90,
64
],
[
61,
68
],
[
72,
71
],
[
87,
75
],
[
93,
77
],
[
90,
77
],
[
71,
81
],
[
86,
84
],
[
86,
87
],
[
89,
90
],
[
28,
92
],
[
92,
93
],
[
95,
96
]
] | [
"n, l = map(int, input().split())\na = list(map(int, input().split()))\nind = -1\nfor i in range(n-1):\n if a[i]+a[i+1] >= l:\n ind = i\n break\n\nif ind == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(ind):\n print(i+1)\n for i in range(n-1, ind, -1):\n print(i)",
"n, l = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ind = -1",
"ind",
"-1",
"for i in range(n-1):\n if a[i]+a[i+1] >= l:\n ind = i\n break",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if a[i]+a[i+1] >= l:\n ind = i\n break",
"a[i]+a[i+1] >= l",
"a[i]+a[i+1]",
"a[i]",
"a",
"i",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"l",
"ind = i",
"ind",
"i",
"break",
"if ind == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(ind):\n print(i+1)\n for i in range(n-1, ind, -1):\n print(i)",
"ind == -1",
"ind",
"-1",
"print(\"Impossible\")",
"print",
"\"Impossible\"",
"print(\"Possible\")",
"print",
"\"Possible\"",
"for i in range(ind):\n print(i+1)\n ",
"i",
"range(ind)",
"range",
"ind",
"print(i+1)",
"print",
"i+1",
"i",
"1",
"for i in range(n-1, ind, -1):\n print(i)",
"i",
"range(n-1, ind, -1)",
"range",
"n-1",
"n",
"1",
"ind",
"-1",
"print(i)",
"print",
"i",
"l = map(int, input().split())",
"map(int, input().split())",
"l",
"n, l = map(int, input().split())",
"map(int, input().split())",
"n",
"ind = -1",
"-1",
"ind",
"ind = i",
"i",
"ind",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a"
] | n, l = map(int, input().split())
a = list(map(int, input().split()))
ind = -1
for i in range(n-1):
if a[i]+a[i+1] >= l:
ind = i
break
if ind == -1:
print("Impossible")
else:
print("Possible")
for i in range(ind):
print(i+1)
for i in range(n-1, ind, -1):
print(i)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.