Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 145

[ 7, 12, 13, 41, 28, 13, 4, 18, 4, 18, 4, 13, 13, 13, 17, 4, 4, 13, 13, 0, 13, 13, 13, 41, 28, 13, 4, 18, 4, 18, 4, 13, 13, 13, 17, 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, 0, 13, 13, 3, 4, 13, 17, 29, 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, 10, 12, 13 ]

[ [ 6, 5 ], [ 5, 18 ], [ 21, 20 ], [ 21, 22 ], [ 26, 25 ], [ 25, 38 ], [ 41, 40 ], [ 44, 43 ], [ 20, 47 ], [ 40, 52 ], [ 43, 54 ], [ 40, 57 ], [ 43, 58 ], [ 22, 59 ], [ 65, 64 ], [ 43, 65 ], [ 73, 72 ], [ 64, 76 ], [ 72, 79 ], [ 82, 81 ], [ 20, 85 ], [ 64, 87 ], [ 81, 91 ], [ 64, 94 ], [ 99, 96 ] ]

[ "def main():\n n, l = (int(s) for s in input().strip().split(' '))\n an = [int (s) for s in input().strip().split(' ')]\n for i in range(1, n):\n if an[i-1] + an[i] >= l:\n print('Possible')\n index = i\n break\n else:\n print('Impossible')\n return\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)\n \nmain()", "def main():\n n, l = (int(s) for s in input().strip().split(' '))\n an = [int (s) for s in input().strip().split(' ')]\n for i in range(1, n):\n if an[i-1] + an[i] >= l:\n print('Possible')\n index = i\n break\n else:\n print('Impossible')\n return\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)\n ", "main", "int(s) for s in input().strip().split(' ')", "for s in input().strip().split(' ')", "s", "input().strip().split(' ')", "().strip().split", "().strip()", "().strip", "()", "input", "strip", "split", "' '", "for s in input().strip().split(' ')", "int(s)", "int", "s", "n, l = (int(s) for s in input().strip().split(' '))", "n", "(int(s) for s in input().strip().split(' '))", "l", "int (s) for s in input().strip().split(' ')", "for s in input().strip().split(' ')", "s", "input().strip().split(' ')", "().strip().split", "().strip()", "().strip", "()", "input", "strip", "split", "' '", "for s in input().strip().split(' ')", "int (s)", "int", "s", "an = [int (s) for s in input().strip().split(' ')]", "an", "[int (s) for s in input().strip().split(' ')]", "for i in range(1, n):\n if an[i-1] + an[i] >= l:\n print('Possible')\n index = i\n break\n else:\n print('Impossible')\n return\n ", "i", "range(1, n)", "range", "1", "n", "if an[i-1] + an[i] >= l:\n print('Possible')\n index = i\n break\n ", "an[i-1] + an[i] >= l", "an[i-1] + an[i]", "an[i-1]", "an", "i-1", "i", "1", "an[i]", "an", "i", "l", "print('Possible')", "print", "'Possible'", "index = i", "index", "i", "break", "print('Impossible')", "print", "'Impossible'", "return", "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", "main()", "main", "def main():\n n, l = (int(s) for s in input().strip().split(' '))\n an = [int (s) for s in input().strip().split(' ')]\n for i in range(1, n):\n if an[i-1] + an[i] >= l:\n print('Possible')\n index = i\n break\n else:\n print('Impossible')\n return\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)\n ", "def main():\n n, l = (int(s) for s in input().strip().split(' '))\n an = [int (s) for s in input().strip().split(' ')]\n for i in range(1, n):\n if an[i-1] + an[i] >= l:\n print('Possible')\n index = i\n break\n else:\n print('Impossible')\n return\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)\n ", "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, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 2, 13, 17, 0, 13, 17, 3, 14, 40, 13, 4, 13, 17, 14, 13, 4, 13, 17, 28, 13, 4, 13, 17, 17, 17, 14, 40, 40, 17, 2, 13, 13, 2, 13, 17, 4, 13, 2, 13, 13, 14, 40, 40, 17, 2, 13, 13, 2, 13, 17, 4, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13 ]

[ [ 122, 2 ], [ 122, 11 ], [ 113, 13 ], [ 116, 25 ], [ 125, 28 ], [ 32, 31 ], [ 111, 35 ], [ 114, 41 ], [ 31, 42 ], [ 114, 44 ], [ 31, 46 ], [ 123, 48 ], [ 128, 50 ], [ 31, 52 ], [ 119, 55 ], [ 120, 60 ], [ 117, 60 ], [ 71, 70 ], [ 129, 81 ], [ 126, 81 ], [ 70, 82 ], [ 111, 84 ], [ 129, 89 ], [ 126, 89 ], [ 70, 90 ], [ 129, 96 ], [ 126, 96 ], [ 70, 97 ], [ 111, 99 ], [ 129, 104 ], [ 126, 104 ], [ 70, 105 ], [ 129, 108 ], [ 126, 108 ], [ 122, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ], [ 128, 129 ] ]

[ "#KNOT PUZZLE\nN,L=map(int,input().split())\nlists=list(map(int,input().split()))\nflag=False\nJ=0\nfor i in range(N-1):\n if lists[i]+lists[i+1]>=L:\n J=i+1\n flag=True\n break\nif not flag:\n print(\"Impossible\")\nif flag:\n print(\"Possible\")\n for i in range(100001,0,-1):\n if 1<=J-i<=N-1:\n print(J-i)\n if 1<=J+i<=N-1:\n print(J+i)\n print(J)\n \n \n\n\n\n\n \n", "N,L=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "lists=list(map(int,input().split()))", "lists", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "flag=False", "flag", "False", "J=0", "J", "0", "for i in range(N-1):\n if lists[i]+lists[i+1]>=L:\n J=i+1\n flag=True\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if lists[i]+lists[i+1]>=L:\n J=i+1\n flag=True\n break", "lists[i]+lists[i+1]>=L", "lists[i]+lists[i+1]", "lists[i]", "lists", "i", "lists[i+1]", "lists", "i+1", "i", "1", "L", "J=i+1", "J", "i+1", "i", "1", "flag=True", "flag", "True", "break", "if not flag:\n print(\"Impossible\")", "not flag", "flag", "print(\"Impossible\")", "print", "\"Impossible\"", "if flag:\n print(\"Possible\")\n for i in range(100001,0,-1):\n if 1<=J-i<=N-1:\n print(J-i)\n if 1<=J+i<=N-1:\n print(J+i)\n print(J)\n \n \n\n\n\n\n ", "flag", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(100001,0,-1):\n if 1<=J-i<=N-1:\n print(J-i)\n if 1<=J+i<=N-1:\n print(J+i)\n ", "i", "range(100001,0,-1)", "range", "100001", "0", "-1", "if 1<=J-i<=N-1:\n print(J-i)\n ", "1<=J-i<=N-1", "1<=J-i", "1", "J-i", "J", "i", "N-1", "N", "1", "print(J-i)", "print", "J-i", "J", "i", "if 1<=J+i<=N-1:\n print(J+i)\n ", "1<=J+i<=N-1", "1<=J+i", "1", "J+i", "J", "i", "N-1", "N", "1", "print(J+i)", "print", "J+i", "J", "i", "print(J)", "print", "J", "N,L=map(int,input().split())", "map(int,input().split())", "N", "lists=list(map(int,input().split()))", "list(map(int,input().split()))", "lists", "flag=False", "False", "flag", "flag=True", "True", "flag", "L=map(int,input().split())", "map(int,input().split())", "L", "J=0", "0", "J", "J=i+1", "i+1", "J" ]

[ 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, 13, 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, 2, 13, 17, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 97, 2 ], [ 97, 11 ], [ 112, 13 ], [ 115, 25 ], [ 103, 28 ], [ 95, 29 ], [ 32, 31 ], [ 95, 35 ], [ 109, 38 ], [ 113, 41 ], [ 31, 42 ], [ 113, 44 ], [ 31, 46 ], [ 110, 50 ], [ 116, 51 ], [ 107, 51 ], [ 106, 53 ], [ 110, 54 ], [ 100, 56 ], [ 31, 58 ], [ 107, 62 ], [ 116, 62 ], [ 98, 63 ], [ 72, 71 ], [ 101, 75 ], [ 104, 75 ], [ 71, 78 ], [ 81, 80 ], [ 95, 84 ], [ 101, 87 ], [ 104, 87 ], [ 80, 92 ], [ 97, 95 ], [ 97, 98 ], [ 100, 101 ], [ 95, 103 ], [ 103, 104 ], [ 110, 106 ], [ 106, 107 ], [ 109, 110 ], [ 112, 113 ], [ 115, 116 ] ]

[ "N, L = map(int, input().split())\na = list((map(int, input().split())))\nlongest = 0\nlongest_i = N\nfor i in range(N-1):\n knot = a[i]+a[i+1]\n if knot > longest:\n longest = knot\n longest_i = i+1\nif longest < L:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,longest_i):\n print(i)\n for j in range(N-1,longest_i-1,-1):\n print(j)", "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", "longest = 0", "longest", "0", "longest_i = N", "longest_i", "N", "for i in range(N-1):\n knot = a[i]+a[i+1]\n if knot > longest:\n longest = knot\n longest_i = i+1", "i", "range(N-1)", "range", "N-1", "N", "1", "knot = a[i]+a[i+1]", "knot", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "if knot > longest:\n longest = knot\n longest_i = i+1", "knot > longest", "knot", "longest", "longest = knot", "longest", "knot", "longest_i = i+1", "longest_i", "i+1", "i", "1", "if longest < L:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,longest_i):\n print(i)\n for j in range(N-1,longest_i-1,-1):\n print(j)", "longest < L", "longest", "L", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,longest_i):\n print(i)\n ", "i", "range(1,longest_i)", "range", "1", "longest_i", "print(i)", "print", "i", "for j in range(N-1,longest_i-1,-1):\n print(j)", "j", "range(N-1,longest_i-1,-1)", "range", "N-1", "N", "1", "longest_i-1", "longest_i", "1", "-1", "print(j)", "print", "j", "N, L = map(int, input().split())", "map(int, input().split())", "N", "L = map(int, input().split())", "map(int, input().split())", "L", "longest_i = i+1", "i+1", "longest_i", "longest_i = N", "N", "longest_i", "longest = knot", "knot", "longest", "knot = a[i]+a[i+1]", "a[i]+a[i+1]", "knot", "a = list((map(int, input().split())))", "list((map(int, input().split())))", "a", "longest = 0", "0", "longest" ]

[ 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, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 4, 2, 13, 17, 0, 13, 13, 0, 13, 8, 13, 4, 18, 17, 13, 4, 18, 17, 13, 4, 13, 13, 2, 2, 4, 13, 4, 13, 17, 18, 13, 17, 4, 13, 4, 13, 2, 13, 17, 18, 13, 17, 17, 39, 18, 13, 17, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 8, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 107, 2 ], [ 107, 11 ], [ 98, 13 ], [ 27, 26 ], [ 96, 30 ], [ 99, 35 ], [ 26, 36 ], [ 99, 38 ], [ 26, 40 ], [ 108, 42 ], [ 26, 45 ], [ 104, 48 ], [ 101, 51 ], [ 105, 53 ], [ 105, 73 ], [ 96, 80 ], [ 105, 83 ], [ 105, 88 ], [ 102, 93 ], [ 107, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ] ]

[ "N, L = map(int, input().split())\na = list(map(int, input().split()))\n\nI = [i + 1 for i in range(N - 1) if a[i] + a[i + 1] >= L]\nans = (\n 'Possible\\n{}'.format(\n '\\n'.join(\n map(\n str,\n list(range(1, I[0])) + list(range(N - 1, I[0], -1)) + [I[0]]\n )\n )\n ) if I else\n 'Impossible'\n)\n\nprint(ans)", "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", "i + 1 for i in range(N - 1) if a[i] + a[i + 1] >= L", "for i in range(N - 1) if a[i] + a[i + 1] >= L", "i", "range(N - 1)", "range", "N - 1", "N", "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", "if a[i] + a[i + 1] >= L", "i + 1", "i", "1", "I = [i + 1 for i in range(N - 1) if a[i] + a[i + 1] >= L]", "I", "[i + 1 for i in range(N - 1) if a[i] + a[i + 1] >= L]", "ans = (\n 'Possible\\n{}'.format(\n '\\n'.join(\n map(\n str,\n list(range(1, I[0])) + list(range(N - 1, I[0], -1)) + [I[0]]\n )\n )\n ) if I else\n 'Impossible'\n)", "ans", "'Possible\\n{}'.format(\n '\\n'.join(\n map(\n str,\n list(range(1, I[0])) + list(range(N - 1, I[0], -1)) + [I[0]]\n )\n )\n ) if I else\n 'Impossible'", "I", "'Possible\\n{}'.format(\n '\\n'.join(\n map(\n str,\n list(range(1, I[0])) + list(range(N - 1, I[0], -1)) + [I[0]]\n )\n )\n )", "'Possible\\n{}'.format", "'Possible\\n{}'", "format", "'\\n'.join(\n map(\n str,\n list(range(1, I[0])) + list(range(N - 1, I[0], -1)) + [I[0]]\n )\n )", "'\\n'.join", "'\\n'", "join", "map(\n str,\n list(range(1, I[0])) + list(range(N - 1, I[0], -1)) + [I[0]]\n )", "map", "str", "list(range(1, I[0])) + list(range(N - 1, I[0], -1)) + [I[0]]", "list(range(1, I[0])) + list(range(N - 1, I[0], -1))", "list(range(1, I[0]))", "list", "range(1, I[0])", "range", "1", "I[0]", "I", "0", "list(range(N - 1, I[0], -1))", "list", "range(N - 1, I[0], -1)", "range", "N - 1", "N", "1", "I[0]", "I", "0", "-1", "[I[0]]", "I[0]", "I", "0", "'Impossible'", "print(ans)", "print", "ans", "N, L = map(int, input().split())", "map(int, input().split())", "N", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "ans = (\n 'Possible\\n{}'.format(\n '\\n'.join(\n map(\n str,\n list(range(1, I[0])) + list(range(N - 1, I[0], -1)) + [I[0]]\n )\n )\n ) if I else\n 'Impossible'\n)", "'Possible\\n{}'.format(\n '\\n'.join(\n map(\n str,\n list(range(1, I[0])) + list(range(N - 1, I[0], -1)) + [I[0]]\n )\n )\n ) if I else\n 'Impossible'", "ans", "I = [i + 1 for i in range(N - 1) if a[i] + a[i + 1] >= L]", "[i + 1 for i in range(N - 1) if a[i] + a[i + 1] >= L]", "I", "L = map(int, input().split())", "map(int, input().split())", "L" ]

[ 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, 14, 2, 13, 17, 4, 13, 17, 4, 13, 17, 0, 13, 39, 28, 13, 4, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 13, 28, 13, 4, 13, 2, 13, 17, 13, 4, 18, 13, 13, 13, 28, 13, 4, 13, 13, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 110, 2 ], [ 110, 11 ], [ 113, 13 ], [ 116, 25 ], [ 29, 28 ], [ 111, 32 ], [ 114, 38 ], [ 28, 39 ], [ 114, 41 ], [ 28, 43 ], [ 102, 45 ], [ 104, 47 ], [ 28, 49 ], [ 105, 53 ], [ 117, 53 ], [ 107, 62 ], [ 66, 65 ], [ 105, 72 ], [ 117, 72 ], [ 108, 76 ], [ 65, 78 ], [ 81, 80 ], [ 105, 84 ], [ 117, 84 ], [ 111, 86 ], [ 108, 89 ], [ 80, 91 ], [ 94, 93 ], [ 108, 96 ], [ 93, 99 ], [ 110, 102 ], [ 104, 105 ], [ 107, 108 ], [ 110, 111 ], [ 113, 114 ], [ 116, 117 ] ]

[ "N, L = 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]>=L:\n k=i+1\nif k==-1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n res = []\n for i in reversed(range(1,k+1)):\n res.append(i)\n for i in range(k+1,N):\n res.append(i)\n for i in reversed(res):\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", "k = -1", "k", "-1", "for i in range(N-1):\n if A[i]+A[i+1]>=L:\n k=i+1", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i]+A[i+1]>=L:\n k=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", "k=i+1", "k", "i+1", "i", "1", "if k==-1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n res = []\n for i in reversed(range(1,k+1)):\n res.append(i)\n for i in range(k+1,N):\n res.append(i)\n for i in reversed(res):\n print(i)", "k==-1", "k", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "res = []", "res", "[]", "for i in reversed(range(1,k+1)):\n res.append(i)\n ", "i", "reversed(range(1,k+1))", "reversed", "range(1,k+1)", "range", "1", "k+1", "k", "1", "res.append(i)", "res.append", "res", "append", "i", "for i in range(k+1,N):\n res.append(i)\n ", "i", "range(k+1,N)", "range", "k+1", "k", "1", "N", "res.append(i)", "res.append", "res", "append", "i", "for i in reversed(res):\n print(i)", "i", "reversed(res)", "reversed", "res", "print(i)", "print", "i", "L = map(int, input().split())", "map(int, input().split())", "L", "k=i+1", "i+1", "k", "res = []", "[]", "res", "N, L = map(int, input().split())", "map(int, input().split())", "N", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "k = -1", "-1", "k" ]

[ 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, 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, 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, 13, 13, 10, 13, 13, 10, 17, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 97, 14 ], [ 97, 16 ], [ 20, 19 ], [ 19, 28 ], [ 91, 30 ], [ 100, 33 ], [ 37, 36 ], [ 98, 40 ], [ 92, 45 ], [ 36, 47 ], [ 92, 50 ], [ 36, 51 ], [ 95, 52 ], [ 103, 54 ], [ 36, 55 ], [ 104, 59 ], [ 101, 59 ], [ 69, 68 ], [ 104, 72 ], [ 101, 72 ], [ 68, 75 ], [ 78, 77 ], [ 98, 81 ], [ 104, 84 ], [ 101, 84 ], [ 77, 89 ], [ 91, 92 ], [ 97, 95 ], [ 97, 98 ], [ 100, 101 ], [ 36, 103 ], [ 103, 104 ] ]

[ "\nn, l = [ int(v) for v in input().split() ]\nknot_list = [ int(v) for v in input().split() ]\n\npos = 0\nfor i in range(1,n):\n if knot_list[i-1] + knot_list[i] >= l:\n pos = i\n break\nif pos == 0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,pos):\n print(i)\n for i in range(n-1,pos-1,-1):\n print(i)", "int(v) for v in input().split()", "for v in input().split()", "v", "input().split()", "().split", "()", "input", "split", "for v in input().split()", "int(v)", "int", "v", "n, l = [ int(v) for v in input().split() ]", "n", "[ int(v) for v in input().split() ]", "l", "int(v) for v in input().split()", "for v in input().split()", "v", "input().split()", "().split", "()", "input", "split", "for v in input().split()", "int(v)", "int", "v", "knot_list = [ int(v) for v in input().split() ]", "knot_list", "[ int(v) for v in input().split() ]", "pos = 0", "pos", "0", "for i in range(1,n):\n if knot_list[i-1] + knot_list[i] >= l:\n pos = i\n break", "i", "range(1,n)", "range", "1", "n", "if knot_list[i-1] + knot_list[i] >= l:\n pos = i\n break", "knot_list[i-1] + knot_list[i] >= l", "knot_list[i-1] + knot_list[i]", "knot_list[i-1]", "knot_list", "i-1", "i", "1", "knot_list[i]", "knot_list", "i", "l", "pos = i", "pos", "i", "break", "if pos == 0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,pos):\n print(i)\n for i in range(n-1,pos-1,-1):\n print(i)", "pos == 0", "pos", "0", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,pos):\n print(i)\n ", "i", "range(1,pos)", "range", "1", "pos", "print(i)", "print", "i", "for i in range(n-1,pos-1,-1):\n print(i)", "i", "range(n-1,pos-1,-1)", "range", "n-1", "n", "1", "pos-1", "pos", "1", "-1", "print(i)", "print", "i", "knot_list = [ int(v) for v in input().split() ]", "[ int(v) for v in input().split() ]", "knot_list", "l = [ int(v) for v in input().split() ]", "[ int(v) for v in input().split() ]", "l", "n, l = [ int(v) for v in input().split() ]", "[ int(v) for v in input().split() ]", "n", "pos = 0", "0", "pos", "pos = i", "i", "pos" ]

[ 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, 2, 4, 13, 4, 13, 17, 2, 13, 17, 18, 4, 13, 4, 13, 2, 13, 17, 13, 39, 17, 4, 18, 13, 13, 2, 13, 17, 28, 13, 13, 4, 13, 13, 4, 13, 4, 13, 17, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 96, 2 ], [ 96, 11 ], [ 90, 13 ], [ 26, 25 ], [ 97, 29 ], [ 91, 35 ], [ 25, 36 ], [ 91, 38 ], [ 25, 40 ], [ 94, 42 ], [ 87, 47 ], [ 25, 55 ], [ 25, 63 ], [ 97, 65 ], [ 88, 70 ], [ 25, 73 ], [ 77, 76 ], [ 88, 76 ], [ 76, 80 ], [ 87, 88 ], [ 90, 91 ], [ 96, 94 ], [ 96, 97 ] ]

[ "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 print('Possible')\n ans = list(range(1,i+1))+list(range(i+2,n))[::-1]\n ans.append(i+1)\n for i in ans:\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(n-1):\n if a[i]+a[i+1]>=l:\n print('Possible')\n ans = list(range(1,i+1))+list(range(i+2,n))[::-1]\n ans.append(i+1)\n for i in ans:\n print(i)\n exit()", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n print('Possible')\n ans = list(range(1,i+1))+list(range(i+2,n))[::-1]\n ans.append(i+1)\n for i in ans:\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'", "ans = list(range(1,i+1))+list(range(i+2,n))[::-1]", "ans", "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", "ans.append(i+1)", "ans.append", "ans", "append", "i+1", "i", "1", "for i in ans:\n print(i)\n ", "i", "ans", "print(i)", "print", "i", "exit()", "exit", "print('Impossible')", "print", "'Impossible'", "ans = list(range(1,i+1))+list(range(i+2,n))[::-1]", "list(range(1,i+1))+list(range(i+2,n))[::-1]", "ans", "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())", "map(int,input().split())", "n" ]

[ 7, 15, 13, 12, 13, 12, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 4, 13, 13, 0, 13, 4, 13, 4, 13, 0, 13, 39, 28, 13, 4, 13, 17, 13, 0, 13, 2, 18, 13, 2, 13, 17, 18, 13, 13, 14, 40, 13, 13, 0, 13, 13, 4, 13, 17, 3, 4, 13, 17, 4, 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, 2, 13, 10, 4, 13, 10, 13, 13, 10, 12, 13, 10, 4, 13, 10, 39, 13, 10, 12, 13, 10, 4, 13 ]

[ [ 106, 15 ], [ 104, 17 ], [ 106, 18 ], [ 97, 20 ], [ 104, 24 ], [ 100, 26 ], [ 30, 29 ], [ 89, 33 ], [ 85, 35 ], [ 98, 38 ], [ 29, 40 ], [ 98, 43 ], [ 29, 44 ], [ 86, 47 ], [ 107, 48 ], [ 91, 50 ], [ 29, 51 ], [ 63, 62 ], [ 92, 66 ], [ 62, 69 ], [ 72, 71 ], [ 89, 75 ], [ 92, 78 ], [ 71, 83 ], [ 85, 86 ], [ 106, 89 ], [ 29, 91 ], [ 91, 92 ], [ 97, 98 ], [ 100, 101 ], [ 106, 107 ] ]

[ "import sys\ndef input(): return sys.stdin.readline().strip()\ndef mapint(): return map(int, input().split())\nsys.setrecursionlimit(10**9)\n\nN, L = mapint()\nAs = list(mapint())\n\nprocces = []\nfor i in range(1, N):\n double = As[i-1]+As[i]\n if double>=L:\n last = i\n print('Possible')\n break\nelse:\n print('Impossible')\n exit()\nfor i in range(1, last):\n print(i)\nfor i in range(N-1, last-1, -1):\n print(i)", "import sys", "sys", "def input(): return sys.stdin.readline().strip()", "input", "def mapint(): return map(int, input().split())", "mapint", "sys.setrecursionlimit(10**9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**9", "10", "9", "N, L = mapint()", "N", "mapint()", "mapint", "L", "As = list(mapint())", "As", "list(mapint())", "list", "mapint()", "mapint", "procces = []", "procces", "[]", "for i in range(1, N):\n double = As[i-1]+As[i]\n if double>=L:\n last = i\n print('Possible')\n break\nelse:\n print('Impossible')\n exit()", "i", "range(1, N)", "range", "1", "N", "double = As[i-1]+As[i]", "double", "As[i-1]+As[i]", "As[i-1]", "As", "i-1", "i", "1", "As[i]", "As", "i", "if double>=L:\n last = i\n print('Possible')\n break", "double>=L", "double", "L", "last = i", "last", "i", "print('Possible')", "print", "'Possible'", "break", "print('Impossible')", "print", "'Impossible'", "exit()", "exit", "for i in range(1, last):\n print(i)", "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", "double = As[i-1]+As[i]", "As[i-1]+As[i]", "double", "N, L = mapint()", "mapint()", "N", "last = i", "i", "last", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "As = list(mapint())", "list(mapint())", "As", "procces = []", "[]", "procces", "def mapint(): return map(int, input().split())", "def mapint(): return map(int, input().split())", "mapint", "L = mapint()", "mapint()", "L" ]

[ 7, 15, 13, 0, 13, 17, 0, 13, 17, 12, 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, 14, 2, 13, 13, 4, 13, 13, 29, 4, 13, 13, 0, 13, 4, 18, 13, 13, 13, 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, 29, 23, 13, 23, 13, 23, 13, 12, 13, 12, 13, 28, 13, 18, 13, 13, 28, 13, 4, 18, 13, 13, 27, 13, 0, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 0, 13, 4, 13, 4, 13, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 13, 0, 13, 13, 4, 13, 13, 13, 13, 14, 2, 13, 17, 4, 13, 10, 17, 13, 10, 12, 13, 10, 12, 13, 10, 17, 13 ]

[ [ 159, 4 ], [ 150, 7 ], [ 14, 13 ], [ 83, 17 ], [ 87, 22 ], [ 13, 23 ], [ 87, 25 ], [ 13, 27 ], [ 31, 30 ], [ 34, 33 ], [ 30, 36 ], [ 33, 39 ], [ 85, 40 ], [ 151, 43 ], [ 160, 47 ], [ 50, 49 ], [ 30, 52 ], [ 33, 54 ], [ 57, 56 ], [ 49, 59 ], [ 56, 63 ], [ 67, 66 ], [ 83, 70 ], [ 49, 73 ], [ 66, 79 ], [ 83, 83 ], [ 85, 85 ], [ 87, 87 ], [ 94, 93 ], [ 99, 98 ], [ 93, 101 ], [ 98, 104 ], [ 107, 106 ], [ 91, 108 ], [ 111, 110 ], [ 106, 115 ], [ 118, 117 ], [ 106, 122 ], [ 126, 125 ], [ 110, 128 ], [ 106, 134 ], [ 137, 136 ], [ 154, 139 ], [ 110, 140 ], [ 117, 141 ], [ 136, 142 ], [ 157, 148 ], [ 150, 151 ], [ 159, 160 ] ]

[ "#!/usr/bin/env python3\nimport sys\n\nYES = \"Possible\" # type: str\nNO = \"Impossible\" # type: str\n\ndef solve(N: int, L: int, a: \"List[int]\"):\n pair_length = [a[i] + a[i+1] for i in range(N-1)]\n longest_pair = max(pair_length)\n \n if longest_pair < L:\n print(NO)\n return\n \n print(YES)\n last_knot = pair_length.index(longest_pair)\n for i in range(last_knot):\n print(i+1)\n for i in range(N-2, last_knot-1, -1):\n print(i+1)\n return\n\n\n# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)\ndef main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n L = int(next(tokens)) # type: int\n a = [ int(next(tokens)) for _ in range(N) ] # type: \"List[int]\"\n solve(N, L, a)\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "YES = \"Possible\"", "YES", "\"Possible\"", "NO = \"Impossible\"", "NO", "\"Impossible\"", "def solve(N: int, L: int, a: \"List[int]\"):\n pair_length = [a[i] + a[i+1] for i in range(N-1)]\n longest_pair = max(pair_length)\n \n if longest_pair < L:\n print(NO)\n return\n \n print(YES)\n last_knot = pair_length.index(longest_pair)\n for i in range(last_knot):\n print(i+1)\n for i in range(N-2, last_knot-1, -1):\n print(i+1)\n return\n\n\n# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)", "solve", "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", "pair_length = [a[i] + a[i+1] for i in range(N-1)]", "pair_length", "[a[i] + a[i+1] for i in range(N-1)]", "longest_pair = max(pair_length)", "longest_pair", "max(pair_length)", "max", "pair_length", "if longest_pair < L:\n print(NO)\n return\n \n ", "longest_pair < L", "longest_pair", "L", "print(NO)", "print", "NO", "return", "print(YES)", "print", "YES", "last_knot = pair_length.index(longest_pair)", "last_knot", "pair_length.index(longest_pair)", "pair_length.index", "pair_length", "index", "longest_pair", "for i in range(last_knot):\n print(i+1)\n ", "i", "range(last_knot)", "range", "last_knot", "print(i+1)", "print", "i+1", "i", "1", "for i in range(N-2, last_knot-1, -1):\n print(i+1)\n ", "i", "range(N-2, last_knot-1, -1)", "range", "N-2", "N", "2", "last_knot-1", "last_knot", "1", "-1", "print(i+1)", "print", "i+1", "i", "1", "return", "N: int", "N", "L: int", "L", "a: \"List[int]\"", "a", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n L = int(next(tokens)) # type: int\n a = [ int(next(tokens)) for _ in range(N) ] # type: \"List[int]\"\n solve(N, L, a)", "main", "def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n ", "iterate_tokens", "for line in sys.stdin:\n for word in line.split():\n yield word\n ", "line", "sys.stdin", "sys", "stdin", "for word in line.split():\n yield word\n ", "word", "line.split()", "line.split", "line", "split", "yield word", "word", "tokens = iterate_tokens()", "tokens", "iterate_tokens()", "iterate_tokens", "N = int(next(tokens))", "N", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "L = int(next(tokens))", "L", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "int(next(tokens)) for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "a = [ int(next(tokens)) for _ in range(N) ]", "a", "[ int(next(tokens)) for _ in range(N) ]", "solve(N, L, a)", "solve", "N", "L", "a", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "NO = \"Impossible\"", "\"Impossible\"", "NO", "def solve(N: int, L: int, a: \"List[int]\"):\n pair_length = [a[i] + a[i+1] for i in range(N-1)]\n longest_pair = max(pair_length)\n \n if longest_pair < L:\n print(NO)\n return\n \n print(YES)\n last_knot = pair_length.index(longest_pair)\n for i in range(last_knot):\n print(i+1)\n for i in range(N-2, last_knot-1, -1):\n print(i+1)\n return\n\n\n# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)", "def solve(N: int, L: int, a: \"List[int]\"):\n pair_length = [a[i] + a[i+1] for i in range(N-1)]\n longest_pair = max(pair_length)\n \n if longest_pair < L:\n print(NO)\n return\n \n print(YES)\n last_knot = pair_length.index(longest_pair)\n for i in range(last_knot):\n print(i+1)\n for i in range(N-2, last_knot-1, -1):\n print(i+1)\n return\n\n\n# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)", "solve", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n L = int(next(tokens)) # type: int\n a = [ int(next(tokens)) for _ in range(N) ] # type: \"List[int]\"\n solve(N, L, a)", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n L = int(next(tokens)) # type: int\n a = [ int(next(tokens)) for _ in range(N) ] # type: \"List[int]\"\n solve(N, L, a)", "main", "YES = \"Possible\"", "\"Possible\"", "YES" ]

[ 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, 17, 28, 13, 13, 4, 13, 13, 14, 40, 13, 13, 0, 13, 2, 13, 17, 14, 2, 13, 17, 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, 2, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 115, 2 ], [ 115, 11 ], [ 106, 13 ], [ 27, 26 ], [ 110, 30 ], [ 107, 35 ], [ 26, 36 ], [ 107, 38 ], [ 26, 40 ], [ 103, 43 ], [ 112, 46 ], [ 104, 53 ], [ 116, 57 ], [ 100, 59 ], [ 101, 65 ], [ 113, 65 ], [ 77, 76 ], [ 101, 80 ], [ 113, 80 ], [ 76, 83 ], [ 86, 85 ], [ 110, 89 ], [ 101, 91 ], [ 113, 91 ], [ 85, 95 ], [ 101, 98 ], [ 113, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ], [ 115, 110 ], [ 112, 113 ], [ 115, 116 ] ]

[ "n,l = map(int, input().split())\nAs = list(map(int, input().split()))\n# 和がl以上のものがあれば、それを残してあとを端から落としていくのでよい\nss = [As[i]+As[i+1] for i in range(n-1)]\n# print(ss)\ncnt = 0\nfor i,s in enumerate(ss):\n if s >= l:\n cnt = i + 1\nif cnt == 0:\n print(\"Impossible\")\n exit()\nprint(\"Possible\")\nfor i in range(1,cnt):\n print(i)\nfor i in range(n-1, cnt, -1):\n print(i)\nprint(cnt)", "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", "As[i]+As[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)", "As[i]+As[i+1]", "As[i]", "As", "i", "As[i+1]", "As", "i+1", "i", "1", "ss = [As[i]+As[i+1] for i in range(n-1)]", "ss", "[As[i]+As[i+1] for i in range(n-1)]", "cnt = 0", "cnt", "0", "for i,s in enumerate(ss):\n if s >= l:\n cnt = i + 1", "i", "s", "enumerate(ss)", "enumerate", "ss", "if s >= l:\n cnt = i + 1", "s >= l", "s", "l", "cnt = i + 1", "cnt", "i + 1", "i", "1", "if cnt == 0:\n print(\"Impossible\")\n exit()", "cnt == 0", "cnt", "0", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,cnt):\n print(i)", "i", "range(1,cnt)", "range", "1", "cnt", "print(i)", "print", "i", "for i in range(n-1, cnt, -1):\n print(i)", "i", "range(n-1, cnt, -1)", "range", "n-1", "n", "1", "cnt", "-1", "print(i)", "print", "i", "print(cnt)", "print", "cnt", "cnt = i + 1", "i + 1", "cnt", "ss = [As[i]+As[i+1] for i in range(n-1)]", "[As[i]+As[i+1] for i in range(n-1)]", "ss", "As = list(map(int, input().split()))", "list(map(int, input().split()))", "As", "n,l = map(int, input().split())", "map(int, input().split())", "n", "cnt = 0", "0", "cnt", "l = map(int, input().split())", "map(int, input().split())", "l" ]

[ 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, 39, 17, 28, 13, 4, 13, 13, 4, 18, 13, 13, 2, 18, 13, 13, 18, 13, 13, 0, 13, 39, 0, 13, 17, 13, 2, 13, 17, 0, 13, 4, 13, 13, 42, 2, 13, 13, 14, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 4, 13, 17, 4, 13, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 2, 18, 13, 2, 13, 17, 18, 13, 13, 4, 18, 13, 13, 2, 13, 17, 0, 13, 17, 4, 18, 13, 13, 13, 0, 13, 17, 4, 13, 17, 28, 13, 13, 4, 13, 13, 10, 17, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 39, 13 ]

[ [ 146, 2 ], [ 146, 11 ], [ 149, 13 ], [ 155, 25 ], [ 30, 29 ], [ 147, 32 ], [ 156, 35 ], [ 156, 39 ], [ 29, 40 ], [ 150, 42 ], [ 29, 43 ], [ 152, 45 ], [ 140, 48 ], [ 134, 50 ], [ 147, 52 ], [ 143, 55 ], [ 150, 58 ], [ 141, 61 ], [ 132, 61 ], [ 135, 62 ], [ 129, 62 ], [ 156, 67 ], [ 135, 69 ], [ 129, 69 ], [ 156, 72 ], [ 141, 73 ], [ 132, 73 ], [ 138, 74 ], [ 150, 84 ], [ 141, 85 ], [ 132, 85 ], [ 150, 87 ], [ 141, 89 ], [ 132, 89 ], [ 150, 93 ], [ 135, 95 ], [ 129, 95 ], [ 150, 98 ], [ 135, 99 ], [ 129, 99 ], [ 153, 102 ], [ 141, 105 ], [ 132, 105 ], [ 131, 108 ], [ 153, 112 ], [ 135, 114 ], [ 129, 114 ], [ 128, 116 ], [ 123, 122 ], [ 153, 122 ], [ 122, 126 ], [ 128, 129 ], [ 131, 132 ], [ 134, 135 ], [ 146, 138 ], [ 140, 141 ], [ 143, 144 ], [ 146, 147 ], [ 149, 150 ], [ 152, 153 ], [ 155, 156 ] ]

[ "n,L = map(int,input().split())\na = list(map(int,input().split()))\n\nr = [0]\nfor i in range(n):\n r.append(r[i] + a[i])\n\nansl = []\np,q = 0,n-1\nsuma = sum(a)\nwhile p < q:\n if r[q+1] - r[p] < L:\n print(\"Impossible\")\n exit()\n if a[p] + a[p + 1] <= a[q-1] + a[q]:\n ansl.append(p + 1)\n p+=1\n else:\n ansl.append(q)\n q-=1\n\n\nprint(\"Possible\")\nfor ans in ansl:\n print(ans)", "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", "r = [0]", "r", "[0]", "0", "for i in range(n):\n r.append(r[i] + a[i])", "i", "range(n)", "range", "n", "r.append(r[i] + a[i])", "r.append", "r", "append", "r[i] + a[i]", "r[i]", "r", "i", "a[i]", "a", "i", "ansl = []", "ansl", "[]", "p,q = 0,n-1", "p", "0", "q", "n-1", "n", "1", "suma = sum(a)", "suma", "sum(a)", "sum", "a", "while p < q:\n if r[q+1] - r[p] < L:\n print(\"Impossible\")\n exit()\n if a[p] + a[p + 1] <= a[q-1] + a[q]:\n ansl.append(p + 1)\n p+=1\n else:\n ansl.append(q)\n q-=1", "p < q", "p", "q", "if r[q+1] - r[p] < L:\n print(\"Impossible\")\n exit()\n ", "r[q+1] - r[p] < L", "r[q+1] - r[p]", "r[q+1]", "r", "q+1", "q", "1", "r[p]", "r", "p", "L", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "if a[p] + a[p + 1] <= a[q-1] + a[q]:\n ansl.append(p + 1)\n p+=1\n else:\n ansl.append(q)\n q-=1", "a[p] + a[p + 1] <= a[q-1] + a[q]", "a[p] + a[p + 1]", "a[p]", "a", "p", "a[p + 1]", "a", "p + 1", "p", "1", "a[q-1] + a[q]", "a[q-1]", "a", "q-1", "q", "1", "a[q]", "a", "q", "ansl.append(p + 1)", "ansl.append", "ansl", "append", "p + 1", "p", "1", "p+=1", "p", "1", "ansl.append(q)", "ansl.append", "ansl", "append", "q", "q-=1", "q", "1", "print(\"Possible\")", "print", "\"Possible\"", "for ans in ansl:\n print(ans)", "ans", "ansl", "print(ans)", "print", "ans", "q-=1", "1", "q", "p+=1", "1", "p", "q = 0,n-1", "n-1", "q", "L = map(int,input().split())", "map(int,input().split())", "L", "p,q = 0,n-1", "0", "p", "suma = sum(a)", "sum(a)", "suma", "n,L = map(int,input().split())", "map(int,input().split())", "n", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "ansl = []", "[]", "ansl", "r = [0]", "[0]", "r" ]

[ 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, 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, 40, 13, 4, 13, 17, 4, 13, 17, 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, 10, 17, 13, 10, 17, 13, 10, 17, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 113, 4 ], [ 113, 13 ], [ 110, 15 ], [ 98, 27 ], [ 101, 30 ], [ 34, 33 ], [ 114, 37 ], [ 111, 43 ], [ 33, 44 ], [ 111, 46 ], [ 33, 48 ], [ 108, 50 ], [ 95, 52 ], [ 104, 55 ], [ 33, 56 ], [ 96, 59 ], [ 99, 59 ], [ 71, 70 ], [ 105, 73 ], [ 102, 73 ], [ 70, 77 ], [ 81, 80 ], [ 105, 85 ], [ 102, 85 ], [ 114, 87 ], [ 80, 92 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 33, 104 ], [ 104, 105 ], [ 113, 108 ], [ 110, 111 ], [ 113, 114 ] ]

[ "import numpy as np\nn,l=map(int,input().split())\na=list(map(int,input().split()))\nflag=False;idx=0\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n flag=True\n idx=i\nif not flag:\n print(\"Impossible\")\n exit(0)\nprint(\"Possible\")\nfor x in range(idx):\n print(x+1)\nfor x in reversed(range(idx,n-1)):\n print(x+1)", "import numpy as np", "numpy", "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", "idx=0", "idx", "0", "for i in range(n-1):\n if a[i]+a[i+1]>=l:\n flag=True\n idx=i", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n flag=True\n idx=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", "idx=i", "idx", "i", "if not flag:\n print(\"Impossible\")\n exit(0)", "not flag", "flag", "print(\"Impossible\")", "print", "\"Impossible\"", "exit(0)", "exit", "0", "print(\"Possible\")", "print", "\"Possible\"", "for x in range(idx):\n print(x+1)", "x", "range(idx)", "range", "idx", "print(x+1)", "print", "x+1", "x", "1", "for x in reversed(range(idx,n-1)):\n print(x+1)", "x", "reversed(range(idx,n-1))", "reversed", "range(idx,n-1)", "range", "idx", "n-1", "n", "1", "print(x+1)", "print", "x+1", "x", "1", "flag=True", "True", "flag", "flag=False", "False", "flag", "idx=0", "0", "idx", "idx=i", "i", "idx", "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" ]

[ 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, 14, 4, 13, 4, 13, 12, 40, 13, 13, 23, 13, 4, 13, 17, 28, 13, 13, 4, 13, 13, 0, 13, 17, 14, 40, 13, 13, 0, 13, 13, 3, 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, 4, 13, 17, 10, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 117, 2 ], [ 117, 11 ], [ 108, 13 ], [ 27, 26 ], [ 118, 30 ], [ 109, 35 ], [ 26, 36 ], [ 109, 38 ], [ 26, 40 ], [ 105, 43 ], [ 115, 53 ], [ 106, 55 ], [ 106, 64 ], [ 67, 66 ], [ 115, 71 ], [ 111, 73 ], [ 78, 77 ], [ 112, 81 ], [ 77, 84 ], [ 87, 86 ], [ 112, 92 ], [ 118, 94 ], [ 86, 97 ], [ 112, 100 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 117, 115 ], [ 117, 118 ] ]

[ "N, L = map(int, input().split())\nA = list(map(int, input().split()))\n\n\nX = [A[i] + A[i + 1] for i in range(N - 1)]\nif any(map(lambda x: x >= L, X)):\n print('Possible')\n\n for i, x in enumerate(X, start=1):\n if x >= L:\n xi = i\n break\n\n for i in range(1, xi):\n print(i)\n for i in reversed(range(xi + 1, N)):\n print(i)\n print(xi)\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", "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", "X = [A[i] + A[i + 1] for i in range(N - 1)]", "X", "[A[i] + A[i + 1] for i in range(N - 1)]", "if any(map(lambda x: x >= L, X)):\n print('Possible')\n\n for i, x in enumerate(X, start=1):\n if x >= L:\n xi = i\n break\n\n for i in range(1, xi):\n print(i)\n for i in reversed(range(xi + 1, N)):\n print(i)\n print(xi)\n\nelse:\n print('Impossible')", "any(map(lambda x: x >= L, X))", "any", "map(lambda x: x >= L, X)", "map", "lambda x: x >= L", "x >= L", "x", "L", "x", "X", "print('Possible')", "print", "'Possible'", "for i, x in enumerate(X, start=1):\n if x >= L:\n xi = i\n break\n\n ", "i", "x", "enumerate(X, start=1)", "enumerate", "X", "start=1", "start", "1", "if x >= L:\n xi = i\n break\n\n ", "x >= L", "x", "L", "xi = i", "xi", "i", "break", "for i in range(1, xi):\n print(i)\n ", "i", "range(1, xi)", "range", "1", "xi", "print(i)", "print", "i", "for i in reversed(range(xi + 1, N)):\n print(i)\n ", "i", "reversed(range(xi + 1, N))", "reversed", "range(xi + 1, N)", "range", "xi + 1", "xi", "1", "N", "print(i)", "print", "i", "print(xi)", "print", "xi", "print('Impossible')", "print", "'Impossible'", "X = [A[i] + A[i + 1] for i in range(N - 1)]", "[A[i] + A[i + 1] for i in range(N - 1)]", "X", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "xi = i", "i", "xi", "L = map(int, input().split())", "map(int, input().split())", "L", "N, L = map(int, input().split())", "map(int, input().split())", "N" ]

[ 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, 29, 39, 13, 13, 13, 12, 13, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 29, 2, 4, 13, 4, 13, 17, 2, 13, 17, 4, 13, 4, 13, 2, 13, 17, 13, 17, 29, 39, 23, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 13, 0, 13, 4, 13, 13, 13, 13, 14, 13, 4, 13, 17, 28, 13, 13, 4, 13, 13, 4, 13, 17, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 35, 34 ], [ 74, 38 ], [ 78, 44 ], [ 34, 45 ], [ 78, 47 ], [ 34, 49 ], [ 76, 51 ], [ 34, 60 ], [ 74, 67 ], [ 34, 69 ], [ 74, 74 ], [ 76, 76 ], [ 78, 78 ], [ 122, 80 ], [ 111, 82 ], [ 122, 83 ], [ 122, 84 ], [ 116, 86 ], [ 114, 88 ], [ 120, 89 ], [ 108, 90 ], [ 123, 91 ], [ 99, 98 ], [ 117, 98 ], [ 98, 102 ], [ 122, 108 ], [ 116, 117 ], [ 122, 120 ], [ 122, 123 ] ]

[ "def read_data():\n N, L = map(int, input().split())\n As = list(map(int, input().split()))\n return N, L, As\n\ndef solve(N, L, As):\n for i in range(N - 1):\n if As[i] + As[i + 1] >= L:\n return list(range(1, i + 1)) + list(range(N - 1, i, - 1))\n return []\n\nN, L, As = read_data()\nans = solve(N, L, As)\nif ans:\n print(\"Possible\")\n for i in ans:\n print(i)\nelse:\n print(\"Impossible\")", "def read_data():\n N, L = map(int, input().split())\n As = list(map(int, input().split()))\n return N, L, As", "read_data", "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", "return N, L, As", "return N, L, As", "N", "L", "As", "def solve(N, L, As):\n for i in range(N - 1):\n if As[i] + As[i + 1] >= L:\n return list(range(1, i + 1)) + list(range(N - 1, i, - 1))\n return []", "solve", "for i in range(N - 1):\n if As[i] + As[i + 1] >= L:\n return list(range(1, i + 1)) + list(range(N - 1, i, - 1))\n ", "i", "range(N - 1)", "range", "N - 1", "N", "1", "if As[i] + As[i + 1] >= L:\n return list(range(1, i + 1)) + list(range(N - 1, i, - 1))\n ", "As[i] + As[i + 1] >= L", "As[i] + As[i + 1]", "As[i]", "As", "i", "As[i + 1]", "As", "i + 1", "i", "1", "L", "return list(range(1, i + 1)) + list(range(N - 1, i, - 1))", "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", "return []", "[]", "N", "N", "L", "L", "As", "As", "N, L, As = read_data()", "N", "read_data()", "read_data", "L", "As", "ans = solve(N, L, As)", "ans", "solve(N, L, As)", "solve", "N", "L", "As", "if ans:\n print(\"Possible\")\n for i in ans:\n print(i)\nelse:\n print(\"Impossible\")", "ans", "print(\"Possible\")", "print", "\"Possible\"", "for i in ans:\n print(i)", "i", "ans", "print(i)", "print", "i", "print(\"Impossible\")", "print", "\"Impossible\"", "L, As = read_data()", "read_data()", "L", "def read_data():\n N, L = map(int, input().split())\n As = list(map(int, input().split()))\n return N, L, As", "def read_data():\n N, L = map(int, input().split())\n As = list(map(int, input().split()))\n return N, L, As", "read_data", "def solve(N, L, As):\n for i in range(N - 1):\n if As[i] + As[i + 1] >= L:\n return list(range(1, i + 1)) + list(range(N - 1, i, - 1))\n return []", "def solve(N, L, As):\n for i in range(N - 1):\n if As[i] + As[i + 1] >= L:\n return list(range(1, i + 1)) + list(range(N - 1, i, - 1))\n return []", "solve", "ans = solve(N, L, As)", "solve(N, L, As)", "ans", "N, L, As = read_data()", "read_data()", "N", "As = read_data()", "read_data()", "As" ]

[ 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, 2, 13, 17, 4, 13, 2, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13 ]

[ [ 93, 2 ], [ 93, 11 ], [ 96, 13 ], [ 99, 25 ], [ 29, 28 ], [ 91, 32 ], [ 97, 38 ], [ 28, 39 ], [ 97, 41 ], [ 28, 43 ], [ 94, 45 ], [ 102, 47 ], [ 28, 48 ], [ 103, 52 ], [ 100, 52 ], [ 62, 61 ], [ 103, 64 ], [ 100, 64 ], [ 61, 68 ], [ 72, 71 ], [ 91, 75 ], [ 103, 77 ], [ 100, 77 ], [ 71, 82 ], [ 103, 87 ], [ 100, 87 ], [ 93, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 28, 102 ], [ 102, 103 ] ]

[ "n, L = map(int, input().split())\na = list(map(int, input().split()))\nst = -1\nfor i in range(n-1):\n if a[i] + a[i+1] >= L:\n st = i\n break\nif st < 0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(st):\n print(i+1)\n for i in range(n-2, st, -1):\n print(i+1)\n print(st+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", "st = -1", "st", "-1", "for i in range(n-1):\n if a[i] + a[i+1] >= L:\n st = i\n break", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i] + a[i+1] >= L:\n st = 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", "st = i", "st", "i", "break", "if st < 0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(st):\n print(i+1)\n for i in range(n-2, st, -1):\n print(i+1)\n print(st+1)", "st < 0", "st", "0", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(st):\n print(i+1)\n ", "i", "range(st)", "range", "st", "print(i+1)", "print", "i+1", "i", "1", "for i in range(n-2, st, -1):\n print(i+1)\n ", "i", "range(n-2, st, -1)", "range", "n-2", "n", "2", "st", "-1", "print(i+1)", "print", "i+1", "i", "1", "print(st+1)", "print", "st+1", "st", "1", "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", "st = -1", "-1", "st", "st = i", "i", "st" ]

[ 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, 2, 13, 13, 0, 13, 13, 0, 13, 13, 14, 40, 13, 13, 4, 13, 17, 28, 13, 4, 13, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 4, 13, 2, 2, 13, 13, 17, 4, 13, 17, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 13, 13 ]

[ [ 101, 2 ], [ 101, 11 ], [ 107, 13 ], [ 110, 25 ], [ 95, 28 ], [ 32, 31 ], [ 102, 35 ], [ 113, 38 ], [ 108, 41 ], [ 31, 42 ], [ 108, 44 ], [ 31, 46 ], [ 114, 50 ], [ 111, 51 ], [ 117, 51 ], [ 116, 53 ], [ 114, 54 ], [ 104, 56 ], [ 31, 57 ], [ 117, 60 ], [ 111, 60 ], [ 99, 61 ], [ 67, 66 ], [ 105, 69 ], [ 96, 69 ], [ 66, 73 ], [ 77, 76 ], [ 102, 81 ], [ 105, 82 ], [ 96, 82 ], [ 102, 88 ], [ 76, 89 ], [ 95, 96 ], [ 101, 99 ], [ 101, 102 ], [ 31, 104 ], [ 104, 105 ], [ 107, 108 ], [ 110, 111 ], [ 113, 114 ], [ 114, 116 ], [ 116, 117 ] ]

[ "n,l = map(int, input().split())\na = list(map(int, input().split()))\nMAX = 0\nMAX_i = 0\nfor i in range(n-1):\n now = a[i] + a[i+1]\n if now > MAX:\n MAX = now\n MAX_i = i\nif MAX >= l:\n print(\"Possible\")\n for i in range(MAX_i):\n print(i+1)\n for i in range(n-MAX_i-1):\n print(n-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", "MAX = 0", "MAX", "0", "MAX_i = 0", "MAX_i", "0", "for i in range(n-1):\n now = a[i] + a[i+1]\n if now > MAX:\n MAX = now\n MAX_i = i", "i", "range(n-1)", "range", "n-1", "n", "1", "now = a[i] + a[i+1]", "now", "a[i] + a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "if now > MAX:\n MAX = now\n MAX_i = i", "now > MAX", "now", "MAX", "MAX = now", "MAX", "now", "MAX_i = i", "MAX_i", "i", "if MAX >= l:\n print(\"Possible\")\n for i in range(MAX_i):\n print(i+1)\n for i in range(n-MAX_i-1):\n print(n-i-1)\nelse:\n print(\"Impossible\")", "MAX >= l", "MAX", "l", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(MAX_i):\n print(i+1)\n ", "i", "range(MAX_i)", "range", "MAX_i", "print(i+1)", "print", "i+1", "i", "1", "for i in range(n-MAX_i-1):\n print(n-i-1)", "i", "range(n-MAX_i-1)", "range", "n-MAX_i-1", "n-MAX_i", "n", "MAX_i", "1", "print(n-i-1)", "print", "n-i-1", "n-i", "n", "i", "1", "print(\"Impossible\")", "print", "\"Impossible\"", "MAX_i = 0", "0", "MAX_i", "l = map(int, input().split())", "map(int, input().split())", "l", "n,l = map(int, input().split())", "map(int, input().split())", "n", "MAX_i = i", "i", "MAX_i", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "MAX = 0", "0", "MAX", "now = a[i] + a[i+1]", "a[i] + a[i+1]", "now", "MAX = now", "now", "MAX" ]

[ 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, 2, 13, 17, 14, 2, 13, 17, 4, 13, 17, 4, 13, 0, 13, 4, 13, 4, 13, 17, 13, 4, 13, 17, 0, 13, 17, 42, 2, 13, 13, 4, 13, 13, 0, 13, 17, 0, 13, 2, 13, 17, 42, 2, 13, 13, 4, 13, 13, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13 ]

[ [ 115, 2 ], [ 115, 11 ], [ 130, 13 ], [ 109, 25 ], [ 136, 28 ], [ 32, 31 ], [ 107, 35 ], [ 131, 41 ], [ 31, 42 ], [ 131, 44 ], [ 31, 46 ], [ 116, 48 ], [ 127, 50 ], [ 31, 52 ], [ 128, 56 ], [ 137, 56 ], [ 124, 64 ], [ 107, 70 ], [ 112, 75 ], [ 113, 79 ], [ 119, 79 ], [ 128, 80 ], [ 137, 80 ], [ 113, 83 ], [ 119, 83 ], [ 118, 85 ], [ 121, 88 ], [ 107, 90 ], [ 122, 94 ], [ 119, 94 ], [ 113, 94 ], [ 134, 94 ], [ 128, 95 ], [ 137, 95 ], [ 122, 98 ], [ 119, 98 ], [ 113, 98 ], [ 134, 98 ], [ 133, 100 ], [ 128, 104 ], [ 137, 104 ], [ 115, 107 ], [ 109, 110 ], [ 112, 113 ], [ 115, 116 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ], [ 127, 128 ], [ 130, 131 ], [ 133, 134 ], [ 136, 137 ] ]

[ "# coding: utf-8\nN, L = map(int, input().split())\nA = list(map(int, input().split()))\nflag = True\nl = -1\nfor i in range(N-1):\n if A[i] + A[i+1] >= L:\n l = i+1\nif l < 0:\n print(\"Impossible\")\n exit()\nknot = list(range(1, N))\nprint(\"Possible\")\nidx = 1\nwhile idx < l:\n print(idx)\n idx += 1\nidx = N-1\nwhile idx > l:\n print(idx)\n idx -= 1\nprint(l)", "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 = True", "flag", "True", "l = -1", "l", "-1", "for i in range(N-1):\n if A[i] + A[i+1] >= L:\n l = i+1", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i] + A[i+1] >= L:\n l = 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", "l = i+1", "l", "i+1", "i", "1", "if l < 0:\n print(\"Impossible\")\n exit()", "l < 0", "l", "0", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "knot = list(range(1, N))", "knot", "list(range(1, N))", "list", "range(1, N)", "range", "1", "N", "print(\"Possible\")", "print", "\"Possible\"", "idx = 1", "idx", "1", "while idx < l:\n print(idx)\n idx += 1", "idx < l", "idx", "l", "print(idx)", "print", "idx", "idx += 1", "idx", "1", "idx = N-1", "idx", "N-1", "N", "1", "while idx > l:\n print(idx)\n idx -= 1", "idx > l", "idx", "l", "print(idx)", "print", "idx", "idx -= 1", "idx", "1", "print(l)", "print", "l", "N, L = map(int, input().split())", "map(int, input().split())", "N", "flag = True", "True", "flag", "idx = 1", "1", "idx", "L = map(int, input().split())", "map(int, input().split())", "L", "idx += 1", "1", "idx", "idx = N-1", "N-1", "idx", "knot = list(range(1, N))", "list(range(1, N))", "knot", "l = i+1", "i+1", "l", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "idx -= 1", "1", "idx", "l = -1", "-1", "l" ]

[ 7, 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, 18, 4, 18, 18, 13, 13, 13, 13, 0, 13, 12, 4, 13, 8, 13, 39, 4, 13, 17, 4, 13, 17, 23, 0, 13, 12, 4, 13, 8, 13, 39, 4, 13, 17, 4, 13, 17, 23, 0, 13, 12, 2, 4, 13, 13, 17, 23, 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, 2, 13, 17, 4, 13, 2, 13, 17, 3, 4, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 172, 11 ], [ 175, 16 ], [ 169, 23 ], [ 166, 35 ], [ 160, 50 ], [ 163, 65 ], [ 77, 76 ], [ 170, 83 ], [ 77, 85 ], [ 88, 87 ], [ 170, 96 ], [ 100, 99 ], [ 76, 103 ], [ 87, 109 ], [ 99, 110 ], [ 87, 112 ], [ 99, 114 ], [ 85, 116 ], [ 122, 121 ], [ 99, 124 ], [ 121, 128 ], [ 132, 131 ], [ 76, 135 ], [ 99, 137 ], [ 131, 142 ], [ 99, 147 ], [ 179, 158 ], [ 160, 161 ], [ 163, 164 ], [ 166, 167 ], [ 169, 170 ], [ 172, 173 ], [ 175, 176 ] ]

[ "# -*- coding: utf-8 -*-\nimport sys\nsys.setrecursionlimit(10**9)\nINF=10**18\nMOD=10**9+7\ninput=lambda: sys.stdin.readline().rstrip()\nYesNo=lambda b: bool([print('Yes')] if b else print('No'))\nYESNO=lambda b: bool([print('YES')] if b else print('NO'))\nint1=lambda x:int(x)-1\n\ndef main():\n N,L=map(int,input().split())\n a=tuple(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-2,i,-1):\n print(j+1)\n print(i+1)\n break\n else:\n print('Impossible')\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "sys.setrecursionlimit(10**9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**9", "10", "9", "INF=10**18", "INF", "10**18", "10", "18", "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", "YesNo=lambda b: bool([print('Yes')] if b else print('No'))", "YesNo", "lambda b: bool([print('Yes')] if b else print('No'))", "bool([print('Yes')] if b else print('No'))", "bool", "[print('Yes')] if b else print('No')", "b", "[print('Yes')]", "print('Yes')", "print", "'Yes'", "print('No')", "print", "'No'", "b", "YESNO=lambda b: bool([print('YES')] if b else print('NO'))", "YESNO", "lambda b: bool([print('YES')] if b else print('NO'))", "bool([print('YES')] if b else print('NO'))", "bool", "[print('YES')] if b else print('NO')", "b", "[print('YES')]", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "b", "int1=lambda x:int(x)-1", "int1", "lambda x:int(x)-1", "int(x)-1", "int(x)", "int", "x", "1", "x", "def main():\n N,L=map(int,input().split())\n a=tuple(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-2,i,-1):\n print(j+1)\n print(i+1)\n break\n else:\n print('Impossible')", "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", "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):\n print(j+1)\n print(i+1)\n break\n else:\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(i):\n print(j+1)\n for j in range(N-2,i,-1):\n print(j+1)\n print(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", "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):\n print(j+1)\n ", "j", "range(N-2,i,-1)", "range", "N-2", "N", "2", "i", "-1", "print(j+1)", "print", "j+1", "j", "1", "print(i+1)", "print", "i+1", "i", "1", "break", "print('Impossible')", "print", "'Impossible'", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "YESNO=lambda b: bool([print('YES')] if b else print('NO'))", "lambda b: bool([print('YES')] if b else print('NO'))", "YESNO", "int1=lambda x:int(x)-1", "lambda x:int(x)-1", "int1", "YesNo=lambda b: bool([print('Yes')] if b else print('No'))", "lambda b: bool([print('Yes')] if b else print('No'))", "YesNo", "input=lambda: sys.stdin.readline().rstrip()", "lambda: sys.stdin.readline().rstrip()", "input", "INF=10**18", "10**18", "INF", "MOD=10**9+7", "10**9+7", "MOD", "def main():\n N,L=map(int,input().split())\n a=tuple(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-2,i,-1):\n print(j+1)\n print(i+1)\n break\n else:\n print('Impossible')", "def main():\n N,L=map(int,input().split())\n a=tuple(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-2,i,-1):\n print(j+1)\n print(i+1)\n break\n else:\n print('Impossible')", "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, 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, 17, 0, 13, 13, 3, 14, 13, 4, 13, 17, 28, 13, 4, 13, 17, 13, 14, 2, 13, 13, 3, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 17, 17, 14, 2, 13, 13, 3, 4, 13, 13, 4, 13, 13, 4, 13, 17, 10, 13, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 115, 2 ], [ 115, 11 ], [ 118, 13 ], [ 109, 25 ], [ 119, 28 ], [ 112, 30 ], [ 34, 33 ], [ 107, 37 ], [ 119, 42 ], [ 33, 43 ], [ 119, 45 ], [ 33, 47 ], [ 116, 49 ], [ 103, 51 ], [ 100, 54 ], [ 33, 55 ], [ 64, 63 ], [ 107, 67 ], [ 101, 70 ], [ 63, 71 ], [ 63, 75 ], [ 78, 77 ], [ 107, 81 ], [ 101, 87 ], [ 77, 88 ], [ 77, 92 ], [ 101, 95 ], [ 33, 100 ], [ 100, 101 ], [ 103, 104 ], [ 115, 107 ], [ 109, 110 ], [ 112, 113 ], [ 115, 116 ], [ 118, 119 ] ]

[ "N,L=map(int,input().split())\na=list(map(int,input().split()))\nsuma=sum(a)\nflag=0\nfor i in range(1,N):\n if a[i]+a[i-1]>=L:\n flag=1\n idx=i\n break\nif flag:\n print(\"Possible\")\n for i in range(1,N):\n if idx==i:\n break\n else:\n print(i)\n for i in range(N-1,0,-1):\n if idx==i:\n break\n else:\n print(i)\n print(idx)\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", "suma=sum(a)", "suma", "sum(a)", "sum", "a", "flag=0", "flag", "0", "for i in range(1,N):\n if a[i]+a[i-1]>=L:\n flag=1\n idx=i\n break", "i", "range(1,N)", "range", "1", "N", "if a[i]+a[i-1]>=L:\n flag=1\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", "flag=1", "flag", "1", "idx=i", "idx", "i", "break", "if flag:\n print(\"Possible\")\n for i in range(1,N):\n if idx==i:\n break\n else:\n print(i)\n for i in range(N-1,0,-1):\n if idx==i:\n break\n else:\n print(i)\n print(idx)\nelse:\n print(\"Impossible\")", "flag", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,N):\n if idx==i:\n break\n else:\n print(i)\n ", "i", "range(1,N)", "range", "1", "N", "if idx==i:\n break\n else:\n print(i)\n ", "idx==i", "idx", "i", "break", "print(i)", "print", "i", "for i in range(N-1,0,-1):\n if idx==i:\n break\n else:\n print(i)\n ", "i", "range(N-1,0,-1)", "range", "N-1", "N", "1", "0", "-1", "if idx==i:\n break\n else:\n print(i)\n ", "idx==i", "idx", "i", "break", "print(i)", "print", "i", "print(idx)", "print", "idx", "print(\"Impossible\")", "print", "\"Impossible\"", "idx=i", "i", "idx", "flag=1", "1", "flag", "N,L=map(int,input().split())", "map(int,input().split())", "N", "suma=sum(a)", "sum(a)", "suma", "flag=0", "0", "flag", "L=map(int,input().split())", "map(int,input().split())", "L", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a" ]

[ 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, 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, 0, 13, 39, 28, 13, 4, 13, 2, 13, 17, 13, 4, 18, 13, 13, 13, 4, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 4, 13, 13, 4, 13, 18, 13, 13, 4, 13, 2, 13, 17, 3, 4, 13, 17, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 113, 2 ], [ 113, 11 ], [ 110, 13 ], [ 26, 25 ], [ 114, 30 ], [ 111, 36 ], [ 25, 37 ], [ 111, 39 ], [ 25, 41 ], [ 108, 43 ], [ 49, 48 ], [ 25, 53 ], [ 48, 57 ], [ 104, 59 ], [ 63, 62 ], [ 25, 66 ], [ 114, 68 ], [ 105, 71 ], [ 62, 73 ], [ 105, 76 ], [ 80, 79 ], [ 83, 82 ], [ 105, 88 ], [ 105, 92 ], [ 82, 93 ], [ 25, 97 ], [ 104, 105 ], [ 113, 108 ], [ 110, 111 ], [ 113, 114 ] ]

[ "N,L=map(int,input().split())\nA=list(map(int,input().split()))\n\nfor i in range(0,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 T=[]\n for j in range(i+2,N):\n T.append(j)\n T.sort(reverse=True)\n for j in range(0,len(T)):\n print(T[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", "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(0,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 T=[]\n for j in range(i+2,N):\n T.append(j)\n T.sort(reverse=True)\n for j in range(0,len(T)):\n print(T[j])\n print(i+1)\n break\nelse:\n print('Impossible')", "i", "range(0,N-1)", "range", "0", "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 T=[]\n for j in range(i+2,N):\n T.append(j)\n T.sort(reverse=True)\n for j in range(0,len(T)):\n print(T[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", "T=[]", "T", "[]", "for j in range(i+2,N):\n T.append(j)\n ", "j", "range(i+2,N)", "range", "i+2", "i", "2", "N", "T.append(j)", "T.append", "T", "append", "j", "T.sort(reverse=True)", "T.sort", "T", "sort", "reverse=True", "reverse", "True", "for j in range(0,len(T)):\n print(T[j])\n ", "j", "range(0,len(T))", "range", "0", "len(T)", "len", "T", "print(T[j])", "print", "T[j]", "T", "j", "print(i+1)", "print", "i+1", "i", "1", "break", "print('Impossible')", "print", "'Impossible'", "T=[]", "[]", "T", "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" ]

[ 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, 14, 2, 13, 17, 4, 13, 17, 4, 13, 0, 13, 39, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 4, 18, 13, 13, 2, 13, 17, 28, 13, 4, 13, 4, 13, 13, 4, 18, 13, 13, 2, 13, 17, 4, 18, 13, 13, 4, 13, 17, 4, 13, 31, 13, 0, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 39, 13, 10, 13, 13 ]

[ [ 113, 2 ], [ 113, 11 ], [ 116, 13 ], [ 119, 25 ], [ 29, 28 ], [ 114, 32 ], [ 117, 38 ], [ 28, 39 ], [ 117, 41 ], [ 28, 43 ], [ 111, 45 ], [ 125, 47 ], [ 28, 48 ], [ 126, 51 ], [ 120, 51 ], [ 122, 59 ], [ 126, 62 ], [ 120, 62 ], [ 66, 65 ], [ 126, 69 ], [ 120, 69 ], [ 114, 72 ], [ 123, 76 ], [ 65, 79 ], [ 83, 82 ], [ 126, 87 ], [ 120, 87 ], [ 123, 90 ], [ 82, 93 ], [ 123, 97 ], [ 123, 105 ], [ 108, 107 ], [ 113, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 28, 125 ], [ 125, 126 ] ]

[ "N, L = map(int, input().split())\nA = list(map(int, input().split()))\n\nstart = -1\nfor i in range(N-1):\n if A[i] + A[i + 1] >= L:\n start = i\nif start < 0:\n print(\"Impossible\")\n exit()\n\nans = [start + 1]\nfor i in range(start + 1, N - 1):\n ans.append(i+1)\nfor i in reversed(range(start)):\n ans.append(i+1)\n\nans.reverse()\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", "start = -1", "start", "-1", "for i in range(N-1):\n if A[i] + A[i + 1] >= L:\n start = i", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i] + A[i + 1] >= L:\n start = 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", "start = i", "start", "i", "if start < 0:\n print(\"Impossible\")\n exit()", "start < 0", "start", "0", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "ans = [start + 1]", "ans", "[start + 1]", "start + 1", "start", "1", "for i in range(start + 1, N - 1):\n ans.append(i+1)", "i", "range(start + 1, N - 1)", "range", "start + 1", "start", "1", "N - 1", "N", "1", "ans.append(i+1)", "ans.append", "ans", "append", "i+1", "i", "1", "for i in reversed(range(start)):\n ans.append(i+1)", "i", "reversed(range(start))", "reversed", "range(start)", "range", "start", "ans.append(i+1)", "ans.append", "ans", "append", "i+1", "i", "1", "ans.reverse()", "ans.reverse", "ans", "reverse", "print(\"Possible\")", "print", "\"Possible\"", "print(*ans, sep=\"\\n\")", "print", "*ans", "ans", "sep=\"\\n\"", "sep", "\"\\n\"", "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", "start = -1", "-1", "start", "ans = [start + 1]", "[start + 1]", "ans", "start = i", "i", "start" ]

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 17, 13, 13, 13, 31, 13, 41, 28, 13, 13, 4, 13, 13, 18, 13, 39, 17, 4, 2, 13, 13, 0, 13, 13, 0, 13, 4, 13, 13, 14, 2, 13, 13, 4, 13, 17, 29, 0, 13, 2, 4, 18, 13, 13, 13, 17, 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, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 17 ], [ 5, 18 ], [ 37, 36 ], [ 40, 39 ], [ 36, 42 ], [ 39, 45 ], [ 17, 46 ], [ 53, 52 ], [ 36, 56 ], [ 39, 58 ], [ 63, 62 ], [ 52, 66 ], [ 62, 68 ], [ 71, 70 ], [ 70, 89 ], [ 98, 95 ] ]

[ "# AGC002C - Knot Puzzle\ndef main():\n N, L, *A = map(int, open(0).read().split())\n B = [i + j for i, j in zip(A, A[1:])]\n x = max(B)\n if x < L: # corner case\n print(\"Impossible\")\n return\n idx = B.index(x) + 1\n # keep the biggest one until the end\n ans = [i for i in range(1, idx)] + [i for i in range(N - 1, idx, -1)] + [idx]\n print(\"Possible\")\n print(\"\\n\".join(map(str, ans)))\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n N, L, *A = map(int, open(0).read().split())\n B = [i + j for i, j in zip(A, A[1:])]\n x = max(B)\n if x < L: # corner case\n print(\"Impossible\")\n return\n idx = B.index(x) + 1\n # keep the biggest one until the end\n ans = [i for i in range(1, idx)] + [i for i in range(N - 1, idx, -1)] + [idx]\n print(\"Possible\")\n print(\"\\n\".join(map(str, ans)))", "main", "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 + 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:])]", "x = max(B)", "x", "max(B)", "max", "B", "if x < L: # corner case\n print(\"Impossible\")\n return\n ", "x < L", "x", "L", "print(\"Impossible\")", "print", "\"Impossible\"", "return", "idx = B.index(x) + 1", "idx", "B.index(x) + 1", "B.index(x)", "B.index", "B", "index", "x", "1", "i for i in range(1, idx)", "for i in range(1, idx)", "i", "range(1, idx)", "range", "1", "idx", "for i in range(1, idx)", "i", "ans = [i for i in range(1, idx)] + [i for i in range(N - 1, idx, -1)] + [idx]", "ans", "[i for i in range(1, idx)] + [i for i in range(N - 1, idx, -1)] + [idx]", "[i for i in range(1, idx)] + [i for i in range(N - 1, idx, -1)]", "[i for i in range(1, idx)]", "[i for i in range(N - 1, idx, -1)]", "[idx]", "idx", "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", "def main():\n N, L, *A = map(int, open(0).read().split())\n B = [i + j for i, j in zip(A, A[1:])]\n x = max(B)\n if x < L: # corner case\n print(\"Impossible\")\n return\n idx = B.index(x) + 1\n # keep the biggest one until the end\n ans = [i for i in range(1, idx)] + [i for i in range(N - 1, idx, -1)] + [idx]\n print(\"Possible\")\n print(\"\\n\".join(map(str, ans)))", "def main():\n N, L, *A = map(int, open(0).read().split())\n B = [i + j for i, j in zip(A, A[1:])]\n x = max(B)\n if x < L: # corner case\n print(\"Impossible\")\n return\n idx = B.index(x) + 1\n # keep the biggest one until the end\n ans = [i for i in range(1, idx)] + [i for i in range(N - 1, idx, -1)] + [idx]\n print(\"Possible\")\n print(\"\\n\".join(map(str, ans)))", "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, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 17, 3, 14, 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, 17, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13 ]

[ [ 94, 2 ], [ 94, 11 ], [ 15, 14 ], [ 14, 23 ], [ 88, 25 ], [ 97, 28 ], [ 32, 31 ], [ 92, 35 ], [ 89, 41 ], [ 31, 42 ], [ 89, 44 ], [ 31, 46 ], [ 95, 48 ], [ 100, 50 ], [ 60, 59 ], [ 59, 66 ], [ 70, 69 ], [ 92, 73 ], [ 69, 82 ], [ 88, 89 ], [ 94, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ] ]

[ "N, L = map(int, input().split())\na = [int(x) for x in input().split()]\n\nans = False\nfor i in range(N-1):\n if a[i] + a[i+1] >= L:\n ans = True\n break\nif ans:\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)\nelse:\n print('Impossible')", "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()]", "ans = False", "ans", "False", "for i in range(N-1):\n if a[i] + a[i+1] >= L:\n ans = True\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if a[i] + a[i+1] >= L:\n ans = True\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 = True", "ans", "True", "break", "if ans:\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)\nelse:\n print('Impossible')", "ans", "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)", "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", "print('Impossible')", "print", "'Impossible'", "a = [int(x) for x in input().split()]", "[int(x) for x 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", "ans = False", "False", "ans", "ans = True", "True", "ans" ]

[ 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, 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, 4, 13, 17, 4, 13, 17, 4, 13, 17, 4, 13, 31, 4, 13, 17, 13, 0, 13, 17, 4, 13, 31, 4, 13, 2, 13, 17, 13, 17, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 104, 2 ], [ 104, 11 ], [ 95, 13 ], [ 98, 25 ], [ 31, 30 ], [ 93, 34 ], [ 96, 40 ], [ 30, 41 ], [ 96, 43 ], [ 30, 45 ], [ 105, 47 ], [ 101, 49 ], [ 30, 51 ], [ 102, 55 ], [ 99, 55 ], [ 102, 71 ], [ 99, 71 ], [ 74, 73 ], [ 93, 81 ], [ 102, 83 ], [ 99, 83 ], [ 87, 86 ], [ 102, 90 ], [ 99, 90 ], [ 104, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ] ]

[ "n, l = map(int, input().split())\na = list(map(int, input().split()))\nans = float(\"inf\")\nfor i in range(n - 1):\n if a[i] + a[i + 1] >= l:\n ans = i + 1\nif ans == float(\"inf\"):\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n print(*range(1, ans), sep=\"\\n\")\n print(*range(n - 1, ans, -1), sep=\"\\n\")\n print(ans)", "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 = float(\"inf\")", "ans", "float(\"inf\")", "float", "\"inf\"", "for i in range(n - 1):\n if a[i] + a[i + 1] >= l:\n ans = i + 1", "i", "range(n - 1)", "range", "n - 1", "n", "1", "if a[i] + a[i + 1] >= l:\n ans = 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", "ans = i + 1", "ans", "i + 1", "i", "1", "if ans == float(\"inf\"):\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n print(*range(1, ans), sep=\"\\n\")\n print(*range(n - 1, ans, -1), sep=\"\\n\")\n print(ans)", "ans == float(\"inf\")", "ans", "float(\"inf\")", "float", "\"inf\"", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "print(*range(1, ans), sep=\"\\n\")", "print", "*range(1, ans)", "range(1, ans)", "range", "1", "ans", "sep=\"\\n\"", "sep", "\"\\n\"", "print(*range(n - 1, ans, -1), sep=\"\\n\")", "print", "*range(n - 1, ans, -1)", "range(n - 1, ans, -1)", "range", "n - 1", "n", "1", "ans", "-1", "sep=\"\\n\"", "sep", "\"\\n\"", "print(ans)", "print", "ans", "n, l = map(int, input().split())", "map(int, input().split())", "n", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "ans = float(\"inf\")", "float(\"inf\")", "ans", "ans = i + 1", "i + 1", "ans", "l = map(int, input().split())", "map(int, input().split())", "l" ]

[ 7, 15, 13, 12, 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, 4, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 2, 13, 13, 3, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 17, 17, 14, 2, 13, 13, 3, 4, 13, 2, 13, 17, 4, 13, 2, 13, 17, 23, 13, 23, 13, 23, 13, 14, 2, 13, 17, 0, 13, 18, 18, 13, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 31, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 13, 13, 13, 13, 10, 12, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 7, 6 ], [ 74, 10 ], [ 78, 16 ], [ 6, 17 ], [ 78, 19 ], [ 6, 21 ], [ 76, 23 ], [ 34, 33 ], [ 74, 37 ], [ 33, 41 ], [ 33, 47 ], [ 51, 50 ], [ 74, 54 ], [ 50, 60 ], [ 50, 66 ], [ 74, 74 ], [ 76, 76 ], [ 78, 78 ], [ 121, 84 ], [ 127, 91 ], [ 122, 98 ], [ 127, 100 ], [ 104, 102 ], [ 122, 110 ], [ 119, 113 ], [ 128, 114 ], [ 125, 115 ], [ 121, 122 ], [ 127, 125 ], [ 127, 128 ] ]

[ "# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)\nimport sys\ndef main(N, L, A):\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 print('Possible')\n for j in range(N - 1):\n if j == i:\n break\n print(j + 1)\n for j in range(N - 2, -1, -1):\n if j == i:\n break\n print(j + 1)\n print(i + 1)\n\nif __name__ == '__main__':\n input = sys.stdin.readline\n N, L = map(int, input().split())\n *A, = map(int, input().split())\n main(N, L, A)", "import sys", "sys", "def main(N, L, A):\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 print('Possible')\n for j in range(N - 1):\n if j == i:\n break\n print(j + 1)\n for j in range(N - 2, -1, -1):\n if j == i:\n break\n print(j + 1)\n print(i + 1)", "main", "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", "print('Possible')", "print", "'Possible'", "for j in range(N - 1):\n if j == i:\n break\n print(j + 1)\n ", "j", "range(N - 1)", "range", "N - 1", "N", "1", "if j == i:\n break\n ", "j == i", "j", "i", "break", "print(j + 1)", "print", "j + 1", "j", "1", "for j in range(N - 2, -1, -1):\n if j == i:\n break\n print(j + 1)\n ", "j", "range(N - 2, -1, -1)", "range", "N - 2", "N", "2", "-1", "-1", "if j == i:\n break\n ", "j == i", "j", "i", "break", "print(j + 1)", "print", "j + 1", "j", "1", "print(i + 1)", "print", "i + 1", "i", "1", "N", "N", "L", "L", "A", "A", "if __name__ == '__main__':\n input = sys.stdin.readline\n N, L = map(int, input().split())\n *A, = map(int, input().split())\n main(N, L, A)", "__name__ == '__main__'", "__name__", "'__main__'", "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, = map(int, input().split())", "*A", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "main(N, L, A)", "main", "N", "L", "A", "def main(N, L, A):\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 print('Possible')\n for j in range(N - 1):\n if j == i:\n break\n print(j + 1)\n for j in range(N - 2, -1, -1):\n if j == i:\n break\n print(j + 1)\n print(i + 1)", "def main(N, L, A):\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 print('Possible')\n for j in range(N - 1):\n if j == i:\n break\n print(j + 1)\n for j in range(N - 2, -1, -1):\n if j == i:\n break\n print(j + 1)\n print(i + 1)", "main", "input = sys.stdin.readline", "sys.stdin.readline", "input", "L = map(int, input().split())", "map(int, input().split())", "L", "N, L = map(int, input().split())", "map(int, input().split())", "N" ]

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 17, 13, 13, 13, 31, 13, 41, 28, 13, 39, 13, 13, 4, 13, 4, 13, 13, 18, 13, 39, 17, 17, 40, 2, 13, 13, 13, 4, 13, 0, 13, 13, 14, 13, 4, 13, 17, 41, 28, 13, 4, 13, 18, 13, 17, 13, 4, 13, 0, 13, 2, 13, 18, 13, 39, 17, 4, 13, 31, 18, 13, 39, 17, 0, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 17 ], [ 5, 18 ], [ 17, 40 ], [ 45, 44 ], [ 54, 53 ], [ 44, 57 ], [ 17, 57 ], [ 4, 59 ], [ 53, 61 ], [ 64, 63 ], [ 63, 74 ], [ 79, 78 ], [ 91, 88 ] ]

[ "def main():\n N, L, *A = map(int, open(0).read().split())\n L = [i for i,(x,y) in enumerate(zip(A, A[1:]), 1) if x+y >= L]\n if L:\n print(\"Possible\")\n B = [i for i in range(L[0], N)]+[i for i in range(1,L[0])][::-1]\n print(*B[::-1], sep=\"\\n\")\n else:\n print(\"Impossible\")\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n N, L, *A = map(int, open(0).read().split())\n L = [i for i,(x,y) in enumerate(zip(A, A[1:]), 1) if x+y >= L]\n if L:\n print(\"Possible\")\n B = [i for i in range(L[0], N)]+[i for i in range(1,L[0])][::-1]\n print(*B[::-1], sep=\"\\n\")\n else:\n print(\"Impossible\")", "main", "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 for i,(x,y) in enumerate(zip(A, A[1:]), 1) if x+y >= L", "for i,(x,y) in enumerate(zip(A, A[1:]), 1) if x+y >= L", "i", "(x,y)", "x", "y", "enumerate(zip(A, A[1:]), 1)", "enumerate", "zip(A, A[1:])", "zip", "A", "A[1:]", "A", "1:", "1", "1", "x+y >= L", "x+y", "x", "y", "L", "if x+y >= L", "i", "L = [i for i,(x,y) in enumerate(zip(A, A[1:]), 1) if x+y >= L]", "L", "[i for i,(x,y) in enumerate(zip(A, A[1:]), 1) if x+y >= L]", "if L:\n print(\"Possible\")\n B = [i for i in range(L[0], N)]+[i for i in range(1,L[0])][::-1]\n print(*B[::-1], sep=\"\\n\")\n else:\n print(\"Impossible\")", "L", "print(\"Possible\")", "print", "\"Possible\"", "i for i in range(L[0], N)", "for i in range(L[0], N)", "i", "range(L[0], N)", "range", "L[0]", "L", "0", "N", "for i in range(L[0], N)", "i", "B = [i for i in range(L[0], N)]+[i for i in range(1,L[0])][::-1]", "B", "[i for i in range(L[0], N)]+[i for i in range(1,L[0])][::-1]", "[i for i in range(L[0], N)]", "[i for i in range(1,L[0])][::-1]", "[i for i in range(1,L[0])]", "::-1", "-1", "print(*B[::-1], sep=\"\\n\")", "print", "*B[::-1]", "B[::-1]", "B", "::-1", "-1", "sep=\"\\n\"", "sep", "\"\\n\"", "print(\"Impossible\")", "print", "\"Impossible\"", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n N, L, *A = map(int, open(0).read().split())\n L = [i for i,(x,y) in enumerate(zip(A, A[1:]), 1) if x+y >= L]\n if L:\n print(\"Possible\")\n B = [i for i in range(L[0], N)]+[i for i in range(1,L[0])][::-1]\n print(*B[::-1], sep=\"\\n\")\n else:\n print(\"Impossible\")", "def main():\n N, L, *A = map(int, open(0).read().split())\n L = [i for i,(x,y) in enumerate(zip(A, A[1:]), 1) if x+y >= L]\n if L:\n print(\"Possible\")\n B = [i for i in range(L[0], N)]+[i for i in range(1,L[0])][::-1]\n print(*B[::-1], sep=\"\\n\")\n else:\n print(\"Impossible\")", "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, 41, 28, 13, 4, 13, 2, 13, 17, 4, 2, 18, 13, 13, 18, 13, 2, 13, 17, 0, 13, 13, 0, 13, 17, 28, 13, 13, 4, 13, 13, 14, 40, 13, 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, 18, 4, 13, 13, 13, 39, 17, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 108, 2 ], [ 108, 11 ], [ 99, 13 ], [ 27, 26 ], [ 109, 30 ], [ 100, 35 ], [ 26, 36 ], [ 100, 38 ], [ 26, 40 ], [ 96, 43 ], [ 111, 46 ], [ 97, 53 ], [ 106, 57 ], [ 102, 59 ], [ 103, 66 ], [ 112, 66 ], [ 76, 75 ], [ 103, 79 ], [ 112, 79 ], [ 75, 82 ], [ 85, 84 ], [ 103, 88 ], [ 112, 88 ], [ 109, 89 ], [ 84, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ], [ 108, 106 ], [ 108, 109 ], [ 111, 112 ] ]

[ "n, l = map(int, input().split())\na = list(map(int, input().split()))\nb = [a[i]+a[i+1] for i in range(n-1)]\nstart = -1\nfor ind, length in enumerate(b):\n if length >= l:\n start = ind+1\n break\nif start<0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,start):\n print(i)\n for i in range(start, n)[::-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[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", "b = [a[i]+a[i+1] for i in range(n-1)]", "b", "[a[i]+a[i+1] for i in range(n-1)]", "start = -1", "start", "-1", "for ind, length in enumerate(b):\n if length >= l:\n start = ind+1\n break", "ind", "length", "enumerate(b)", "enumerate", "b", "if length >= l:\n start = ind+1\n break", "length >= l", "length", "l", "start = ind+1", "start", "ind+1", "ind", "1", "break", "if start<0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,start):\n print(i)\n for i in range(start, n)[::-1]:\n print(i)", "start<0", "start", "0", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,start):\n print(i)\n ", "i", "range(1,start)", "range", "1", "start", "print(i)", "print", "i", "for i in range(start, n)[::-1]:\n print(i)", "i", "range(start, n)[::-1]", "(start, n)", "range", "start", "n", "::-1", "-1", "print(i)", "print", "i", "b = [a[i]+a[i+1] for i in range(n-1)]", "[a[i]+a[i+1] for i in range(n-1)]", "b", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "start = ind+1", "ind+1", "start", "l = map(int, input().split())", "map(int, input().split())", "l", "n, l = map(int, input().split())", "map(int, input().split())", "n", "start = -1", "-1", "start" ]

[ 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, 40, 2, 18, 13, 17, 18, 13, 17, 13, 4, 13, 17, 28, 13, 4, 13, 2, 13, 17, 17, 17, 4, 13, 14, 40, 2, 18, 13, 17, 18, 13, 17, 13, 4, 13, 17, 28, 13, 4, 13, 17, 13, 4, 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, 28, 13, 4, 13, 17, 13, 28, 13, 4, 13, 2, 13, 17, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13 ]

[ [ 126, 2 ], [ 126, 11 ], [ 123, 13 ], [ 124, 28 ], [ 124, 31 ], [ 127, 33 ], [ 39, 38 ], [ 121, 42 ], [ 124, 52 ], [ 124, 55 ], [ 127, 57 ], [ 63, 62 ], [ 121, 66 ], [ 132, 70 ], [ 74, 73 ], [ 121, 77 ], [ 124, 82 ], [ 73, 84 ], [ 124, 87 ], [ 73, 88 ], [ 127, 89 ], [ 129, 91 ], [ 73, 92 ], [ 130, 96 ], [ 133, 96 ], [ 103, 102 ], [ 130, 106 ], [ 133, 106 ], [ 109, 108 ], [ 121, 112 ], [ 130, 114 ], [ 133, 114 ], [ 130, 118 ], [ 133, 118 ], [ 126, 121 ], [ 123, 124 ], [ 126, 127 ], [ 73, 129 ], [ 129, 130 ], [ 132, 133 ] ]

[ "n,l=map(int,input().split())\na=list(map(int,input().split()))\nif a[0]+a[1]>=l:\n print(\"Possible\")\n for i in range(n-1,0,-1):print(i)\n exit()\nif a[-2]+a[-1]>=l:\n print(\"Possible\")\n for i in range(1,n):print(i)\n exit()\nans=-1\nfor i in range(1,n):\n if a[i-1]+a[i]>=l:\n ans=i\n break\nif ans==-1:print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,ans):print(i)\n for i in range(n-1,ans,-1):print(i)\n print(ans)", "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 a[0]+a[1]>=l:\n print(\"Possible\")\n for i in range(n-1,0,-1):print(i)\n exit()", "a[0]+a[1]>=l", "a[0]+a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "l", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(n-1,0,-1):print(i)\n ", "i", "range(n-1,0,-1)", "range", "n-1", "n", "1", "0", "-1", "exit()", "exit", "if a[-2]+a[-1]>=l:\n print(\"Possible\")\n for i in range(1,n):print(i)\n exit()", "a[-2]+a[-1]>=l", "a[-2]+a[-1]", "a[-2]", "a", "-2", "a[-1]", "a", "-1", "l", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,n):print(i)\n ", "i", "range(1,n)", "range", "1", "n", "exit()", "exit", "ans=-1", "ans", "-1", "for i in range(1,n):\n if a[i-1]+a[i]>=l:\n ans=i\n break", "i", "range(1,n)", "range", "1", "n", "if a[i-1]+a[i]>=l:\n ans=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", "ans=i", "ans", "i", "break", "if ans==-1:print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,ans):print(i)\n for i in range(n-1,ans,-1):print(i)\n print(ans)", "ans==-1", "ans", "-1", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,ans):print(i)\n ", "i", "range(1,ans)", "range", "1", "ans", "for i in range(n-1,ans,-1):print(i)\n ", "i", "range(n-1,ans,-1)", "range", "n-1", "n", "1", "ans", "-1", "print(ans)", "print", "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", "ans=i", "i", "ans", "ans=-1", "-1", "ans" ]

[ 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, 3, 14, 40, 13, 4, 13, 17, 4, 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, 13, 4, 13, 2, 13, 17, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 100, 2 ], [ 100, 11 ], [ 103, 13 ], [ 97, 25 ], [ 29, 28 ], [ 95, 32 ], [ 104, 38 ], [ 28, 39 ], [ 104, 41 ], [ 28, 43 ], [ 101, 45 ], [ 91, 47 ], [ 92, 52 ], [ 98, 52 ], [ 63, 62 ], [ 62, 69 ], [ 73, 72 ], [ 95, 76 ], [ 72, 84 ], [ 91, 92 ], [ 100, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ] ]

[ "N, L = map(int, input().split())\nA = list(map(int, input().split()))\nflg = False\nfor i in range(N - 1):\n if A[i] + A[i+1] >= L:\n flg = True\n break\nif not flg:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")\n# 0, 1, ..., i - 1, [i], [i+1], i + 2, ..., N - 1\nfor j in range(i):\n print(j + 1)\nfor j in range(N - 1, i + 1, -1):\n print(j)\nprint(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", "flg = False", "flg", "False", "for i in range(N - 1):\n if A[i] + A[i+1] >= L:\n flg = True\n break", "i", "range(N - 1)", "range", "N - 1", "N", "1", "if A[i] + A[i+1] >= L:\n flg = True\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", "flg = True", "flg", "True", "break", "if not flg:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")\n# 0, 1, ..., i - 1, [i], [i+1], i + 2, ..., N - 1", "not flg", "flg", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for j in range(i):\n print(j + 1)", "j", "range(i)", "range", "i", "print(j + 1)", "print", "j + 1", "j", "1", "for j in range(N - 1, i + 1, -1):\n print(j)", "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", "flg = True", "True", "flg", "N, L = map(int, input().split())", "map(int, input().split())", "N", "flg = False", "False", "flg", "L = map(int, input().split())", "map(int, input().split())", "L", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A" ]

[ 7, 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, 4, 13, 12, 13, 23, 13, 0, 13, 4, 13, 13, 0, 13, 2, 39, 17, 4, 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, 2, 13, 17, 17, 4, 13, 13, 3, 4, 13, 17, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 10, 9 ], [ 113, 15 ], [ 19, 19 ], [ 23, 22 ], [ 107, 28 ], [ 32, 32 ], [ 109, 34 ], [ 101, 36 ], [ 109, 37 ], [ 103, 39 ], [ 107, 44 ], [ 47, 46 ], [ 95, 50 ], [ 104, 55 ], [ 46, 56 ], [ 104, 58 ], [ 46, 60 ], [ 110, 62 ], [ 68, 67 ], [ 46, 71 ], [ 67, 74 ], [ 77, 76 ], [ 95, 80 ], [ 46, 83 ], [ 76, 88 ], [ 109, 95 ], [ 103, 104 ], [ 109, 110 ] ]

[ "def N(): return int(input())\ndef NM():return map(int,input().split())\ndef L():return list(NM())\ndef LN(n):return [N() for i in range(n)]\ndef LL(n):return [L() for i in range(n)]\nn,l=NM()\na=[0]+L()\nfor 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,-1):\n print(j)\n break\nelse:\n print(\"Impossible\")", "def N(): return int(input())", "N", "def NM():return map(int,input().split())", "NM", "def L():return list(NM())", "L", "N() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "N()", "N", "def LN(n):return [N() for i in range(n)]", "LN", "n", "n", "L() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "L()", "L", "def LL(n):return [L() for i in range(n)]", "LL", "n", "n", "n,l=NM()", "n", "NM()", "NM", "l", "a=[0]+L()", "a", "[0]+L()", "[0]", "0", "L()", "L", "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,-1):\n print(j)\n break\nelse:\n print(\"Impossible\")", "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,-1):\n print(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", "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,-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", "break", "print(\"Impossible\")", "print", "\"Impossible\"", "n,l=NM()", "NM()", "n", "def LL(n):return [L() for i in range(n)]", "def LL(n):return [L() for i in range(n)]", "LL", "def NM():return map(int,input().split())", "def NM():return map(int,input().split())", "NM", "a=[0]+L()", "[0]+L()", "a", "def L():return list(NM())", "def L():return list(NM())", "L", "l=NM()", "NM()", "l", "def N(): return int(input())", "def N(): return int(input())", "N", "def LN(n):return [N() for i in range(n)]", "def LN(n):return [N() for i in range(n)]", "LN" ]

[ 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, 17, 3, 14, 2, 13, 17, 4, 13, 17, 4, 13, 4, 13, 17, 28, 13, 4, 13, 17, 13, 4, 13, 13, 28, 13, 4, 13, 17, 2, 4, 13, 13, 13, 4, 13, 2, 4, 13, 13, 13, 4, 13, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 104, 3 ], [ 104, 12 ], [ 101, 14 ], [ 92, 26 ], [ 30, 29 ], [ 105, 33 ], [ 102, 38 ], [ 29, 40 ], [ 102, 43 ], [ 29, 44 ], [ 99, 45 ], [ 95, 47 ], [ 96, 52 ], [ 93, 52 ], [ 64, 63 ], [ 63, 70 ], [ 73, 72 ], [ 102, 79 ], [ 102, 86 ], [ 72, 87 ], [ 92, 93 ], [ 95, 96 ], [ 104, 99 ], [ 101, 102 ], [ 104, 105 ] ]

[ "from collections import deque\n\nn,l=map(int,input().split())\na=list(map(int,input().split()))\n\ns=\"\"\n\nfor i in range(1,n):\n if a[i-1]+a[i]>=l:\n s=\"p\"\n break\n\nif s==\"\":\n print(\"Impossible\")\n exit()\nprint(\"Possible\")\n \nfor j in range(1,i):\n print(j)\nfor j in range(1,len(a)-i):\n print(len(a)-j)\n \nprint(i)\n ", "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", "s=\"\"", "s", "\"\"", "for i in range(1,n):\n if a[i-1]+a[i]>=l:\n s=\"p\"\n break", "i", "range(1,n)", "range", "1", "n", "if a[i-1]+a[i]>=l:\n s=\"p\"\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", "s=\"p\"", "s", "\"p\"", "break", "if s==\"\":\n print(\"Impossible\")\n exit()", "s==\"\"", "s", "\"\"", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for j in range(1,i):\n print(j)", "j", "range(1,i)", "range", "1", "i", "print(j)", "print", "j", "for j in range(1,len(a)-i):\n print(len(a)-j)\n ", "j", "range(1,len(a)-i)", "range", "1", "len(a)-i", "len(a)", "len", "a", "i", "print(len(a)-j)", "print", "len(a)-j", "len(a)", "len", "a", "j", "print(i)", "print", "i", "s=\"\"", "\"\"", "s", "s=\"p\"", "\"p\"", "s", "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" ]

[ 7, 12, 13, 28, 13, 4, 13, 2, 4, 13, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 29, 2, 4, 13, 17, 13, 4, 13, 2, 4, 13, 13, 17, 2, 13, 17, 17, 29, 39, 23, 13, 23, 13, 12, 13, 41, 28, 13, 4, 18, 4, 18, 4, 13, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 41, 28, 13, 4, 18, 4, 18, 4, 13, 13, 13, 4, 4, 13, 13, 0, 13, 13, 0, 13, 4, 13, 13, 13, 14, 2, 4, 13, 13, 17, 13, 13, 28, 13, 13, 13, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 44, 10 ], [ 44, 16 ], [ 4, 17 ], [ 44, 19 ], [ 4, 21 ], [ 46, 23 ], [ 4, 29 ], [ 44, 35 ], [ 4, 38 ], [ 44, 44 ], [ 46, 46 ], [ 52, 51 ], [ 51, 63 ], [ 66, 65 ], [ 66, 67 ], [ 71, 70 ], [ 70, 82 ], [ 85, 84 ], [ 88, 87 ], [ 115, 89 ], [ 84, 90 ], [ 67, 91 ], [ 87, 96 ], [ 102, 101 ], [ 87, 101 ], [ 101, 105 ], [ 118, 112 ] ]

[ "def cutSequence(piles, threshold):\n for i in xrange(len(piles)-1):\n if piles[i]+piles[i+1]>=threshold:\n return range(0, i)+range(len(piles)-2, i-1, -1)\n return []\n\ndef main():\n n, m = [int(x) for x in raw_input().strip().split()]\n a = [int(x) for x in raw_input().strip().split()]\n foo = cutSequence(a, m)\n if len(foo)==0:\n print 'Impossible'\n else:\n print 'Possible'\n for x in foo:\n print x+1\n\nif __name__ == '__main__':\n main()", "def cutSequence(piles, threshold):\n for i in xrange(len(piles)-1):\n if piles[i]+piles[i+1]>=threshold:\n return range(0, i)+range(len(piles)-2, i-1, -1)\n return []", "cutSequence", "for i in xrange(len(piles)-1):\n if piles[i]+piles[i+1]>=threshold:\n return range(0, i)+range(len(piles)-2, i-1, -1)\n ", "i", "xrange(len(piles)-1)", "xrange", "len(piles)-1", "len(piles)", "len", "piles", "1", "if piles[i]+piles[i+1]>=threshold:\n return range(0, i)+range(len(piles)-2, i-1, -1)\n ", "piles[i]+piles[i+1]>=threshold", "piles[i]+piles[i+1]", "piles[i]", "piles", "i", "piles[i+1]", "piles", "i+1", "i", "1", "threshold", "return range(0, i)+range(len(piles)-2, i-1, -1)", "range(0, i)+range(len(piles)-2, i-1, -1)", "range(0, i)", "range", "0", "i", "range(len(piles)-2, i-1, -1)", "range", "len(piles)-2", "len(piles)", "len", "piles", "2", "i-1", "i", "1", "-1", "return []", "[]", "piles", "piles", "threshold", "threshold", "def main():\n n, m = [int(x) for x in raw_input().strip().split()]\n a = [int(x) for x in raw_input().strip().split()]\n foo = cutSequence(a, m)\n if len(foo)==0:\n print 'Impossible'\n else:\n print 'Possible'\n for x in foo:\n print x+1", "main", "int(x) for x in raw_input().strip().split()", "for x in raw_input().strip().split()", "x", "raw_input().strip().split()", "().strip().split", "().strip()", "().strip", "()", "raw_input", "strip", "split", "for x in raw_input().strip().split()", "int(x)", "int", "x", "n, m = [int(x) for x in raw_input().strip().split()]", "n", "[int(x) for x in raw_input().strip().split()]", "m", "int(x) for x in raw_input().strip().split()", "for x in raw_input().strip().split()", "x", "raw_input().strip().split()", "().strip().split", "().strip()", "().strip", "()", "raw_input", "strip", "split", "for x in raw_input().strip().split()", "int(x)", "int", "x", "a = [int(x) for x in raw_input().strip().split()]", "a", "[int(x) for x in raw_input().strip().split()]", "foo = cutSequence(a, m)", "foo", "cutSequence(a, m)", "cutSequence", "a", "m", "if len(foo)==0:\n print 'Impossible'\n else:\n print 'Possible'\n for x in foo:\n print x+1", "len(foo)==0", "len(foo)", "len", "foo", "0", "print", "print", "for x in foo:\n print x+1", "x", "foo", "print", "x+1", "x", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def cutSequence(piles, threshold):\n for i in xrange(len(piles)-1):\n if piles[i]+piles[i+1]>=threshold:\n return range(0, i)+range(len(piles)-2, i-1, -1)\n return []", "def cutSequence(piles, threshold):\n for i in xrange(len(piles)-1):\n if piles[i]+piles[i+1]>=threshold:\n return range(0, i)+range(len(piles)-2, i-1, -1)\n return []", "cutSequence", "def main():\n n, m = [int(x) for x in raw_input().strip().split()]\n a = [int(x) for x in raw_input().strip().split()]\n foo = cutSequence(a, m)\n if len(foo)==0:\n print 'Impossible'\n else:\n print 'Possible'\n for x in foo:\n print x+1", "def main():\n n, m = [int(x) for x in raw_input().strip().split()]\n a = [int(x) for x in raw_input().strip().split()]\n foo = cutSequence(a, m)\n if len(foo)==0:\n print 'Impossible'\n else:\n print 'Possible'\n for x in foo:\n print x+1", "main" ]

[ 7, 15, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 12, 13, 29, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 18, 4, 18, 4, 13, 13, 13, 12, 13, 29, 4, 13, 13, 4, 18, 4, 18, 4, 13, 13, 13, 12, 13, 29, 4, 13, 13, 4, 18, 4, 18, 4, 13, 13, 13, 12, 13, 41, 28, 13, 4, 13, 4, 13, 4, 4, 18, 4, 13, 13, 29, 13, 12, 13, 41, 28, 13, 4, 13, 4, 13, 4, 4, 13, 4, 18, 4, 13, 13, 29, 13, 12, 13, 41, 28, 13, 4, 13, 4, 13, 4, 4, 13, 4, 18, 4, 13, 13, 29, 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, 14, 40, 13, 17, 13, 28, 13, 4, 13, 13, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 13, 17, 13, 13, 10, 12, 13, 10, 17, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 13, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 78, 77 ], [ 95, 94 ], [ 114, 113 ], [ 224, 129 ], [ 198, 131 ], [ 224, 132 ], [ 209, 134 ], [ 198, 136 ], [ 191, 138 ], [ 142, 141 ], [ 225, 145 ], [ 210, 151 ], [ 141, 152 ], [ 210, 154 ], [ 141, 156 ], [ 195, 158 ], [ 221, 160 ], [ 141, 161 ], [ 222, 164 ], [ 192, 164 ], [ 169, 168 ], [ 222, 171 ], [ 192, 171 ], [ 168, 174 ], [ 178, 177 ], [ 225, 181 ], [ 222, 183 ], [ 192, 183 ], [ 191, 192 ], [ 224, 195 ], [ 209, 210 ], [ 141, 221 ], [ 221, 222 ], [ 224, 225 ] ]

[ "# -*- coding: utf-8 -*-\nimport math,string,itertools,fractions,heapq,collections,re,array,bisect,sys\n\ndef s():\n return raw_input().strip()\ndef n():\n return int(raw_input())\ndef d():\n return float(raw_input())\n\ndef ls():\n return raw_input().strip().split()\ndef ln():\n return map(int, raw_input().strip().split())\ndef ld():\n return map(float, raw_input().strip().split())\n\ndef fs():\n return [raw_input().strip() for i in xrange(input())]\ndef fn():\n return [int(raw_input().strip()) for i in xrange(input())]\ndef fd():\n return [float(raw_input().strip()) for i in xrange(input())]\n\nN, L = ln()\n\nA = ln()\n\ncandidate = -1\n\nfor i in xrange(N - 1):\n if A[i] + A[i + 1] >= L:\n candidate = i\n\nif candidate != -1:\n print 'Possible'\n for i in xrange(candidate):\n print i + 1\n for i in xrange(N - 1, candidate, -1):\n print i\nelse:\n print 'Impossible'", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys", "math", "string", "itertools", "fractions", "heapq", "collections", "re", "array", "bisect", "sys", "def s():\n return raw_input().strip()", "s", "return raw_input().strip()", "raw_input().strip()", "().strip", "()", "raw_input", "strip", "def n():\n return int(raw_input())", "n", "return int(raw_input())", "int(raw_input())", "int", "raw_input()", "raw_input", "def d():\n return float(raw_input())", "d", "return float(raw_input())", "float(raw_input())", "float", "raw_input()", "raw_input", "def ls():\n return raw_input().strip().split()", "ls", "return raw_input().strip().split()", "raw_input().strip().split()", "().strip().split", "().strip()", "().strip", "()", "raw_input", "strip", "split", "def ln():\n return map(int, raw_input().strip().split())", "ln", "return map(int, raw_input().strip().split())", "map(int, raw_input().strip().split())", "map", "int", "raw_input().strip().split()", "().strip().split", "().strip()", "().strip", "()", "raw_input", "strip", "split", "def ld():\n return map(float, raw_input().strip().split())", "ld", "return map(float, raw_input().strip().split())", "map(float, raw_input().strip().split())", "map", "float", "raw_input().strip().split()", "().strip().split", "().strip()", "().strip", "()", "raw_input", "strip", "split", "def fs():\n return [raw_input().strip() for i in xrange(input())]", "fs", "raw_input().strip() for i in xrange(input())", "for i in xrange(input())", "i", "xrange(input())", "xrange", "input()", "input", "for i in xrange(input())", "raw_input().strip()", "().strip", "()", "raw_input", "strip", "return [raw_input().strip() for i in xrange(input())]", "[raw_input().strip() for i in xrange(input())]", "def fn():\n return [int(raw_input().strip()) for i in xrange(input())]", "fn", "int(raw_input().strip()) for i in xrange(input())", "for i in xrange(input())", "i", "xrange(input())", "xrange", "input()", "input", "for i in xrange(input())", "int(raw_input().strip())", "int", "raw_input().strip()", "().strip", "()", "raw_input", "strip", "return [int(raw_input().strip()) for i in xrange(input())]", "[int(raw_input().strip()) for i in xrange(input())]", "def fd():\n return [float(raw_input().strip()) for i in xrange(input())]", "fd", "float(raw_input().strip()) for i in xrange(input())", "for i in xrange(input())", "i", "xrange(input())", "xrange", "input()", "input", "for i in xrange(input())", "float(raw_input().strip())", "float", "raw_input().strip()", "().strip", "()", "raw_input", "strip", "return [float(raw_input().strip()) for i in xrange(input())]", "[float(raw_input().strip()) for i in xrange(input())]", "N, L = ln()", "N", "ln()", "ln", "L", "A = ln()", "A", "ln()", "ln", "candidate = -1", "candidate", "-1", "for i in xrange(N - 1):\n if A[i] + A[i + 1] >= L:\n candidate = i", "i", "xrange(N - 1)", "xrange", "N - 1", "N", "1", "if A[i] + A[i + 1] >= L:\n candidate = 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", "candidate = i", "candidate", "i", "if candidate != -1:\n print 'Possible'\n for i in xrange(candidate):\n print i + 1\n for i in xrange(N - 1, candidate, -1):\n print i\nelse:\n print 'Impossible'", "candidate != -1", "candidate", "-1", "print", "for i in xrange(candidate):\n print i + 1\n ", "i", "xrange(candidate)", "xrange", "candidate", "print", "i + 1", "i", "1", "for i in xrange(N - 1, candidate, -1):\n print i", "i", "xrange(N - 1, candidate, -1)", "xrange", "N - 1", "N", "1", "candidate", "-1", "print", "print", "def d():\n return float(raw_input())", "def d():\n return float(raw_input())", "d", "candidate = -1", "-1", "candidate", "L = ln()", "ln()", "L", "def ln():\n return map(int, raw_input().strip().split())", "def ln():\n return map(int, raw_input().strip().split())", "ln", "def s():\n return raw_input().strip()", "def s():\n return raw_input().strip()", "s", "def n():\n return int(raw_input())", "def n():\n return int(raw_input())", "n", "def fn():\n return [int(raw_input().strip()) for i in xrange(input())]", "def fn():\n return [int(raw_input().strip()) for i in xrange(input())]", "fn", "A = ln()", "ln()", "A", "def fd():\n return [float(raw_input().strip()) for i in xrange(input())]", "def fd():\n return [float(raw_input().strip()) for i in xrange(input())]", "fd", "def ld():\n return map(float, raw_input().strip().split())", "def ld():\n return map(float, raw_input().strip().split())", "ld", "def ls():\n return raw_input().strip().split()", "def ls():\n return raw_input().strip().split()", "ls", "candidate = i", "i", "candidate", "N, L = ln()", "ln()", "N", "def fs():\n return [raw_input().strip() for i in xrange(input())]", "def fs():\n return [raw_input().strip() for i in xrange(input())]", "fs" ]

[ 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, 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, 17, 0, 13, 17, 41, 28, 13, 4, 13, 17, 13, 4, 13, 0, 13, 2, 2, 13, 13, 39, 13, 4, 13, 4, 18, 17, 13, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 28, 27 ], [ 31, 30 ], [ 4, 34 ], [ 15, 40 ], [ 30, 41 ], [ 15, 43 ], [ 30, 45 ], [ 13, 47 ], [ 50, 49 ], [ 30, 50 ], [ 49, 53 ], [ 27, 53 ], [ 63, 62 ], [ 67, 66 ], [ 62, 70 ], [ 49, 70 ], [ 27, 70 ], [ 66, 72 ], [ 75, 74 ], [ 74, 90 ], [ 99, 96 ] ]

[ "# -*- coding: utf-8 -*-\n\n\ndef main():\n n, l = map(int, input().split())\n a = list(map(int, input().split()))\n\n # KeyInsight\n # 最後から直前の状態を考える\n # ある位置a[i]と右隣の値a[i+1]の和がL以上であれば構成できる\n # iの位置を特定\n # 左右の両端から切る\n pos = -1\n\n for i in range(n - 1):\n if (a[i] + a[i + 1]) >= l:\n pos = i\n\n if pos == -1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n\n # 1-indexに\n pos += 1\n\n # See:\n # https://atcoder.jp/contests/agc002/submissions/7179969\n ans = [i for i in range(1, pos)] + [i for i in range(n - 1, pos, -1)] + [pos]\n print('\\n'.join(map(str, ans)))\n\n\nif __name__ == '__main__':\n main()", "def main():\n n, l = map(int, input().split())\n a = list(map(int, input().split()))\n\n # KeyInsight\n # 最後から直前の状態を考える\n # ある位置a[i]と右隣の値a[i+1]の和がL以上であれば構成できる\n # iの位置を特定\n # 左右の両端から切る\n pos = -1\n\n for i in range(n - 1):\n if (a[i] + a[i + 1]) >= l:\n pos = i\n\n if pos == -1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n\n # 1-indexに\n pos += 1\n\n # See:\n # https://atcoder.jp/contests/agc002/submissions/7179969\n ans = [i for i in range(1, pos)] + [i for i in range(n - 1, pos, -1)] + [pos]\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", "pos = -1", "pos", "-1", "for i in range(n - 1):\n if (a[i] + a[i + 1]) >= l:\n pos = i\n\n ", "i", "range(n - 1)", "range", "n - 1", "n", "1", "if (a[i] + a[i + 1]) >= l:\n pos = i\n\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", "pos = i", "pos", "i", "if pos == -1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n\n # 1-indexに\n pos += 1\n\n # See:\n # https://atcoder.jp/contests/agc002/submissions/7179969\n ans = [i for i in range(1, pos)] + [i for i in range(n - 1, pos, -1)] + [pos]\n print('\\n'.join(map(str, ans)))", "pos == -1", "pos", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "pos += 1", "pos", "1", "i for i in range(1, pos)", "for i in range(1, pos)", "i", "range(1, pos)", "range", "1", "pos", "for i in range(1, pos)", "i", "ans = [i for i in range(1, pos)] + [i for i in range(n - 1, pos, -1)] + [pos]", "ans", "[i for i in range(1, pos)] + [i for i in range(n - 1, pos, -1)] + [pos]", "[i for i in range(1, pos)] + [i for i in range(n - 1, pos, -1)]", "[i for i in range(1, pos)]", "[i for i in range(n - 1, pos, -1)]", "[pos]", "pos", "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", "def main():\n n, l = map(int, input().split())\n a = list(map(int, input().split()))\n\n # KeyInsight\n # 最後から直前の状態を考える\n # ある位置a[i]と右隣の値a[i+1]の和がL以上であれば構成できる\n # iの位置を特定\n # 左右の両端から切る\n pos = -1\n\n for i in range(n - 1):\n if (a[i] + a[i + 1]) >= l:\n pos = i\n\n if pos == -1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n\n # 1-indexに\n pos += 1\n\n # See:\n # https://atcoder.jp/contests/agc002/submissions/7179969\n ans = [i for i in range(1, pos)] + [i for i in range(n - 1, pos, -1)] + [pos]\n print('\\n'.join(map(str, ans)))", "def main():\n n, l = map(int, input().split())\n a = list(map(int, input().split()))\n\n # KeyInsight\n # 最後から直前の状態を考える\n # ある位置a[i]と右隣の値a[i+1]の和がL以上であれば構成できる\n # iの位置を特定\n # 左右の両端から切る\n pos = -1\n\n for i in range(n - 1):\n if (a[i] + a[i + 1]) >= l:\n pos = i\n\n if pos == -1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n\n # 1-indexに\n pos += 1\n\n # See:\n # https://atcoder.jp/contests/agc002/submissions/7179969\n ans = [i for i in range(1, pos)] + [i for i in range(n - 1, pos, -1)] + [pos]\n print('\\n'.join(map(str, ans)))", "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, 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, 2, 13, 13, 4, 13, 17, 4, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 2, 13, 13, 3, 4, 13, 2, 13, 17, 28, 13, 4, 13, 4, 13, 2, 13, 17, 14, 2, 13, 13, 3, 4, 13, 2, 13, 17, 4, 13, 2, 13, 17, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 127, 2 ], [ 127, 11 ], [ 115, 13 ], [ 121, 25 ], [ 29, 28 ], [ 119, 32 ], [ 116, 38 ], [ 28, 39 ], [ 116, 41 ], [ 28, 43 ], [ 122, 45 ], [ 113, 45 ], [ 112, 47 ], [ 116, 50 ], [ 28, 51 ], [ 116, 53 ], [ 28, 55 ], [ 124, 58 ], [ 28, 59 ], [ 113, 62 ], [ 122, 62 ], [ 128, 63 ], [ 72, 71 ], [ 119, 75 ], [ 71, 79 ], [ 125, 80 ], [ 71, 85 ], [ 89, 88 ], [ 119, 94 ], [ 88, 98 ], [ 125, 99 ], [ 88, 104 ], [ 125, 109 ], [ 112, 113 ], [ 115, 116 ], [ 127, 119 ], [ 121, 122 ], [ 28, 124 ], [ 124, 125 ], [ 127, 128 ] ]

[ "N, L = map(int, input().split())\nA = list(map(int, input().split()))\n\ns = 0\nfor i in range(N-1):\n if A[i] + A[i+1] > s:\n s = A[i] + A[i+1]\n ind = i\n\nif s < L:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(N-1):\n if i == ind:\n break\n print(i+1)\n for i in reversed(range(N-1)):\n if i == ind:\n break\n print(i+1)\n print(ind+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", "s = 0", "s", "0", "for i in range(N-1):\n if A[i] + A[i+1] > s:\n s = A[i] + A[i+1]\n ind = i", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i] + A[i+1] > s:\n s = A[i] + A[i+1]\n ind = i", "A[i] + A[i+1] > s", "A[i] + A[i+1]", "A[i]", "A", "i", "A[i+1]", "A", "i+1", "i", "1", "s", "s = A[i] + A[i+1]", "s", "A[i] + A[i+1]", "A[i]", "A", "i", "A[i+1]", "A", "i+1", "i", "1", "ind = i", "ind", "i", "if s < L:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(N-1):\n if i == ind:\n break\n print(i+1)\n for i in reversed(range(N-1)):\n if i == ind:\n break\n print(i+1)\n print(ind+1) ", "s < L", "s", "L", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "for i in range(N-1):\n if i == ind:\n break\n print(i+1)\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if i == ind:\n break\n ", "i == ind", "i", "ind", "break", "print(i+1)", "print", "i+1", "i", "1", "for i in reversed(range(N-1)):\n if i == ind:\n break\n print(i+1)\n ", "i", "reversed(range(N-1))", "reversed", "range(N-1)", "range", "N-1", "N", "1", "if i == ind:\n break\n ", "i == ind", "i", "ind", "break", "print(i+1)", "print", "i+1", "i", "1", "print(ind+1)", "print", "ind+1", "ind", "1", "s = A[i] + A[i+1]", "A[i] + A[i+1]", "s", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "N, L = map(int, input().split())", "map(int, input().split())", "N", "s = 0", "0", "s", "ind = i", "i", "ind", "L = map(int, input().split())", "map(int, input().split())", "L" ]

[ 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, 39, 28, 13, 4, 13, 2, 13, 17, 4, 18, 13, 13, 13, 39, 2, 40, 18, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 39, 0, 13, 2, 39, 17, 13, 42, 13, 0, 13, 4, 18, 13, 13, 13, 13, 0, 13, 40, 13, 14, 18, 13, 13, 9, 14, 2, 13, 13, 3, 0, 18, 13, 13, 17, 4, 18, 13, 13, 2, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 18, 13, 13, 13, 39, 2, 40, 13, 18, 13, 2, 13, 17, 2, 13, 17, 14, 40, 2, 13, 17, 17, 4, 18, 13, 13, 13, 39, 2, 40, 13, 18, 13, 2, 13, 17, 2, 13, 17, 14, 40, 4, 13, 13, 2, 13, 17, 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, 4, 13, 10, 39, 13, 10, 4, 13, 10, 39, 13, 10, 40, 13, 10, 2, 13 ]

[ [ 177, 4 ], [ 177, 13 ], [ 174, 15 ], [ 189, 27 ], [ 31, 30 ], [ 178, 34 ], [ 190, 40 ], [ 175, 45 ], [ 30, 46 ], [ 175, 48 ], [ 30, 50 ], [ 183, 54 ], [ 195, 57 ], [ 178, 61 ], [ 186, 65 ], [ 190, 70 ], [ 186, 71 ], [ 192, 73 ], [ 181, 75 ], [ 193, 75 ], [ 196, 78 ], [ 187, 79 ], [ 193, 83 ], [ 181, 83 ], [ 172, 84 ], [ 90, 87 ], [ 196, 88 ], [ 187, 89 ], [ 184, 93 ], [ 187, 96 ], [ 187, 101 ], [ 178, 104 ], [ 190, 110 ], [ 193, 114 ], [ 181, 114 ], [ 175, 116 ], [ 187, 118 ], [ 187, 121 ], [ 187, 126 ], [ 190, 133 ], [ 193, 137 ], [ 181, 137 ], [ 175, 139 ], [ 187, 141 ], [ 187, 144 ], [ 184, 150 ], [ 178, 152 ], [ 184, 164 ], [ 169, 168 ], [ 177, 172 ], [ 174, 175 ], [ 177, 178 ], [ 186, 181 ], [ 183, 184 ], [ 186, 187 ], [ 189, 190 ], [ 192, 193 ], [ 195, 196 ] ]

[ "import heapq\nN, K = map(int, input().split())\nA = list(map(int, input().split()))\n\nknot = []\nfor i in range(N - 1):\n heapq.heappush(knot, (-A[i]-A[i+1], i))\n\nans = []\nseen = [False]*N\nwhile knot:\n L, i = heapq.heappop(knot)\n L = -L\n\n if seen[i]:\n continue\n if L < K:\n break\n\n seen[i] = True\n ans.append(i + 1)\n\n if i + 1 < N - 1:\n heapq.heappush(knot, (-L - A[i + 1], i + 1))\n if i - 1 >= 0:\n heapq.heappush(knot, (-L - A[i - 1], i - 1))\n\nif len(ans) != N - 1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n print(*ans[::-1], sep=\"\\n\")", "import heapq", "heapq", "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", "knot = []", "knot", "[]", "for i in range(N - 1):\n heapq.heappush(knot, (-A[i]-A[i+1], i))", "i", "range(N - 1)", "range", "N - 1", "N", "1", "heapq.heappush(knot, (-A[i]-A[i+1], i))", "heapq.heappush", "heapq", "heappush", "knot", "(-A[i]-A[i+1], i)", "-A[i]-A[i+1]", "-A[i]", "A[i]", "A", "i", "A[i+1]", "A", "i+1", "i", "1", "i", "ans = []", "ans", "[]", "seen = [False]*N", "seen", "[False]*N", "[False]", "False", "N", "while knot:\n L, i = heapq.heappop(knot)\n L = -L\n\n if seen[i]:\n continue\n if L < K:\n break\n\n seen[i] = True\n ans.append(i + 1)\n\n if i + 1 < N - 1:\n heapq.heappush(knot, (-L - A[i + 1], i + 1))\n if i - 1 >= 0:\n heapq.heappush(knot, (-L - A[i - 1], i - 1))", "knot", "L, i = heapq.heappop(knot)", "L", "heapq.heappop(knot)", "heapq.heappop", "heapq", "heappop", "knot", "i", "L = -L", "L", "-L", "L", "if seen[i]:\n continue\n ", "seen[i]", "seen", "i", "continue", "if L < K:\n break\n\n ", "L < K", "L", "K", "break", "seen[i] = True", "seen[i]", "seen", "i", "True", "ans.append(i + 1)", "ans.append", "ans", "append", "i + 1", "i", "1", "if i + 1 < N - 1:\n heapq.heappush(knot, (-L - A[i + 1], i + 1))\n ", "i + 1 < N - 1", "i + 1", "i", "1", "N - 1", "N", "1", "heapq.heappush(knot, (-L - A[i + 1], i + 1))", "heapq.heappush", "heapq", "heappush", "knot", "(-L - A[i + 1], i + 1)", "-L - A[i + 1]", "-L", "L", "A[i + 1]", "A", "i + 1", "i", "1", "i + 1", "i", "1", "if i - 1 >= 0:\n heapq.heappush(knot, (-L - A[i - 1], i - 1))", "i - 1 >= 0", "i - 1", "i", "1", "0", "heapq.heappush(knot, (-L - A[i - 1], i - 1))", "heapq.heappush", "heapq", "heappush", "knot", "(-L - A[i - 1], i - 1)", "-L - A[i - 1]", "-L", "L", "A[i - 1]", "A", "i - 1", "i", "1", "i - 1", "i", "1", "if len(ans) != N - 1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n print(*ans[::-1], sep=\"\\n\")", "len(ans) != N - 1", "len(ans)", "len", "ans", "N - 1", "N", "1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "print(*ans[::-1], sep=\"\\n\")", "print", "*ans[::-1]", "ans[::-1]", "ans", "::-1", "-1", "sep=\"\\n\"", "sep", "\"\\n\"", "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())", "map(int, input().split())", "N", "L, i = heapq.heappop(knot)", "heapq.heappop(knot)", "L", "ans = []", "[]", "ans", "i = heapq.heappop(knot)", "heapq.heappop(knot)", "i", "knot = []", "[]", "knot", "L = -L", "-L", "L", "seen = [False]*N", "[False]*N", "seen" ]

[ 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, 39, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 41, 28, 13, 4, 13, 17, 2, 13, 17, 4, 13, 0, 13, 2, 2, 13, 13, 39, 2, 13, 17, 0, 13, 17, 3, 14, 13, 4, 13, 17, 4, 13, 31, 13, 0, 13, 17, 4, 13, 17, 10, 17, 13, 10, 39, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 105, 2 ], [ 105, 11 ], [ 108, 13 ], [ 90, 25 ], [ 93, 28 ], [ 32, 31 ], [ 106, 35 ], [ 109, 41 ], [ 31, 42 ], [ 109, 44 ], [ 31, 46 ], [ 103, 48 ], [ 52, 51 ], [ 31, 56 ], [ 51, 59 ], [ 96, 61 ], [ 31, 68 ], [ 99, 71 ], [ 97, 82 ], [ 94, 82 ], [ 85, 84 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 105, 103 ], [ 105, 106 ], [ 108, 109 ] ]

[ "#002_C\nn, l = map(int, input().split())\na = list(map(int, input().split()))\n\nflg = False\nans = []\nfor i in range(n-1):\n if a[i] + a[i+1] >= l:\n ans = [j for j in range(1, i+1)] + [j for j in range(n-1, i+1, -1)] + [i+1]\n flg = True\n break\n \nif flg:\n print('Possible')\n print(*ans, sep='\\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", "flg = False", "flg", "False", "ans = []", "ans", "[]", "for i in range(n-1):\n if a[i] + a[i+1] >= l:\n ans = [j for j in range(1, i+1)] + [j for j in range(n-1, i+1, -1)] + [i+1]\n flg = True\n break\n ", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i] + a[i+1] >= l:\n ans = [j for j in range(1, i+1)] + [j for j in range(n-1, i+1, -1)] + [i+1]\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", "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)] + [j for j in range(n-1, i+1, -1)] + [i+1]", "ans", "[j for j in range(1, i+1)] + [j for j in range(n-1, i+1, -1)] + [i+1]", "[j for j in range(1, i+1)] + [j for j in range(n-1, i+1, -1)]", "[j for j in range(1, i+1)]", "[j for j in range(n-1, i+1, -1)]", "[i+1]", "i+1", "i", "1", "flg = True", "flg", "True", "break", "if flg:\n print('Possible')\n print(*ans, sep='\\n')\nelse:\n print('Impossible')", "flg", "print('Possible')", "print", "'Possible'", "print(*ans, sep='\\n')", "print", "*ans", "ans", "sep='\\n'", "sep", "'\\n'", "print('Impossible')", "print", "'Impossible'", "flg = False", "False", "flg", "ans = []", "[]", "ans", "ans = [j for j in range(1, i+1)] + [j for j in range(n-1, i+1, -1)] + [i+1]", "[j for j in range(1, i+1)] + [j for j in range(n-1, i+1, -1)] + [i+1]", "ans", "flg = True", "True", "flg", "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" ]

[ 7, 12, 13, 28, 13, 4, 13, 2, 13, 17, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 17, 4, 13, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 17, 13, 0, 13, 4, 18, 4, 13, 13, 17, 41, 28, 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, 3, 14, 2, 13, 17, 4, 13, 17, 4, 13, 17, 4, 13, 13, 13, 10, 13, 13, 10, 4, 13, 10, 12, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 5, 4 ], [ 32, 8 ], [ 4, 13 ], [ 17, 16 ], [ 30, 20 ], [ 32, 23 ], [ 16, 28 ], [ 30, 30 ], [ 32, 32 ], [ 122, 34 ], [ 122, 44 ], [ 125, 46 ], [ 56, 55 ], [ 126, 55 ], [ 55, 60 ], [ 107, 62 ], [ 116, 65 ], [ 69, 68 ], [ 111, 72 ], [ 108, 78 ], [ 126, 78 ], [ 68, 79 ], [ 108, 81 ], [ 126, 81 ], [ 68, 83 ], [ 123, 85 ], [ 119, 87 ], [ 68, 89 ], [ 120, 94 ], [ 117, 94 ], [ 114, 103 ], [ 111, 104 ], [ 120, 105 ], [ 117, 105 ], [ 107, 108 ], [ 122, 111 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ] ]

[ "def dump(n,k):\n for i in range(k-1):\n print(i+1)\n for i in range(n-1,k-1,-1):\n print(i)\n\nn,l=map(int,input().split(' '))\na=input().split(' ')\na=[int(s) for s in a]\n\nk=0\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n k=i+1\n break\n\nif k==0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n dump(n,k)", "def dump(n,k):\n for i in range(k-1):\n print(i+1)\n for i in range(n-1,k-1,-1):\n print(i)", "dump", "for i in range(k-1):\n print(i+1)\n ", "i", "range(k-1)", "range", "k-1", "k", "1", "print(i+1)", "print", "i+1", "i", "1", "for i in range(n-1,k-1,-1):\n print(i)", "i", "range(n-1,k-1,-1)", "range", "n-1", "n", "1", "k-1", "k", "1", "-1", "print(i)", "print", "i", "n", "n", "k", "k", "n,l=map(int,input().split(' '))", "n", "map(int,input().split(' '))", "map", "int", "input().split(' ')", "().split", "()", "input", "split", "' '", "l", "a=input().split(' ')", "a", "input().split(' ')", "().split", "()", "input", "split", "' '", "int(s) for s in a", "for s in a", "s", "a", "for s in a", "int(s)", "int", "s", "a=[int(s) for s in a]", "a", "[int(s) for s in a]", "k=0", "k", "0", "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==0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n dump(n,k)", "k==0", "k", "0", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "dump(n,k)", "dump", "n", "k", "a=[int(s) for s in a]", "[int(s) for s in a]", "a", "n,l=map(int,input().split(' '))", "map(int,input().split(' '))", "n", "def dump(n,k):\n for i in range(k-1):\n print(i+1)\n for i in range(n-1,k-1,-1):\n print(i)", "def dump(n,k):\n for i in range(k-1):\n print(i+1)\n for i in range(n-1,k-1,-1):\n print(i)", "dump", "k=0", "0", "k", "k=i+1", "i+1", "k", "l=map(int,input().split(' '))", "map(int,input().split(' '))", "l", "a=input().split(' ')", "input().split(' ')", "a" ]

[ 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, 2, 13, 13, 0, 13, 13, 0, 13, 13, 14, 2, 13, 13, 4, 13, 17, 4, 13, 17, 0, 13, 4, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 4, 13, 2, 13, 17, 2, 13, 17, 17, 4, 18, 13, 13, 2, 13, 17, 4, 13, 4, 18, 17, 13, 4, 13, 13, 13, 10, 17, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 121, 2 ], [ 121, 11 ], [ 130, 13 ], [ 109, 25 ], [ 124, 28 ], [ 32, 31 ], [ 116, 35 ], [ 118, 38 ], [ 131, 41 ], [ 31, 42 ], [ 131, 44 ], [ 31, 46 ], [ 125, 50 ], [ 113, 50 ], [ 119, 51 ], [ 133, 53 ], [ 31, 54 ], [ 112, 56 ], [ 119, 57 ], [ 113, 60 ], [ 125, 60 ], [ 122, 61 ], [ 127, 69 ], [ 134, 76 ], [ 110, 76 ], [ 128, 80 ], [ 116, 85 ], [ 134, 88 ], [ 110, 88 ], [ 128, 93 ], [ 134, 96 ], [ 110, 96 ], [ 128, 107 ], [ 109, 110 ], [ 119, 112 ], [ 112, 113 ], [ 121, 116 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ], [ 127, 128 ], [ 130, 131 ], [ 31, 133 ], [ 133, 134 ] ]

[ "n, l = map(int, input().split())\naaa = list(map(int, input().split()))\n\nmax_i = 0\nmax_two_ropes = 0\nfor i in range(n - 1):\n two_ropes = aaa[i] + aaa[i + 1]\n if max_two_ropes < two_ropes:\n max_i = i\n max_two_ropes = two_ropes\n\nif max_two_ropes < l:\n print('Impossible')\nelse:\n print('Possible')\n ans = list(range(1, max_i + 1))\n ans.extend(range(n - 1, max_i + 1, -1))\n ans.append(max_i + 1)\n print('\\n'.join(map(str, ans)))", "n, l = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "aaa = list(map(int, input().split()))", "aaa", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "max_i = 0", "max_i", "0", "max_two_ropes = 0", "max_two_ropes", "0", "for i in range(n - 1):\n two_ropes = aaa[i] + aaa[i + 1]\n if max_two_ropes < two_ropes:\n max_i = i\n max_two_ropes = two_ropes", "i", "range(n - 1)", "range", "n - 1", "n", "1", "two_ropes = aaa[i] + aaa[i + 1]", "two_ropes", "aaa[i] + aaa[i + 1]", "aaa[i]", "aaa", "i", "aaa[i + 1]", "aaa", "i + 1", "i", "1", "if max_two_ropes < two_ropes:\n max_i = i\n max_two_ropes = two_ropes", "max_two_ropes < two_ropes", "max_two_ropes", "two_ropes", "max_i = i", "max_i", "i", "max_two_ropes = two_ropes", "max_two_ropes", "two_ropes", "if max_two_ropes < l:\n print('Impossible')\nelse:\n print('Possible')\n ans = list(range(1, max_i + 1))\n ans.extend(range(n - 1, max_i + 1, -1))\n ans.append(max_i + 1)\n print('\\n'.join(map(str, ans)))", "max_two_ropes < l", "max_two_ropes", "l", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "ans = list(range(1, max_i + 1))", "ans", "list(range(1, max_i + 1))", "list", "range(1, max_i + 1)", "range", "1", "max_i + 1", "max_i", "1", "ans.extend(range(n - 1, max_i + 1, -1))", "ans.extend", "ans", "extend", "range(n - 1, max_i + 1, -1)", "range", "n - 1", "n", "1", "max_i + 1", "max_i", "1", "-1", "ans.append(max_i + 1)", "ans.append", "ans", "append", "max_i + 1", "max_i", "1", "print('\\n'.join(map(str, ans)))", "print", "'\\n'.join(map(str, ans))", "'\\n'.join", "'\\n'", "join", "map(str, ans)", "map", "str", "ans", "max_i = 0", "0", "max_i", "max_two_ropes = two_ropes", "two_ropes", "max_two_ropes", "n, l = map(int, input().split())", "map(int, input().split())", "n", "two_ropes = aaa[i] + aaa[i + 1]", "aaa[i] + aaa[i + 1]", "two_ropes", "l = map(int, input().split())", "map(int, input().split())", "l", "max_two_ropes = 0", "0", "max_two_ropes", "ans = list(range(1, max_i + 1))", "list(range(1, max_i + 1))", "ans", "aaa = list(map(int, input().split()))", "list(map(int, input().split()))", "aaa", "max_i = i", "i", "max_i" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 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, 14, 2, 13, 17, 4, 13, 17, 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, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 93, 2 ], [ 93, 11 ], [ 96, 13 ], [ 90, 23 ], [ 27, 26 ], [ 88, 30 ], [ 97, 36 ], [ 26, 37 ], [ 97, 39 ], [ 26, 41 ], [ 94, 43 ], [ 84, 45 ], [ 26, 47 ], [ 85, 51 ], [ 91, 51 ], [ 61, 60 ], [ 88, 64 ], [ 85, 66 ], [ 91, 66 ], [ 60, 70 ], [ 73, 72 ], [ 85, 76 ], [ 91, 76 ], [ 72, 79 ], [ 85, 82 ], [ 91, 82 ], [ 84, 85 ], [ 93, 88 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ] ]

[ "n,l=map(int,raw_input().split())\na=map(int,raw_input().split())\nfknot=0\nfor i in xrange(n-1):\n if a[i]+a[i+1]>=l:\n fknot=i+1\nif fknot==0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in xrange(n-1,fknot,-1):\n print(i)\n for i in xrange(1,fknot):\n print(i)\n print(fknot)", "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", "fknot=0", "fknot", "0", "for i in xrange(n-1):\n if a[i]+a[i+1]>=l:\n fknot=i+1", "i", "xrange(n-1)", "xrange", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n fknot=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", "fknot=i+1", "fknot", "i+1", "i", "1", "if fknot==0:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in xrange(n-1,fknot,-1):\n print(i)\n for i in xrange(1,fknot):\n print(i)\n print(fknot)", "fknot==0", "fknot", "0", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in xrange(n-1,fknot,-1):\n print(i)\n ", "i", "xrange(n-1,fknot,-1)", "xrange", "n-1", "n", "1", "fknot", "-1", "print(i)", "print", "i", "for i in xrange(1,fknot):\n print(i)\n ", "i", "xrange(1,fknot)", "xrange", "1", "fknot", "print(i)", "print", "i", "print(fknot)", "print", "fknot", "fknot=i+1", "i+1", "fknot", "n,l=map(int,raw_input().split())", "map(int,raw_input().split())", "n", "fknot=0", "0", "fknot", "l=map(int,raw_input().split())", "map(int,raw_input().split())", "l", "a=map(int,raw_input().split())", "map(int,raw_input().split())", "a" ]

[ 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, 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, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 95, 2 ], [ 95, 11 ], [ 92, 13 ], [ 98, 25 ], [ 29, 28 ], [ 90, 32 ], [ 93, 38 ], [ 28, 39 ], [ 93, 41 ], [ 28, 43 ], [ 96, 45 ], [ 86, 47 ], [ 28, 48 ], [ 87, 51 ], [ 99, 51 ], [ 61, 60 ], [ 87, 63 ], [ 99, 63 ], [ 60, 67 ], [ 71, 70 ], [ 90, 74 ], [ 87, 77 ], [ 99, 77 ], [ 70, 83 ], [ 28, 86 ], [ 86, 87 ], [ 95, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ] ]

[ "n,l = map(int,input().split())\na = list(map(int,input().split()))\n\nmemo = -1\nfor i in range(n-1):\n if a[i]+a[i+1] >= l:\n memo = i\n\nif memo == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(memo):\n print(i+1)\n for i in range(n-2,memo-1,-1):\n print(i+1)\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", "memo = -1", "memo", "-1", "for i in range(n-1):\n if a[i]+a[i+1] >= l:\n memo = i", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1] >= l:\n memo = 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", "memo = i", "memo", "i", "if memo == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(memo):\n print(i+1)\n for i in range(n-2,memo-1,-1):\n print(i+1)", "memo == -1", "memo", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(memo):\n print(i+1)\n ", "i", "range(memo)", "range", "memo", "print(i+1)", "print", "i+1", "i", "1", "for i in range(n-2,memo-1,-1):\n print(i+1)", "i", "range(n-2,memo-1,-1)", "range", "n-2", "n", "2", "memo-1", "memo", "1", "-1", "print(i+1)", "print", "i+1", "i", "1", "memo = i", "i", "memo", "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", "memo = -1", "-1", "memo" ]

[ 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, 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, 28, 13, 18, 13, 39, 17, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 39, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 117, 2 ], [ 117, 11 ], [ 105, 13 ], [ 114, 25 ], [ 29, 28 ], [ 118, 32 ], [ 106, 37 ], [ 28, 39 ], [ 106, 42 ], [ 28, 43 ], [ 112, 44 ], [ 102, 46 ], [ 28, 47 ], [ 103, 51 ], [ 115, 51 ], [ 108, 62 ], [ 67, 66 ], [ 103, 70 ], [ 115, 70 ], [ 109, 76 ], [ 66, 78 ], [ 81, 80 ], [ 103, 84 ], [ 115, 84 ], [ 118, 86 ], [ 109, 89 ], [ 80, 91 ], [ 94, 93 ], [ 109, 95 ], [ 93, 100 ], [ 28, 102 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 117, 112 ], [ 114, 115 ], [ 117, 118 ] ]

[ "# 隣り合う和がL未満ならそもそもimpossible\n# ならば隣り合う和がL以上ならば？ -> そこから連続して隣り合うやつをどうやって足しても常にL以上\n\nn, l = map(int, input().split())\na = list(map(int, input().split()))\nidx = 0\nfor i in range(1, n):\n if a[i - 1] + a[i] >= l:\n idx = i\n break\nif idx == 0:\n print(\"Impossible\")\n exit()\n\nprint(\"Possible\")\n\nans = [idx]\nfor i in range(idx - 1, 0, -1):\n ans.append(i)\nfor i in range(idx + 1, n):\n ans.append(i)\nfor a in ans[::-1]:\n print(a)", "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", "idx = 0", "idx", "0", "for i in range(1, n):\n if a[i - 1] + a[i] >= l:\n idx = i\n break", "i", "range(1, n)", "range", "1", "n", "if a[i - 1] + a[i] >= l:\n idx = 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", "idx = i", "idx", "i", "break", "if idx == 0:\n print(\"Impossible\")\n exit()", "idx == 0", "idx", "0", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "ans = [idx]", "ans", "[idx]", "idx", "for i in range(idx - 1, 0, -1):\n ans.append(i)", "i", "range(idx - 1, 0, -1)", "range", "idx - 1", "idx", "1", "0", "-1", "ans.append(i)", "ans.append", "ans", "append", "i", "for i in range(idx + 1, n):\n ans.append(i)", "i", "range(idx + 1, n)", "range", "idx + 1", "idx", "1", "n", "ans.append(i)", "ans.append", "ans", "append", "i", "for a in ans[::-1]:\n print(a)", "a", "ans[::-1]", "ans", "::-1", "-1", "print(a)", "print", "a", "idx = i", "i", "idx", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "ans = [idx]", "[idx]", "ans", "l = map(int, input().split())", "map(int, input().split())", "l", "idx = 0", "0", "idx", "n, l = map(int, input().split())", "map(int, input().split())", "n" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 13, 4, 18, 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, 3, 14, 2, 13, 17, 13, 13, 28, 13, 4, 13, 13, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 13, 17, 13, 10, 13, 13, 10, 4, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 89, 2 ], [ 89, 11 ], [ 80, 13 ], [ 83, 23 ], [ 92, 26 ], [ 30, 29 ], [ 90, 33 ], [ 81, 39 ], [ 29, 40 ], [ 81, 42 ], [ 29, 44 ], [ 87, 46 ], [ 77, 48 ], [ 29, 49 ], [ 78, 53 ], [ 93, 53 ], [ 59, 58 ], [ 78, 61 ], [ 93, 61 ], [ 58, 64 ], [ 68, 67 ], [ 90, 71 ], [ 78, 73 ], [ 93, 73 ], [ 29, 77 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 89, 87 ], [ 89, 90 ], [ 92, 93 ] ]

[ "n,l=map(int,raw_input().split())\na=map(int,raw_input().split())\nans=[]\nf=-1\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n f=i\n break\nif f==-1:\n print 'Impossible'\nelse:\n print 'Possible'\n for i in range(f):\n print i+1\n for i in range(n-1,f,-1):\n print i", "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", "ans=[]", "ans", "[]", "f=-1", "f", "-1", "for i in range(n-1):\n if a[i]+a[i+1]>=l:\n f=i\n break", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n f=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", "f=i", "f", "i", "break", "if f==-1:\n print 'Impossible'\nelse:\n print 'Possible'\n for i in range(f):\n print i+1\n for i in range(n-1,f,-1):\n print i", "f==-1", "f", "-1", "print", "print", "for i in range(f):\n print i+1\n ", "i", "range(f)", "range", "f", "print", "i+1", "i", "1", "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", "f=i", "i", "f", "a=map(int,raw_input().split())", "map(int,raw_input().split())", "a", "ans=[]", "[]", "ans", "l=map(int,raw_input().split())", "map(int,raw_input().split())", "l", "n,l=map(int,raw_input().split())", "map(int,raw_input().split())", "n", "f=-1", "-1", "f" ]

[ 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, 13, 4, 13, 13, 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, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 108, 2 ], [ 108, 11 ], [ 96, 13 ], [ 99, 25 ], [ 29, 28 ], [ 103, 32 ], [ 97, 38 ], [ 28, 39 ], [ 97, 41 ], [ 28, 43 ], [ 109, 45 ], [ 105, 47 ], [ 93, 50 ], [ 28, 51 ], [ 106, 55 ], [ 100, 55 ], [ 106, 59 ], [ 100, 59 ], [ 106, 62 ], [ 100, 62 ], [ 65, 64 ], [ 94, 67 ], [ 64, 71 ], [ 75, 74 ], [ 103, 78 ], [ 94, 80 ], [ 74, 85 ], [ 94, 90 ], [ 28, 93 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 108, 103 ], [ 105, 106 ], [ 108, 109 ] ]

[ "N, L = map( int, input().split())\nA = list( map( int, input().split()))\nans = \"Impossible\"\nfor i in range(N-1):\n if A[i] + A[i+1] >= L:\n ans = \"Possible\"\n t = i\n break\nif ans == \"Impossible\":\n print(ans)\nelse:\n print(ans)\n for i in range(t):\n print(i+1)\n for i in range(N-2,t,-1):\n print(i+1)\n print(t+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", "ans = \"Impossible\"", "ans", "\"Impossible\"", "for i in range(N-1):\n if A[i] + A[i+1] >= L:\n ans = \"Possible\"\n t = i\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i] + A[i+1] >= L:\n ans = \"Possible\"\n t = 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", "ans = \"Possible\"", "ans", "\"Possible\"", "t = i", "t", "i", "break", "if ans == \"Impossible\":\n print(ans)\nelse:\n print(ans)\n for i in range(t):\n print(i+1)\n for i in range(N-2,t,-1):\n print(i+1)\n print(t+1)", "ans == \"Impossible\"", "ans", "\"Impossible\"", "print(ans)", "print", "ans", "print(ans)", "print", "ans", "for i in range(t):\n print(i+1)\n ", "i", "range(t)", "range", "t", "print(i+1)", "print", "i+1", "i", "1", "for i in range(N-2,t,-1):\n print(i+1)\n ", "i", "range(N-2,t,-1)", "range", "N-2", "N", "2", "t", "-1", "print(i+1)", "print", "i+1", "i", "1", "print(t+1)", "print", "t+1", "t", "1", "t = i", "i", "t", "A = list( map( int, input().split()))", "list( map( int, input().split()))", "A", "ans = \"Impossible\"", "\"Impossible\"", "ans", "N, L = map( int, input().split())", "map( int, input().split())", "N", "ans = \"Possible\"", "\"Possible\"", "ans", "L = map( int, input().split())", "map( int, input().split())", "L" ]

[ 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, 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, 2, 13, 17, 14, 2, 13, 13, 4, 13, 17, 4, 13, 4, 13, 17, 28, 13, 4, 13, 17, 13, 14, 2, 13, 13, 3, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 17, 17, 14, 2, 13, 13, 4, 13, 13, 4, 13, 4, 13, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 134, 2 ], [ 134, 11 ], [ 15, 14 ], [ 14, 23 ], [ 116, 25 ], [ 131, 28 ], [ 119, 31 ], [ 35, 34 ], [ 135, 38 ], [ 117, 44 ], [ 34, 45 ], [ 117, 47 ], [ 34, 49 ], [ 132, 51 ], [ 123, 51 ], [ 122, 53 ], [ 117, 56 ], [ 34, 57 ], [ 117, 59 ], [ 34, 61 ], [ 125, 64 ], [ 34, 66 ], [ 123, 70 ], [ 132, 70 ], [ 129, 71 ], [ 82, 81 ], [ 135, 85 ], [ 81, 88 ], [ 126, 89 ], [ 120, 89 ], [ 81, 93 ], [ 96, 95 ], [ 135, 99 ], [ 95, 105 ], [ 126, 106 ], [ 120, 106 ], [ 95, 109 ], [ 95, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ], [ 134, 129 ], [ 131, 132 ], [ 134, 135 ] ]

[ "N, L = map(int, input().split())\na = [int(i) for i in input().split()]\n\nmax_k = 0\nmax_p = 0\n\nfor i in range(N-1):\n if a[i]+a[i+1] > max_k:\n max_k = a[i]+a[i+1]\n max_p = i+1\n\nif max_k < L:\n print('Impossible')\n exit()\nelse:\n print('Possible')\n\nfor i in range(1, N):\n if i == max_p:\n break\n else:\n print(i)\n\nfor i in range(N-1, 0, -1):\n if i == max_p:\n print(i)\n exit()\n else:\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()]", "max_k = 0", "max_k", "0", "max_p = 0", "max_p", "0", "for i in range(N-1):\n if a[i]+a[i+1] > max_k:\n max_k = a[i]+a[i+1]\n max_p = i+1", "i", "range(N-1)", "range", "N-1", "N", "1", "if a[i]+a[i+1] > max_k:\n max_k = a[i]+a[i+1]\n max_p = i+1", "a[i]+a[i+1] > max_k", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "max_k", "max_k = a[i]+a[i+1]", "max_k", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "max_p = i+1", "max_p", "i+1", "i", "1", "if max_k < L:\n print('Impossible')\n exit()\nelse:\n print('Possible')", "max_k < L", "max_k", "L", "print('Impossible')", "print", "'Impossible'", "exit()", "exit", "print('Possible')", "print", "'Possible'", "for i in range(1, N):\n if i == max_p:\n break\n else:\n print(i)", "i", "range(1, N)", "range", "1", "N", "if i == max_p:\n break\n else:\n print(i)", "i == max_p", "i", "max_p", "break", "print(i)", "print", "i", "for i in range(N-1, 0, -1):\n if i == max_p:\n print(i)\n exit()\n else:\n print(i)", "i", "range(N-1, 0, -1)", "range", "N-1", "N", "1", "0", "-1", "if i == max_p:\n print(i)\n exit()\n else:\n print(i)", "i == max_p", "i", "max_p", "print(i)", "print", "i", "exit()", "exit", "print(i)", "print", "i", "a = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "a", "max_p = 0", "0", "max_p", "max_k = a[i]+a[i+1]", "a[i]+a[i+1]", "max_k", "max_p = i+1", "i+1", "max_p", "L = map(int, input().split())", "map(int, input().split())", "L", "max_k = 0", "0", "max_k", "N, L = map(int, input().split())", "map(int, input().split())", "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, 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, 28, 13, 4, 13, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 17, 4, 13, 13, 4, 13, 2, 13, 17, 10, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 103, 2 ], [ 103, 11 ], [ 100, 13 ], [ 97, 25 ], [ 29, 28 ], [ 95, 32 ], [ 101, 38 ], [ 28, 39 ], [ 101, 41 ], [ 28, 43 ], [ 104, 45 ], [ 91, 47 ], [ 28, 48 ], [ 92, 51 ], [ 98, 51 ], [ 63, 62 ], [ 92, 65 ], [ 98, 65 ], [ 62, 69 ], [ 73, 72 ], [ 95, 76 ], [ 92, 79 ], [ 98, 79 ], [ 72, 84 ], [ 92, 88 ], [ 98, 88 ], [ 28, 91 ], [ 91, 92 ], [ 103, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ] ]

[ "n,l = map(int,input().split())\nal = list(map(int,input().split()))\n\ntarget = -1\nfor i in range(n-1):\n if al[i] + al[i+1] >= l:\n target = i\n\nif target == -1:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")\n for i in range(target):\n print(i+1)\n for i in range(n-1, target+1, -1):\n print(i)\n print(target+1)\n", "n,l = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "al = list(map(int,input().split()))", "al", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "target = -1", "target", "-1", "for i in range(n-1):\n if al[i] + al[i+1] >= l:\n target = i", "i", "range(n-1)", "range", "n-1", "n", "1", "if al[i] + al[i+1] >= l:\n target = i", "al[i] + al[i+1] >= l", "al[i] + al[i+1]", "al[i]", "al", "i", "al[i+1]", "al", "i+1", "i", "1", "l", "target = i", "target", "i", "if target == -1:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")\n for i in range(target):\n print(i+1)\n for i in range(n-1, target+1, -1):\n print(i)\n print(target+1)", "target == -1", "target", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(target):\n print(i+1)\n ", "i", "range(target)", "range", "target", "print(i+1)", "print", "i+1", "i", "1", "for i in range(n-1, target+1, -1):\n print(i)\n ", "i", "range(n-1, target+1, -1)", "range", "n-1", "n", "1", "target+1", "target", "1", "-1", "print(i)", "print", "i", "print(target+1)", "print", "target+1", "target", "1", "target = i", "i", "target", "n,l = map(int,input().split())", "map(int,input().split())", "n", "target = -1", "-1", "target", "al = list(map(int,input().split()))", "list(map(int,input().split()))", "al", "l = map(int,input().split())", "map(int,input().split())", "l" ]

[ 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, 4, 13, 17, 41, 28, 13, 4, 13, 17, 2, 13, 17, 4, 4, 13, 13, 4, 13, 4, 18, 17, 13, 2, 2, 13, 13, 39, 4, 13, 2, 13, 17, 0, 13, 17, 3, 14, 13, 4, 13, 17, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 100, 2 ], [ 100, 11 ], [ 94, 13 ], [ 88, 25 ], [ 29, 28 ], [ 98, 32 ], [ 95, 38 ], [ 28, 39 ], [ 95, 41 ], [ 28, 43 ], [ 101, 45 ], [ 52, 51 ], [ 28, 56 ], [ 51, 61 ], [ 28, 76 ], [ 91, 79 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ], [ 100, 98 ], [ 100, 101 ] ]

[ "n,l=map(int,input().split())\na=list(map(int,input().split()))\nf=True\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n print(\"Possible\")\n print(\"\\n\".join([str(j) for j in range(1,i+1)]+[str(j) for j in range(n-1,i+1,-1)]+[str(i+1)]))\n f=False\n break\nif f:\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", "f=True", "f", "True", "for i in range(n-1):\n if a[i]+a[i+1]>=l:\n print(\"Possible\")\n print(\"\\n\".join([str(j) for j in range(1,i+1)]+[str(j) for j in range(n-1,i+1,-1)]+[str(i+1)]))\n f=False\n break", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n print(\"Possible\")\n print(\"\\n\".join([str(j) for j in range(1,i+1)]+[str(j) for j in range(n-1,i+1,-1)]+[str(i+1)]))\n f=False\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\"", "str(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)", "str(j)", "str", "j", "print(\"\\n\".join([str(j) for j in range(1,i+1)]+[str(j) for j in range(n-1,i+1,-1)]+[str(i+1)]))", "print", "\"\\n\".join([str(j) for j in range(1,i+1)]+[str(j) for j in range(n-1,i+1,-1)]+[str(i+1)])", "\"\\n\".join", "\"\\n\"", "join", "[str(j) for j in range(1,i+1)]+[str(j) for j in range(n-1,i+1,-1)]+[str(i+1)]", "[str(j) for j in range(1,i+1)]+[str(j) for j in range(n-1,i+1,-1)]", "[str(j) for j in range(1,i+1)]", "[str(j) for j in range(n-1,i+1,-1)]", "[str(i+1)]", "str(i+1)", "str", "i+1", "i", "1", "f=False", "f", "False", "break", "if f:\n print(\"Impossible\")", "f", "print(\"Impossible\")", "print", "\"Impossible\"", "f=True", "True", "f", "f=False", "False", "f", "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" ]

[ 7, 15, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 2, 39, 13, 13, 12, 13, 23, 13, 23, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 13, 12, 13, 23, 13, 23, 13, 23, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 13, 12, 13, 23, 13, 23, 13, 23, 13, 23, 13, 23, 13, 12, 13, 23, 13, 23, 13, 17, 12, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 17, 12, 13, 12, 13, 12, 13, 12, 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, 0, 13, 39, 28, 13, 4, 13, 17, 13, 4, 18, 13, 13, 2, 18, 13, 2, 13, 17, 18, 13, 13, 0, 13, 4, 13, 13, 14, 2, 13, 13, 4, 13, 17, 4, 13, 4, 13, 17, 0, 13, 4, 18, 13, 13, 13, 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, 4, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 39, 13 ]

[ [ 8, 7 ], [ 19, 19 ], [ 21, 21 ], [ 23, 23 ], [ 27, 26 ], [ 35, 35 ], [ 37, 37 ], [ 39, 39 ], [ 41, 41 ], [ 45, 44 ], [ 53, 53 ], [ 55, 55 ], [ 57, 57 ], [ 59, 59 ], [ 61, 61 ], [ 65, 65 ], [ 68, 67 ], [ 76, 75 ], [ 251, 81 ], [ 86, 85 ], [ 208, 103 ], [ 241, 108 ], [ 238, 115 ], [ 224, 117 ], [ 238, 118 ], [ 226, 120 ], [ 212, 122 ], [ 256, 124 ], [ 128, 127 ], [ 239, 131 ], [ 257, 134 ], [ 227, 138 ], [ 127, 140 ], [ 227, 143 ], [ 127, 144 ], [ 229, 146 ], [ 257, 149 ], [ 230, 152 ], [ 200, 153 ], [ 202, 163 ], [ 257, 166 ], [ 230, 168 ], [ 171, 170 ], [ 203, 173 ], [ 170, 177 ], [ 181, 180 ], [ 239, 184 ], [ 203, 186 ], [ 180, 191 ], [ 203, 196 ], [ 238, 200 ], [ 202, 203 ], [ 208, 209 ], [ 226, 227 ], [ 229, 230 ], [ 238, 239 ], [ 241, 242 ], [ 256, 257 ] ]

[ "# -*- coding: utf-8 -*-\n\nimport sys\n\ndef input(): return sys.stdin.readline().strip()\ndef list2d(a, b, c): return [[c] * b for i in range(a)]\ndef list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]\ndef list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]\ndef ceil(x, y=1): return int(-(-x // y))\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]\ndef Yes(): print('Yes')\ndef No(): print('No')\ndef YES(): print('YES')\ndef NO(): print('NO')\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nMOD = 10 ** 9 + 7\n\nN, L = MAP()\nA = LIST()\n\n# 結び目のリストを作っておく\nB = []\nfor i in range(1, N):\n B.append(A[i-1]+A[i])\nmx = max(B)\n# 一番長いところがL未満なら無理\nif mx < L:\n print('Impossible')\n exit()\n\n# 一番長いところに集めてくるように切る\nprint('Possible')\nidx = B.index(mx)\nfor i in range(idx):\n print(i+1)\nfor i in range(N-2, idx, -1):\n print(i+1)\nprint(idx+1)", "import sys", "sys", "def input(): return sys.stdin.readline().strip()", "input", "[c] * b for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[c] * b", "[c]", "c", "b", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "list2d", "a", "a", "b", "b", "c", "c", "[[d] * c for j in range(b)] for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[[d] * c for j in range(b)]", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "list3d", "a", "a", "b", "b", "c", "c", "d", "d", "[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[[[e] * d for j in range(c)] for j in range(b)]", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "list4d", "a", "a", "b", "b", "c", "c", "d", "d", "e", "e", "def ceil(x, y=1): return int(-(-x // y))", "ceil", "x", "x", "y=1", "y", "1", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "MAP", "INT() for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "INT()", "INT", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "LIST", "N=None", "N", "None", "def Yes(): print('Yes')", "Yes", "def No(): print('No')", "No", "def YES(): print('YES')", "YES", "def NO(): print('NO')", "NO", "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", "B = []", "B", "[]", "for i in range(1, N):\n B.append(A[i-1]+A[i])", "i", "range(1, N)", "range", "1", "N", "B.append(A[i-1]+A[i])", "B.append", "B", "append", "A[i-1]+A[i]", "A[i-1]", "A", "i-1", "i", "1", "A[i]", "A", "i", "mx = max(B)", "mx", "max(B)", "max", "B", "if mx < L:\n print('Impossible')\n exit()\n\n# 一番長いところに集めてくるように切る", "mx < L", "mx", "L", "print('Impossible')", "print", "'Impossible'", "exit()", "exit", "print('Possible')", "print", "'Possible'", "idx = B.index(mx)", "idx", "B.index(mx)", "B.index", "B", "index", "mx", "for i in range(idx):\n print(i+1)", "i", "range(idx)", "range", "idx", "print(i+1)", "print", "i+1", "i", "1", "for i in range(N-2, idx, -1):\n print(i+1)", "i", "range(N-2, idx, -1)", "range", "N-2", "N", "2", "idx", "-1", "print(i+1)", "print", "i+1", "i", "1", "print(idx+1)", "print", "idx+1", "idx", "1", "L = MAP()", "MAP()", "L", "idx = B.index(mx)", "B.index(mx)", "idx", "def YES(): print('YES')", "def YES(): print('YES')", "YES", "INF = float('inf')", "float('inf')", "INF", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "LIST", "def No(): print('No')", "def No(): print('No')", "No", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "list4d", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "list2d", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP", "A = LIST()", "LIST()", "A", "mx = max(B)", "max(B)", "mx", "def Yes(): print('Yes')", "def Yes(): print('Yes')", "Yes", "def ceil(x, y=1): return int(-(-x // y))", "def ceil(x, y=1): return int(-(-x // y))", "ceil", "N, L = MAP()", "MAP()", "N", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "list3d", "def NO(): print('NO')", "def NO(): print('NO')", "NO", "def INT(): return int(input())", "def INT(): return int(input())", "INT", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "B = []", "[]", "B" ]

[ 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, 0, 13, 4, 13, 13, 0, 13, 17, 13, 2, 13, 17, 0, 13, 39, 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, 2, 13, 17, 3, 14, 2, 13, 17, 4, 13, 17, 4, 13, 17, 28, 13, 4, 13, 2, 13, 17, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 13, 17, 4, 13, 13, 4, 13, 13, 10, 2, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 125, 2 ], [ 125, 13 ], [ 137, 15 ], [ 116, 27 ], [ 138, 30 ], [ 131, 32 ], [ 110, 34 ], [ 120, 36 ], [ 113, 39 ], [ 134, 42 ], [ 128, 45 ], [ 49, 48 ], [ 120, 52 ], [ 138, 58 ], [ 48, 59 ], [ 138, 61 ], [ 48, 63 ], [ 126, 65 ], [ 122, 67 ], [ 48, 69 ], [ 123, 74 ], [ 129, 74 ], [ 84, 83 ], [ 123, 87 ], [ 129, 87 ], [ 83, 92 ], [ 96, 95 ], [ 120, 99 ], [ 123, 101 ], [ 129, 101 ], [ 95, 105 ], [ 123, 108 ], [ 129, 108 ], [ 110, 111 ], [ 113, 114 ], [ 116, 117 ], [ 125, 120 ], [ 122, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ], [ 134, 135 ], [ 137, 138 ] ]

[ "N, L = list(map(int, input().split()))\nAs = list(map(int, input().split()))\n\nsumL = sum(As)\n\nl,r = 0, N-1\nans = []\ncnt = 0\n\ncenter = -1\nfor i in range(N-1):\n if As[i]+As[i+1]>=L:\n center = i+1\n break\nif center < 0:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(center-1):\n print(i+1)\n for i in range(N-1, center, -1):\n print(i)\n print(center)\n# while sumL>=L and cnt < N-1:\n# # print(l,r,As[l],As[r])\n# if As[l] < As[r]:\n# # print('l<')\n# l += 1\n# sumL -= As[l]\n# ans.append(l)\n# cnt += 1\n# else:\n# # print('r<')\n# r -= 1\n# sumL -= As[r+1]\n# ans.append(r+1)\n# cnt += 1\n# # print('suml',sumL)\n# if cnt==N-1:\n# print('Possible')\n# for _a in ans:\n# print(_a)\n# else:\n# print('Impossible')", "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", "As = list(map(int, input().split()))", "As", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "sumL = sum(As)", "sumL", "sum(As)", "sum", "As", "l,r = 0, N-1", "l", "0", "r", "N-1", "N", "1", "ans = []", "ans", "[]", "cnt = 0", "cnt", "0", "center = -1", "center", "-1", "for i in range(N-1):\n if As[i]+As[i+1]>=L:\n center = i+1\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if As[i]+As[i+1]>=L:\n center = i+1\n break", "As[i]+As[i+1]>=L", "As[i]+As[i+1]", "As[i]", "As", "i", "As[i+1]", "As", "i+1", "i", "1", "L", "center = i+1", "center", "i+1", "i", "1", "break", "if center < 0:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(center-1):\n print(i+1)\n for i in range(N-1, center, -1):\n print(i)\n print(center)\n# while sumL>=L and cnt < N-1:\n# # print(l,r,As[l],As[r])\n# if As[l] < As[r]:\n# # print('l<')\n# l += 1\n# sumL -= As[l]\n# ans.append(l)\n# cnt += 1\n# else:\n# # print('r<')\n# r -= 1\n# sumL -= As[r+1]\n# ans.append(r+1)\n# cnt += 1\n# # print('suml',sumL)\n# if cnt==N-1:\n# print('Possible')\n# for _a in ans:\n# print(_a)\n# else:\n# print('Impossible')", "center < 0", "center", "0", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "for i in range(center-1):\n print(i+1)\n ", "i", "range(center-1)", "range", "center-1", "center", "1", "print(i+1)", "print", "i+1", "i", "1", "for i in range(N-1, center, -1):\n print(i)\n ", "i", "range(N-1, center, -1)", "range", "N-1", "N", "1", "center", "-1", "print(i)", "print", "i", "print(center)", "print", "center", "r = 0, N-1", "N-1", "r", "ans = []", "[]", "ans", "sumL = sum(As)", "sum(As)", "sumL", "N, L = list(map(int, input().split()))", "list(map(int, input().split()))", "N", "center = i+1", "i+1", "center", "L = list(map(int, input().split()))", "list(map(int, input().split()))", "L", "center = -1", "-1", "center", "l,r = 0, N-1", "0", "l", "cnt = 0", "0", "cnt", "As = list(map(int, input().split()))", "list(map(int, input().split()))", "As" ]

[ 7, 15, 13, 15, 13, 0, 13, 18, 13, 13, 0, 13, 12, 4, 13, 4, 13, 0, 13, 12, 4, 13, 4, 13, 13, 4, 18, 4, 18, 13, 13, 13, 0, 13, 12, 4, 18, 4, 18, 13, 13, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 4, 13, 13, 0, 13, 4, 18, 13, 13, 4, 13, 0, 13, 2, 18, 13, 39, 17, 18, 13, 39, 17, 14, 2, 4, 18, 13, 13, 13, 4, 13, 17, 4, 13, 4, 13, 17, 0, 13, 2, 18, 18, 4, 18, 13, 13, 40, 13, 13, 17, 17, 17, 28, 13, 4, 13, 17, 13, 14, 2, 13, 13, 3, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 17, 17, 14, 2, 13, 13, 3, 4, 13, 13, 4, 13, 13, 10, 12, 13, 10, 2, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 144, 6 ], [ 138, 11 ], [ 153, 18 ], [ 145, 29 ], [ 156, 33 ], [ 145, 39 ], [ 162, 50 ], [ 154, 52 ], [ 162, 53 ], [ 150, 55 ], [ 154, 61 ], [ 159, 63 ], [ 151, 66 ], [ 151, 70 ], [ 160, 77 ], [ 148, 79 ], [ 141, 89 ], [ 160, 98 ], [ 148, 99 ], [ 105, 104 ], [ 163, 108 ], [ 104, 111 ], [ 142, 112 ], [ 104, 116 ], [ 119, 118 ], [ 163, 122 ], [ 118, 128 ], [ 142, 129 ], [ 118, 133 ], [ 142, 136 ], [ 138, 139 ], [ 141, 142 ], [ 144, 145 ], [ 162, 148 ], [ 150, 151 ], [ 153, 154 ], [ 156, 157 ], [ 159, 160 ], [ 162, 163 ] ]

[ "import sys\nimport numpy as np\n\nstdin = sys.stdin\n\nri = lambda: int(rs())\nrl = lambda: list(map(int, stdin.readline().split())) # applies to only numbers\nrs = lambda: stdin.readline().rstrip() # ignore trailing spaces\nsys.setrecursionlimit(10 ** 7)\n\nN, L = rl()\nA = np.array(rl())\ncouple = A[:-1] + A[1:]\nif couple.max() < L:\n print('Impossible')\n exit()\nprint('Possible')\nindex = np.nonzero(couple>=L)[0][0] + 1\nfor i in range(1, N):\n if i == index:\n break\n print(i)\nfor i in range(N-1, 0, -1):\n if i == index:\n break\n print(i)\n\nprint(index)\n# 43", "import sys", "sys", "import numpy as np", "numpy", "stdin = sys.stdin", "stdin", "sys.stdin", "sys", "stdin", "ri = lambda: int(rs())", "ri", "lambda: int(rs())", "int(rs())", "int", "rs()", "rs", "rl = lambda: list(map(int, stdin.readline().split()))", "rl", "lambda: list(map(int, stdin.readline().split()))", "list(map(int, stdin.readline().split()))", "list", "map(int, stdin.readline().split())", "map", "int", "stdin.readline().split()", "stdin.readline().split", "stdin.readline()", "stdin.readline", "stdin", "readline", "split", "rs = lambda: stdin.readline().rstrip()", "rs", "lambda: stdin.readline().rstrip()", "stdin.readline().rstrip()", "stdin.readline().rstrip", "stdin.readline()", "stdin.readline", "stdin", "readline", "rstrip", "sys.setrecursionlimit(10 ** 7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 7", "10", "7", "N, L = rl()", "N", "rl()", "rl", "L", "A = np.array(rl())", "A", "np.array(rl())", "np.array", "np", "array", "rl()", "rl", "couple = A[:-1] + A[1:]", "couple", "A[:-1] + A[1:]", "A[:-1]", "A", ":-1", "-1", "A[1:]", "A", "1:", "1", "if couple.max() < L:\n print('Impossible')\n exit()", "couple.max() < L", "couple.max()", "couple.max", "couple", "max", "L", "print('Impossible')", "print", "'Impossible'", "exit()", "exit", "print('Possible')", "print", "'Possible'", "index = np.nonzero(couple>=L)[0][0] + 1", "index", "np.nonzero(couple>=L)[0][0] + 1", "np.nonzero(couple>=L)[0][0]", "[0]", "np.nonzero(couple>=L)", "np.nonzero", "np", "nonzero", "couple>=L", "couple", "L", "0", "0", "1", "for i in range(1, N):\n if i == index:\n break\n print(i)", "i", "range(1, N)", "range", "1", "N", "if i == index:\n break\n ", "i == index", "i", "index", "break", "print(i)", "print", "i", "for i in range(N-1, 0, -1):\n if i == index:\n break\n print(i)", "i", "range(N-1, 0, -1)", "range", "N-1", "N", "1", "0", "-1", "if i == index:\n break\n ", "i == index", "i", "index", "break", "print(i)", "print", "i", "print(index)", "print", "index", "ri = lambda: int(rs())", "lambda: int(rs())", "ri", "index = np.nonzero(couple>=L)[0][0] + 1", "np.nonzero(couple>=L)[0][0] + 1", "index", "stdin = sys.stdin", "sys.stdin", "stdin", "L = rl()", "rl()", "L", "A = np.array(rl())", "np.array(rl())", "A", "rl = lambda: list(map(int, stdin.readline().split()))", "lambda: list(map(int, stdin.readline().split()))", "rl", "rs = lambda: stdin.readline().rstrip()", "lambda: stdin.readline().rstrip()", "rs", "couple = A[:-1] + A[1:]", "A[:-1] + A[1:]", "couple", "N, L = rl()", "rl()", "N" ]

[ 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, 17, 4, 13, 17, 4, 18, 13, 13, 4, 13, 17, 28, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 13, 17, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 87, 4 ], [ 87, 13 ], [ 93, 15 ], [ 81, 27 ], [ 31, 30 ], [ 85, 34 ], [ 94, 40 ], [ 30, 41 ], [ 94, 43 ], [ 30, 45 ], [ 88, 47 ], [ 90, 49 ], [ 30, 50 ], [ 91, 54 ], [ 82, 54 ], [ 68, 67 ], [ 91, 70 ], [ 82, 70 ], [ 73, 72 ], [ 85, 76 ], [ 91, 78 ], [ 82, 78 ], [ 81, 82 ], [ 87, 85 ], [ 87, 88 ], [ 30, 90 ], [ 90, 91 ], [ 93, 94 ] ]

[ "import sys\nN, 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\nif last == -1:\n print('Impossible')\n sys.exit()\n\nprint('Possible')\nfor i in range(last): print(i+1)\nfor i in range(N-1, last, -1): print(i)", "import sys", "sys", "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')\n sys.exit()", "last == -1", "last", "-1", "print('Impossible')", "print", "'Impossible'", "sys.exit()", "sys.exit", "sys", "exit", "print('Possible')", "print", "'Possible'", "for i in range(last): print(i+1)", "i", "range(last)", "range", "last", "for i in range(N-1, last, -1): print(i)", "i", "range(N-1, last, -1)", "range", "N-1", "N", "1", "last", "-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", "last = i", "i", "last", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a" ]

[ 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, 2, 13, 17, 14, 2, 13, 13, 4, 13, 2, 13, 17, 14, 2, 13, 13, 4, 13, 2, 2, 13, 13, 13, 4, 13, 2, 13, 17, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 104, 2 ], [ 104, 11 ], [ 101, 13 ], [ 107, 25 ], [ 29, 28 ], [ 99, 32 ], [ 102, 38 ], [ 28, 39 ], [ 102, 41 ], [ 28, 43 ], [ 105, 45 ], [ 95, 47 ], [ 28, 48 ], [ 96, 52 ], [ 108, 52 ], [ 64, 63 ], [ 99, 67 ], [ 63, 71 ], [ 96, 72 ], [ 108, 72 ], [ 63, 76 ], [ 63, 80 ], [ 96, 81 ], [ 108, 81 ], [ 99, 86 ], [ 63, 87 ], [ 96, 88 ], [ 108, 88 ], [ 96, 92 ], [ 108, 92 ], [ 28, 95 ], [ 95, 96 ], [ 104, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ] ]

[ "n,l=map(int,input().split())\na=list(map(int,input().split()))\nf=-1\nfor i in range(n-1):\n\tif a[i]+a[i+1]>=l:\n\t\tf=i\n\t\tbreak\nif f==-1:\n\tprint(\"Impossible\")\n\texit()\nprint(\"Possible\")\nfor i in range(n-1):\n\tif i<f:\n\t\tprint(i+1)\n\telif i>f:\n\t\tprint(n-i+f)\nprint(f+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", "f=-1", "f", "-1", "for i in range(n-1):\n\tif a[i]+a[i+1]>=l:\n\t\tf=i\n\t\tbreak", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n\t\tf=i\n\t\tbreak", "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", "f", "i", "break", "if f==-1:\n\tprint(\"Impossible\")\n\texit()", "f==-1", "f", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(n-1):\n\tif i<f:\n\t\tprint(i+1)\n\telif i>f:\n\t\tprint(n-i+f)", "i", "range(n-1)", "range", "n-1", "n", "1", "if i<f:\n\t\tprint(i+1)\n\telif i>f:\n\t\tprint(n-i+f)", "i<f", "i", "f", "print(i+1)", "print", "i+1", "i", "1", "elif i>f:\n\t\tprint(n-i+f)", "i>f", "i", "f", "print(n-i+f)", "print", "n-i+f", "n-i", "n", "i", "f", "print(f+1)", "print", "f+1", "f", "1", "f=i", "i", "f", "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", "f=-1", "-1", "f" ]

[ 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, 17, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 95, 2 ], [ 95, 11 ], [ 89, 13 ], [ 83, 25 ], [ 29, 28 ], [ 87, 32 ], [ 90, 38 ], [ 28, 39 ], [ 90, 41 ], [ 28, 43 ], [ 96, 45 ], [ 92, 47 ], [ 28, 48 ], [ 93, 52 ], [ 84, 52 ], [ 62, 61 ], [ 93, 64 ], [ 84, 64 ], [ 61, 68 ], [ 72, 71 ], [ 87, 75 ], [ 93, 77 ], [ 84, 77 ], [ 71, 81 ], [ 83, 84 ], [ 95, 87 ], [ 89, 90 ], [ 28, 92 ], [ 92, 93 ], [ 95, 96 ] ]

[ "N, L = map(int, input().split())\na = list(map(int, input().split()))\n\nidx = -1\nfor i in range(N - 1):\n if a[i] + a[i + 1] >= L:\n idx = i\n break\n\nif idx == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(idx):\n print(i + 1)\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", "idx = -1", "idx", "-1", "for i in range(N - 1):\n if a[i] + a[i + 1] >= L:\n idx = i\n break", "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", "if idx == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(idx):\n print(i + 1)\n for i in range(N - 1, idx, -1):\n print(i)", "idx == -1", "idx", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(idx):\n print(i + 1)\n ", "i", "range(idx)", "range", "idx", "print(i + 1)", "print", "i + 1", "i", "1", "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", "idx = -1", "-1", "idx", "N, L = map(int, input().split())", "map(int, input().split())", "N", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "idx = i", "i", "idx", "L = map(int, input().split())", "map(int, input().split())", "L" ]

[ 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, 17, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 13, 17, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 99, 2 ], [ 99, 11 ], [ 93, 13 ], [ 96, 25 ], [ 29, 28 ], [ 100, 32 ], [ 94, 38 ], [ 28, 39 ], [ 94, 41 ], [ 28, 43 ], [ 91, 45 ], [ 87, 47 ], [ 28, 48 ], [ 88, 52 ], [ 97, 52 ], [ 64, 63 ], [ 88, 68 ], [ 97, 68 ], [ 63, 73 ], [ 76, 75 ], [ 100, 79 ], [ 88, 81 ], [ 97, 81 ], [ 75, 85 ], [ 28, 87 ], [ 87, 88 ], [ 99, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ] ]

[ "n,l=map(int, input().split())\na=list(map(int, input().split()))\n\nf = -1\nfor i in range(n-1):\n if a[i] + a[i+1] >= l:\n f = i\n break\nif f == -1:\n print('Impossible')\n exit()\nprint('Possible')\nfor i in range(1,f+1,1):\n print(i)\nfor i in range(n-1,f,-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", "f = -1", "f", "-1", "for i in range(n-1):\n if a[i] + a[i+1] >= l:\n f = i\n break", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i] + a[i+1] >= l:\n f = 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", "f = i", "f", "i", "break", "if f == -1:\n print('Impossible')\n exit()", "f == -1", "f", "-1", "print('Impossible')", "print", "'Impossible'", "exit()", "exit", "print('Possible')", "print", "'Possible'", "for i in range(1,f+1,1):\n print(i)", "i", "range(1,f+1,1)", "range", "1", "f+1", "f", "1", "1", "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", "f = i", "i", "f", "l=map(int, input().split())", "map(int, input().split())", "l", "a=list(map(int, input().split()))", "list(map(int, input().split()))", "a", "f = -1", "-1", "f", "n,l=map(int, input().split())", "map(int, input().split())", "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, 14, 2, 13, 17, 14, 2, 2, 18, 13, 17, 18, 13, 17, 13, 4, 13, 17, 4, 13, 17, 4, 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, 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, 17, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 126, 2 ], [ 126, 11 ], [ 135, 13 ], [ 127, 26 ], [ 136, 32 ], [ 136, 35 ], [ 124, 37 ], [ 120, 48 ], [ 52, 51 ], [ 127, 55 ], [ 136, 61 ], [ 51, 62 ], [ 136, 64 ], [ 51, 66 ], [ 121, 68 ], [ 133, 68 ], [ 132, 70 ], [ 136, 73 ], [ 51, 74 ], [ 136, 76 ], [ 51, 78 ], [ 129, 81 ], [ 51, 83 ], [ 133, 87 ], [ 121, 87 ], [ 124, 88 ], [ 97, 96 ], [ 130, 100 ], [ 96, 103 ], [ 106, 105 ], [ 127, 109 ], [ 130, 111 ], [ 105, 115 ], [ 130, 118 ], [ 120, 121 ], [ 126, 124 ], [ 126, 127 ], [ 129, 130 ], [ 132, 133 ], [ 135, 136 ] ]

[ "n, l = map(int, input().split())\na = list(map(int, input().split()))\n\nif n == 2:\n\tif a[0] + a[1] < l:\n\t\tprint(\"Impossible\")\n\telse:\n\t\tprint(\"Possible\")\n\t\tprint(1)\n\nelse:\n\tnagai = 0\n\tfor i in range(n - 1):\n\t\tif a[i] + a[i + 1] > nagai:\n\t\t\tnagai = a[i] + a[i + 1]\n\t\t\tnagai_index = i + 1\n\n\tif nagai < l:\n\t\tprint(\"Impossible\")\n\telse:\n\t\tprint(\"Possible\")\n\t\tfor i in range(1, nagai_index):\n\t\t\tprint(i)\n\t\tfor i in range(n - 1, nagai_index, -1):\n\t\t\tprint(i)\n\t\tprint(nagai_index)", "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\tif a[0] + a[1] < l:\n\t\tprint(\"Impossible\")\n\telse:\n\t\tprint(\"Possible\")\n\t\tprint(1)\n\nelse:\n\tnagai = 0\n\tfor i in range(n - 1):\n\t\tif a[i] + a[i + 1] > nagai:\n\t\t\tnagai = a[i] + a[i + 1]\n\t\t\tnagai_index = i + 1\n\n\tif nagai < l:\n\t\tprint(\"Impossible\")\n\telse:\n\t\tprint(\"Possible\")\n\t\tfor i in range(1, nagai_index):\n\t\t\tprint(i)\n\t\tfor i in range(n - 1, nagai_index, -1):\n\t\t\tprint(i)\n\t\tprint(nagai_index)", "n == 2", "n", "2", "if a[0] + a[1] < l:\n\t\tprint(\"Impossible\")\n\telse:\n\t\tprint(\"Possible\")\n\t\tprint(1)", "a[0] + a[1] < l", "a[0] + a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "l", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "print(1)", "print", "1", "nagai = 0", "nagai", "0", "for i in range(n - 1):\n\t\tif a[i] + a[i + 1] > nagai:\n\t\t\tnagai = a[i] + a[i + 1]\n\t\t\tnagai_index = i + 1\n\n\t", "i", "range(n - 1)", "range", "n - 1", "n", "1", "if a[i] + a[i + 1] > nagai:\n\t\t\tnagai = a[i] + a[i + 1]\n\t\t\tnagai_index = i + 1\n\n\t", "a[i] + a[i + 1] > nagai", "a[i] + a[i + 1]", "a[i]", "a", "i", "a[i + 1]", "a", "i + 1", "i", "1", "nagai", "nagai = a[i] + a[i + 1]", "nagai", "a[i] + a[i + 1]", "a[i]", "a", "i", "a[i + 1]", "a", "i + 1", "i", "1", "nagai_index = i + 1", "nagai_index", "i + 1", "i", "1", "if nagai < l:\n\t\tprint(\"Impossible\")\n\telse:\n\t\tprint(\"Possible\")\n\t\tfor i in range(1, nagai_index):\n\t\t\tprint(i)\n\t\tfor i in range(n - 1, nagai_index, -1):\n\t\t\tprint(i)\n\t\tprint(nagai_index)", "nagai < l", "nagai", "l", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1, nagai_index):\n\t\t\tprint(i)\n\t\t", "i", "range(1, nagai_index)", "range", "1", "nagai_index", "print(i)", "print", "i", "for i in range(n - 1, nagai_index, -1):\n\t\t\tprint(i)\n\t\t", "i", "range(n - 1, nagai_index, -1)", "range", "n - 1", "n", "1", "nagai_index", "-1", "print(i)", "print", "i", "print(nagai_index)", "print", "nagai_index", "nagai = 0", "0", "nagai", "l = map(int, input().split())", "map(int, input().split())", "l", "n, l = map(int, input().split())", "map(int, input().split())", "n", "nagai_index = i + 1", "i + 1", "nagai_index", "nagai = a[i] + a[i + 1]", "a[i] + a[i + 1]", "nagai", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a" ]

[ 7, 15, 13, 15, 13, 15, 15, 13, 15, 0, 13, 18, 13, 13, 4, 13, 2, 17, 17, 12, 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, 0, 13, 18, 13, 17, 0, 13, 17, 28, 13, 13, 4, 13, 18, 13, 39, 17, 14, 40, 2, 13, 13, 13, 4, 13, 17, 0, 13, 13, 3, 0, 13, 13, 14, 2, 13, 17, 4, 13, 17, 4, 13, 28, 13, 4, 13, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 4, 13, 2, 2, 13, 13, 17, 29, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 123, 10 ], [ 23, 22 ], [ 124, 29 ], [ 23, 31 ], [ 35, 34 ], [ 124, 38 ], [ 34, 43 ], [ 46, 45 ], [ 49, 48 ], [ 45, 50 ], [ 54, 53 ], [ 45, 61 ], [ 48, 67 ], [ 78, 67 ], [ 31, 69 ], [ 75, 74 ], [ 79, 78 ], [ 74, 82 ], [ 53, 82 ], [ 91, 90 ], [ 74, 93 ], [ 53, 93 ], [ 90, 97 ], [ 101, 100 ], [ 22, 105 ], [ 74, 106 ], [ 53, 106 ], [ 22, 112 ], [ 100, 113 ], [ 127, 121 ], [ 123, 124 ] ]

[ "import math\n#import numpy as np\nimport queue\nfrom collections import deque,defaultdict\nimport heapq as hpq\nfrom sys import stdin,setrecursionlimit\n#from scipy.sparse.csgraph import dijkstra\n#from scipy.sparse import csr_matrix\nipt = stdin.readline\nsetrecursionlimit(10**7)\n\ndef main():\n n,l = map(int,ipt().split())\n a = [int(i) for i in ipt().split()]\n pa = a[0]\n mi = -1\n for i,ai in enumerate(a[1::]):\n if pa+ai >= l:\n print(\"Possible\")\n mi = i\n break\n pa = ai\n if mi == -1:\n print(\"Impossible\")\n exit()\n for i in range(mi):\n print(i+1)\n for i in range(n-mi-1):\n print(n-i-1)\n\n return\n\nif __name__ == '__main__':\n main()", "import math", "math", "import queue", "queue", "from collections import deque,defaultdict", "import heapq as hpq", "heapq", "from sys import stdin,setrecursionlimit", "ipt = stdin.readline", "ipt", "stdin.readline", "stdin", "readline", "setrecursionlimit(10**7)", "setrecursionlimit", "10**7", "10", "7", "def main():\n n,l = map(int,ipt().split())\n a = [int(i) for i in ipt().split()]\n pa = a[0]\n mi = -1\n for i,ai in enumerate(a[1::]):\n if pa+ai >= l:\n print(\"Possible\")\n mi = i\n break\n pa = ai\n if mi == -1:\n print(\"Impossible\")\n exit()\n for i in range(mi):\n print(i+1)\n for i in range(n-mi-1):\n print(n-i-1)\n\n return", "main", "n,l = map(int,ipt().split())", "n", "map(int,ipt().split())", "map", "int", "ipt().split()", "().split", "()", "ipt", "split", "l", "int(i) for i in ipt().split()", "for i in ipt().split()", "i", "ipt().split()", "().split", "()", "ipt", "split", "for i in ipt().split()", "int(i)", "int", "i", "a = [int(i) for i in ipt().split()]", "a", "[int(i) for i in ipt().split()]", "pa = a[0]", "pa", "a[0]", "a", "0", "mi = -1", "mi", "-1", "for i,ai in enumerate(a[1::]):\n if pa+ai >= l:\n print(\"Possible\")\n mi = i\n break\n pa = ai\n ", "i", "ai", "enumerate(a[1::])", "enumerate", "a[1::]", "a", "1::", "1", "if pa+ai >= l:\n print(\"Possible\")\n mi = i\n break\n ", "pa+ai >= l", "pa+ai", "pa", "ai", "l", "print(\"Possible\")", "print", "\"Possible\"", "mi = i", "mi", "i", "break", "pa = ai", "pa", "ai", "if mi == -1:\n print(\"Impossible\")\n exit()\n ", "mi == -1", "mi", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "for i in range(mi):\n print(i+1)\n ", "i", "range(mi)", "range", "mi", "print(i+1)", "print", "i+1", "i", "1", "for i in range(n-mi-1):\n print(n-i-1)\n\n ", "i", "range(n-mi-1)", "range", "n-mi-1", "n-mi", "n", "mi", "1", "print(n-i-1)", "print", "n-i-1", "n-i", "n", "i", "1", "return", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "ipt = stdin.readline", "stdin.readline", "ipt", "def main():\n n,l = map(int,ipt().split())\n a = [int(i) for i in ipt().split()]\n pa = a[0]\n mi = -1\n for i,ai in enumerate(a[1::]):\n if pa+ai >= l:\n print(\"Possible\")\n mi = i\n break\n pa = ai\n if mi == -1:\n print(\"Impossible\")\n exit()\n for i in range(mi):\n print(i+1)\n for i in range(n-mi-1):\n print(n-i-1)\n\n return", "def main():\n n,l = map(int,ipt().split())\n a = [int(i) for i in ipt().split()]\n pa = a[0]\n mi = -1\n for i,ai in enumerate(a[1::]):\n if pa+ai >= l:\n print(\"Possible\")\n mi = i\n break\n pa = ai\n if mi == -1:\n print(\"Impossible\")\n exit()\n for i in range(mi):\n print(i+1)\n for i in range(n-mi-1):\n print(n-i-1)\n\n return", "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, 4, 13, 17, 4, 13, 4, 13, 17, 14, 2, 13, 17, 28, 13, 4, 13, 13, 14, 2, 2, 13, 17, 13, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 17, 4, 13, 2, 13, 17, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 99, 2 ], [ 99, 11 ], [ 90, 13 ], [ 96, 25 ], [ 29, 28 ], [ 94, 32 ], [ 91, 38 ], [ 28, 39 ], [ 91, 41 ], [ 28, 43 ], [ 100, 45 ], [ 102, 47 ], [ 28, 48 ], [ 103, 60 ], [ 97, 60 ], [ 64, 63 ], [ 103, 66 ], [ 97, 66 ], [ 103, 70 ], [ 97, 70 ], [ 94, 72 ], [ 75, 74 ], [ 94, 78 ], [ 103, 81 ], [ 97, 81 ], [ 103, 87 ], [ 97, 87 ], [ 90, 91 ], [ 99, 94 ], [ 96, 97 ], [ 99, 100 ], [ 28, 102 ], [ 102, 103 ] ]

[ "n,l= map(int,input().split())\na= list(map(int,input().split()))\nrh=-1\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n rh=i\n break\nelse:\n print('Impossible')\n exit()\nprint('Possible')\nif rh>0:\n for i in range(rh):print(i+1)\nif rh+1<n:\n for i in range(n-1,rh+1,-1):print(i)\nprint(rh+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", "rh=-1", "rh", "-1", "for i in range(n-1):\n if a[i]+a[i+1]>=l:\n rh=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 rh=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", "rh=i", "rh", "i", "break", "print('Impossible')", "print", "'Impossible'", "exit()", "exit", "print('Possible')", "print", "'Possible'", "if rh>0:\n for i in range(rh):print(i+1)", "rh>0", "rh", "0", "for i in range(rh):print(", "i", "range(rh)", "range", "rh", "if rh+1<n:\n for i in range(n-1,rh+1,-1):print(i)", "rh+1<n", "rh+1", "rh", "1", "n", "for i in range(n-1,rh+1,-1):prin", "i", "range(n-1,rh+1,-1)", "range", "n-1", "n", "1", "rh+1", "rh", "1", "-1", "print(rh+1)", "print", "rh+1", "rh", "1", "a= list(map(int,input().split()))", "list(map(int,input().split()))", "a", "n,l= map(int,input().split())", "map(int,input().split())", "n", "rh=-1", "-1", "rh", "l= map(int,input().split())", "map(int,input().split())", "l", "rh=i", "i", "rh" ]

[ 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, 14, 13, 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, 17, 13, 4, 13, 17, 10, 13, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 106, 2 ], [ 106, 11 ], [ 97, 13 ], [ 103, 25 ], [ 109, 28 ], [ 32, 31 ], [ 101, 35 ], [ 98, 41 ], [ 31, 42 ], [ 98, 44 ], [ 31, 46 ], [ 107, 48 ], [ 94, 50 ], [ 91, 53 ], [ 31, 54 ], [ 63, 62 ], [ 92, 65 ], [ 110, 65 ], [ 62, 69 ], [ 73, 72 ], [ 101, 77 ], [ 92, 79 ], [ 110, 79 ], [ 101, 84 ], [ 72, 86 ], [ 31, 91 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 106, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ] ]

[ "\nN,L = map(int,input().split())\n\na = list(map(int,input().split()))\n\nflag = False\nable = 0\nfor i in range(N-1):\n\n if a[i] + a[i+1] >= L:\n flag = True\n able = i\n break\n\nif flag:\n\n print (\"Possible\")\n\n for i in range(able):\n print (i+1)\n\n for i in range(N-1-able):\n print (N-1-i)\n\n #print (able + 1)\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", "flag = False", "flag", "False", "able = 0", "able", "0", "for i in range(N-1):\n\n if a[i] + a[i+1] >= L:\n flag = True\n able = i\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if a[i] + a[i+1] >= L:\n flag = True\n able = 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 = True", "flag", "True", "able = i", "able", "i", "break", "if flag:\n\n print (\"Possible\")\n\n for i in range(able):\n print (i+1)\n\n for i in range(N-1-able):\n print (N-1-i)\n\n #print (able + 1)\n\nelse:\n print (\"Impossible\")", "flag", "print (\"Possible\")", "print", "\"Possible\"", "for i in range(able):\n print (i+1)\n\n ", "i", "range(able)", "range", "able", "print (i+1)", "print", "i+1", "i", "1", "for i in range(N-1-able):\n print (N-1-i)\n\n #print (able + 1)", "i", "range(N-1-able)", "range", "N-1-able", "N-1", "N", "1", "able", "print (N-1-i)", "print", "N-1-i", "N-1", "N", "1", "i", "print (\"Impossible\")", "print", "\"Impossible\"", "able = i", "i", "able", "flag = True", "True", "flag", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "N,L = map(int,input().split())", "map(int,input().split())", "N", "flag = False", "False", "flag", "L = map(int,input().split())", "map(int,input().split())", "L", "able = 0", "0", "able" ]

[ 7, 15, 13, 0, 13, 18, 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, 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, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 102, 4 ], [ 16, 15 ], [ 103, 22 ], [ 16, 24 ], [ 27, 26 ], [ 103, 35 ], [ 39, 38 ], [ 42, 41 ], [ 15, 45 ], [ 26, 51 ], [ 41, 52 ], [ 26, 54 ], [ 41, 56 ], [ 24, 58 ], [ 61, 60 ], [ 41, 61 ], [ 60, 65 ], [ 38, 65 ], [ 75, 74 ], [ 74, 81 ], [ 85, 84 ], [ 15, 88 ], [ 84, 94 ], [ 106, 100 ], [ 102, 103 ] ]

[ "import sys\ninput = sys.stdin.buffer.readline\n\ndef main():\n N,M = map(int,input().split())\n a = list(map(int,input().split()))\n use = -1\n for i in range(N-1):\n if a[i]+a[i+1] >= M:\n use = i\n break\n \n if use == -1:\n print(\"Impossible\")\n else:\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\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "input = sys.stdin.buffer.readline", "input", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "def main():\n N,M = map(int,input().split())\n a = list(map(int,input().split()))\n use = -1\n for i in range(N-1):\n if a[i]+a[i+1] >= M:\n use = i\n break\n \n if use == -1:\n print(\"Impossible\")\n else:\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)", "main", "N,M = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "use = -1", "use", "-1", "for i in range(N-1):\n if a[i]+a[i+1] >= M:\n use = i\n break\n \n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if a[i]+a[i+1] >= M:\n use = i\n break\n \n ", "a[i]+a[i+1] >= M", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "M", "use = i", "use", "i", "break", "if use == -1:\n print(\"Impossible\")\n else:\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)", "use == -1", "use", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "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)", "j", "range(N-1,i,-1)", "range", "N-1", "N", "1", "i", "-1", "print(j)", "print", "j", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "input = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "input", "def main():\n N,M = map(int,input().split())\n a = list(map(int,input().split()))\n use = -1\n for i in range(N-1):\n if a[i]+a[i+1] >= M:\n use = i\n break\n \n if use == -1:\n print(\"Impossible\")\n else:\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)", "def main():\n N,M = map(int,input().split())\n a = list(map(int,input().split()))\n use = -1\n for i in range(N-1):\n if a[i]+a[i+1] >= M:\n use = i\n break\n \n if use == -1:\n print(\"Impossible\")\n else:\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)", "main" ]

[ 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, 2, 18, 13, 17, 18, 13, 17, 0, 13, 17, 28, 13, 4, 13, 17, 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, 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, 17, 13, 10, 13, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 127, 14 ], [ 127, 16 ], [ 20, 19 ], [ 19, 28 ], [ 133, 30 ], [ 118, 33 ], [ 134, 36 ], [ 134, 39 ], [ 112, 42 ], [ 46, 45 ], [ 116, 50 ], [ 121, 53 ], [ 134, 56 ], [ 45, 57 ], [ 134, 59 ], [ 45, 61 ], [ 122, 65 ], [ 119, 66 ], [ 131, 66 ], [ 130, 68 ], [ 122, 69 ], [ 124, 71 ], [ 45, 73 ], [ 131, 77 ], [ 119, 77 ], [ 128, 78 ], [ 89, 88 ], [ 125, 92 ], [ 113, 92 ], [ 88, 95 ], [ 98, 97 ], [ 116, 101 ], [ 125, 103 ], [ 113, 103 ], [ 97, 107 ], [ 125, 110 ], [ 113, 110 ], [ 112, 113 ], [ 127, 116 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ], [ 127, 128 ], [ 122, 130 ], [ 130, 131 ], [ 133, 134 ] ]

[ "n,l = [int(i) for i in input().split()]\na=[int(i) for i in input().split()]\n#b=[int(i) for i in input().split()]\n\nmax_len = a[0]+a[1]\nmax_joint = 1\n\nfor i in range(1,n-1):\n len = a[i] + a[i+1]\n if len > max_len:\n max_len = len\n max_joint = i+1\n\n\nif max_len < l:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")\n for i in range(1,max_joint):\n print(i)\n for i in range(n-1, max_joint, -1):\n print(i)\n print(max_joint)", "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()]", "max_len = a[0]+a[1]", "max_len", "a[0]+a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "max_joint = 1", "max_joint", "1", "for i in range(1,n-1):\n len = a[i] + a[i+1]\n if len > max_len:\n max_len = len\n max_joint = i+1", "i", "range(1,n-1)", "range", "1", "n-1", "n", "1", "len = a[i] + a[i+1]", "len", "a[i] + a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "if len > max_len:\n max_len = len\n max_joint = i+1", "len > max_len", "len", "max_len", "max_len = len", "max_len", "len", "max_joint = i+1", "max_joint", "i+1", "i", "1", "if max_len < l:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")\n for i in range(1,max_joint):\n print(i)\n for i in range(n-1, max_joint, -1):\n print(i)\n print(max_joint)", "max_len < l", "max_len", "l", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,max_joint):\n print(i)\n ", "i", "range(1,max_joint)", "range", "1", "max_joint", "print(i)", "print", "i", "for i in range(n-1, max_joint, -1):\n print(i)\n ", "i", "range(n-1, max_joint, -1)", "range", "n-1", "n", "1", "max_joint", "-1", "print(i)", "print", "i", "print(max_joint)", "print", "max_joint", "max_joint = 1", "1", "max_joint", "n,l = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "n", "max_len = a[0]+a[1]", "a[0]+a[1]", "max_len", "len = a[i] + a[i+1]", "a[i] + a[i+1]", "len", "max_joint = i+1", "i+1", "max_joint", "l = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "l", "max_len = len", "len", "max_len", "a=[int(i) for i in input().split()]", "[int(i) for i in input().split()]", "a" ]

[ 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, 13, 18, 13, 2, 13, 17, 13, 0, 13, 2, 13, 17, 3, 14, 2, 13, 17, 4, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 41, 28, 13, 4, 13, 13, 13, 4, 13, 28, 13, 18, 13, 39, 17, 4, 13, 2, 13, 17, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 99, 2 ], [ 99, 11 ], [ 90, 13 ], [ 96, 25 ], [ 29, 28 ], [ 94, 32 ], [ 91, 37 ], [ 28, 38 ], [ 91, 40 ], [ 28, 42 ], [ 100, 44 ], [ 87, 46 ], [ 28, 48 ], [ 88, 53 ], [ 97, 53 ], [ 60, 59 ], [ 88, 64 ], [ 97, 64 ], [ 69, 68 ], [ 88, 71 ], [ 97, 71 ], [ 94, 72 ], [ 68, 74 ], [ 77, 76 ], [ 88, 84 ], [ 97, 84 ], [ 87, 88 ], [ 90, 91 ], [ 99, 94 ], [ 96, 97 ], [ 99, 100 ] ]

[ "n,l=map(int,input().split())\nA=list(map(int,input().split()))\nadd=0\nfor i in range(1,n):\n if A[i]+A[i-1]>=l:\n add=i+1\n break\nif add==0:print(\"Impossible\");exit()\nprint(\"Possible\")\nfor i in range(1,add-1):print(i)\nfor i in [j for j in range(add,n)][::-1]:print(i)\nprint(add-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", "add=0", "add", "0", "for i in range(1,n):\n if A[i]+A[i-1]>=l:\n add=i+1\n break", "i", "range(1,n)", "range", "1", "n", "if A[i]+A[i-1]>=l:\n add=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", "add=i+1", "add", "i+1", "i", "1", "break", "if add==0:print(\"Impossible\");exit()", "add==0", "add", "0", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,add-1):print(i)", "i", "range(1,add-1)", "range", "1", "add-1", "add", "1", "j for j in range(add,n)", "for j in range(add,n)", "j", "range(add,n)", "range", "add", "n", "for j in range(add,n)", "j", "for i in [j for j in range(add,n)][::-1]:print(i)", "i", "[j for j in range(add,n)][::-1]", "[j for j in range(add,n)]", "::-1", "-1", "print(add-1)", "print", "add-1", "add", "1", "add=i+1", "i+1", "add", "A=list(map(int,input().split()))", "list(map(int,input().split()))", "A", "n,l=map(int,input().split())", "map(int,input().split())", "n", "add=0", "0", "add", "l=map(int,input().split())", "map(int,input().split())", "l" ]

[ 7, 15, 15, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 18, 13, 13, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 18, 13, 13, 13, 4, 13, 17, 13, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 2, 2, 4, 13, 17, 2, 13, 17, 4, 13, 2, 13, 17, 2, 13, 17, 17, 39, 2, 13, 17, 4, 18, 13, 13, 17, 4, 18, 13, 13, 4, 18, 17, 13, 4, 13, 13, 13, 4, 18, 13, 13, 17, 29, 13, 4, 13, 10, 12, 13 ]

[ [ 7, 6 ], [ 7, 17 ], [ 20, 19 ], [ 6, 33 ], [ 36, 35 ], [ 6, 39 ], [ 19, 45 ], [ 35, 46 ], [ 19, 48 ], [ 35, 50 ], [ 17, 52 ], [ 55, 54 ], [ 35, 61 ], [ 6, 66 ], [ 35, 69 ], [ 35, 74 ], [ 54, 92 ], [ 104, 101 ] ]

[ "from sys import stdin, stdout\nfrom itertools import repeat\ndef main():\n n, l = map(int, stdin.readline().split())\n a = map(int, stdin.read().split(), repeat(10, n))\n for i in xrange(n - 1):\n\tif a[i] + a[i+1] >= l:\n ans = range(1, i + 1) + range(n - 1, i + 1, -1) + [i + 1]\n stdout.write('Possible\\n')\n stdout.write('\\n'.join(map(str, ans)))\n stdout.write('\\n')\n return\n print \"Impossible\"\nmain()", "from sys import stdin, stdout", "from itertools import repeat", "def main():\n n, l = map(int, stdin.readline().split())\n a = map(int, stdin.read().split(), repeat(10, n))\n for i in xrange(n - 1):\n\tif a[i] + a[i+1] >= l:\n ans = range(1, i + 1) + range(n - 1, i + 1, -1) + [i + 1]\n stdout.write('Possible\\n')\n stdout.write('\\n'.join(map(str, ans)))\n stdout.write('\\n')\n return\n print \"Impossible\"", "main", "n, l = map(int, stdin.readline().split())", "n", "map(int, stdin.readline().split())", "map", "int", "stdin.readline().split()", "stdin.readline().split", "stdin.readline()", "stdin.readline", "stdin", "readline", "split", "l", "a = map(int, stdin.read().split(), repeat(10, n))", "a", "map(int, stdin.read().split(), repeat(10, n))", "map", "int", "stdin.read().split()", "stdin.read().split", "stdin.read()", "stdin.read", "stdin", "read", "split", "repeat(10, n)", "repeat", "10", "n", "for i in xrange(n - 1):\n\tif a[i] + a[i+1] >= l:\n ans = range(1, i + 1) + range(n - 1, i + 1, -1) + [i + 1]\n stdout.write('Possible\\n')\n stdout.write('\\n'.join(map(str, ans)))\n stdout.write('\\n')\n return\n ", "i", "xrange(n - 1)", "xrange", "n - 1", "n", "1", "if a[i] + a[i+1] >= l:\n ans = range(1, i + 1) + range(n - 1, i + 1, -1) + [i + 1]\n stdout.write('Possible\\n')\n stdout.write('\\n'.join(map(str, ans)))\n stdout.write('\\n')\n return\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 = range(1, i + 1) + range(n - 1, i + 1, -1) + [i + 1]", "ans", "range(1, i + 1) + range(n - 1, i + 1, -1) + [i + 1]", "range(1, i + 1) + range(n - 1, i + 1, -1)", "range(1, i + 1)", "range", "1", "i + 1", "i", "1", "range(n - 1, i + 1, -1)", "range", "n - 1", "n", "1", "i + 1", "i", "1", "-1", "[i + 1]", "i + 1", "i", "1", "stdout.write('Possible\\n')", "stdout.write", "stdout", "write", "'Possible\\n'", "stdout.write('\\n'.join(map(str, ans)))", "stdout.write", "stdout", "write", "'\\n'.join(map(str, ans))", "'\\n'.join", "'\\n'", "join", "map(str, ans)", "map", "str", "ans", "stdout.write('\\n')", "stdout.write", "stdout", "write", "'\\n'", "return", "print", "main()", "main", "def main():\n n, l = map(int, stdin.readline().split())\n a = map(int, stdin.read().split(), repeat(10, n))\n for i in xrange(n - 1):\n\tif a[i] + a[i+1] >= l:\n ans = range(1, i + 1) + range(n - 1, i + 1, -1) + [i + 1]\n stdout.write('Possible\\n')\n stdout.write('\\n'.join(map(str, ans)))\n stdout.write('\\n')\n return\n print \"Impossible\"", "def main():\n n, l = map(int, stdin.readline().split())\n a = map(int, stdin.read().split(), repeat(10, n))\n for i in xrange(n - 1):\n\tif a[i] + a[i+1] >= l:\n ans = range(1, i + 1) + range(n - 1, i + 1, -1) + [i + 1]\n stdout.write('Possible\\n')\n stdout.write('\\n'.join(map(str, ans)))\n stdout.write('\\n')\n return\n print \"Impossible\"", "main" ]

[ 7, 15, 15, 15, 13, 15, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 0, 13, 4, 18, 13, 13, 4, 18, 13, 13, 2, 17, 17, 12, 13, 29, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 29, 13, 0, 13, 39, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 0, 13, 4, 13, 0, 13, 17, 0, 13, 39, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 17, 0, 13, 39, 2, 13, 17, 3, 4, 13, 13, 14, 2, 13, 17, 0, 13, 4, 13, 4, 13, 2, 18, 13, 17, 17, 13, 0, 13, 18, 4, 13, 4, 13, 17, 18, 13, 17, 39, 17, 28, 13, 18, 13, 39, 17, 4, 13, 13, 10, 12, 13, 10, 18, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 39, 13, 10, 12, 13, 10, 17, 13, 10, 4, 13, 10, 12, 13, 10, 39, 13 ]

[ [ 208, 17 ], [ 60, 59 ], [ 59, 68 ], [ 199, 72 ], [ 178, 77 ], [ 193, 84 ], [ 170, 86 ], [ 193, 87 ], [ 187, 89 ], [ 212, 91 ], [ 184, 93 ], [ 196, 96 ], [ 100, 99 ], [ 176, 103 ], [ 188, 109 ], [ 99, 110 ], [ 188, 112 ], [ 99, 114 ], [ 194, 116 ], [ 205, 118 ], [ 214, 121 ], [ 99, 124 ], [ 206, 129 ], [ 185, 129 ], [ 206, 132 ], [ 185, 132 ], [ 190, 135 ], [ 215, 142 ], [ 197, 142 ], [ 176, 145 ], [ 172, 147 ], [ 191, 155 ], [ 215, 155 ], [ 197, 155 ], [ 161, 160 ], [ 173, 162 ], [ 191, 162 ], [ 215, 162 ], [ 197, 162 ], [ 160, 167 ], [ 172, 173 ], [ 193, 176 ], [ 178, 179 ], [ 184, 185 ], [ 187, 188 ], [ 190, 191 ], [ 193, 194 ], [ 196, 197 ], [ 199, 200 ], [ 205, 206 ], [ 208, 209 ], [ 214, 215 ] ]

[ "from heapq import heappush, heappop\nfrom collections import deque,defaultdict,Counter\nimport itertools\nfrom itertools import permutations\nimport sys\nimport bisect\nimport string\nimport math\nimport time\nts=time.time()\nsys.setrecursionlimit(10**6)\ndef SI():\n return input().split()\ndef MI():\n return map(int,input().split())\ndef I():\n return int(input())\ndef LI():\n return [int(i) for i in input().split()]\nYN=['Yes','No']\nmo=10**9+7\n\nn,l=MI()\na=LI()\nans='Impossible'\nan=[]\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n ans='Possible'\n an+=[i+1]\n break\n\nprint(ans)\nif ans=='Possible':\n an+=list(range(an[0]+1,n))\n an+=list(range(1,an[0]))[::-1]\n for i in an[::-1]:\n print(i)", "from heapq import heappush, heappop", "from collections import deque,defaultdict,Counter", "import itertools", "itertools", "from itertools import permutations", "import sys", "sys", "import bisect", "bisect", "import string", "string", "import math", "math", "import time", "time", "ts=time.time()", "ts", "time.time()", "time.time", "time", "time", "sys.setrecursionlimit(10**6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**6", "10", "6", "def SI():\n return input().split()", "SI", "return input().split()", "input().split()", "().split", "()", "input", "split", "def MI():\n return map(int,input().split())", "MI", "return map(int,input().split())", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def I():\n return int(input())", "I", "return int(input())", "int(input())", "int", "input()", "input", "def LI():\n return [int(i) for i in input().split()]", "LI", "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", "return [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "YN=['Yes','No']", "YN", "['Yes','No']", "'Yes'", "'No'", "mo=10**9+7", "mo", "10**9+7", "10**9", "10", "9", "7", "n,l=MI()", "n", "MI()", "MI", "l", "a=LI()", "a", "LI()", "LI", "ans='Impossible'", "ans", "'Impossible'", "an=[]", "an", "[]", "for i in range(n-1):\n if a[i]+a[i+1]>=l:\n ans='Possible'\n an+=[i+1]\n break", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n ans='Possible'\n an+=[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'", "an+=[i+1]", "an", "[i+1]", "i+1", "i", "1", "break", "print(ans)", "print", "ans", "if ans=='Possible':\n an+=list(range(an[0]+1,n))\n an+=list(range(1,an[0]))[::-1]\n for i in an[::-1]:\n print(i)", "ans=='Possible'", "ans", "'Possible'", "an+=list(range(an[0]+1,n))", "an", "list(range(an[0]+1,n))", "list", "range(an[0]+1,n)", "range", "an[0]+1", "an[0]", "an", "0", "1", "n", "an+=list(range(1,an[0]))[::-1]", "an", "list(range(1,an[0]))[::-1]", "(range(1,an[0]))", "list", "range(1,an[0])", "range", "1", "an[0]", "an", "0", "::-1", "-1", "for i in an[::-1]:\n print(i)", "i", "an[::-1]", "an", "::-1", "-1", "print(i)", "print", "i", "def MI():\n return map(int,input().split())", "def MI():\n return map(int,input().split())", "MI", "an+=list(range(1,an[0]))[::-1]", "list(range(1,an[0]))[::-1]", "an", "n,l=MI()", "MI()", "n", "mo=10**9+7", "10**9+7", "mo", "def SI():\n return input().split()", "def SI():\n return input().split()", "SI", "ans='Impossible'", "'Impossible'", "ans", "a=LI()", "LI()", "a", "an+=list(range(an[0]+1,n))", "list(range(an[0]+1,n))", "an", "l=MI()", "MI()", "l", "an=[]", "[]", "an", "YN=['Yes','No']", "['Yes','No']", "YN", "def I():\n return int(input())", "def I():\n return int(input())", "I", "ans='Possible'", "'Possible'", "ans", "ts=time.time()", "time.time()", "ts", "def LI():\n return [int(i) for i in input().split()]", "def LI():\n return [int(i) for i in input().split()]", "LI", "an+=[i+1]", "[i+1]", "an" ]

[ 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, 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, 4, 13, 10, 17, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 87, 2 ], [ 87, 11 ], [ 96, 13 ], [ 90, 25 ], [ 29, 28 ], [ 88, 32 ], [ 97, 37 ], [ 28, 39 ], [ 97, 42 ], [ 28, 43 ], [ 85, 44 ], [ 93, 46 ], [ 28, 47 ], [ 94, 51 ], [ 91, 51 ], [ 61, 60 ], [ 94, 64 ], [ 91, 64 ], [ 60, 67 ], [ 70, 69 ], [ 88, 73 ], [ 94, 75 ], [ 91, 75 ], [ 69, 79 ], [ 94, 82 ], [ 91, 82 ], [ 87, 85 ], [ 87, 88 ], [ 90, 91 ], [ 28, 93 ], [ 93, 94 ], [ 96, 97 ] ]

[ "N, L = map(int, input().split())\nAs = list(map(int, input().split()))\n\ni = 0\n\nfor j in range(1,N):\n if As[j-1] + As[j] >= L:\n i = j\n break\n \nif i == 0:\n print('Impossible')\nelse:\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, 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", "i = 0", "i", "0", "for j in range(1,N):\n if As[j-1] + As[j] >= L:\n i = j\n break\n ", "j", "range(1,N)", "range", "1", "N", "if As[j-1] + As[j] >= L:\n i = j\n break\n ", "As[j-1] + As[j] >= L", "As[j-1] + As[j]", "As[j-1]", "As", "j-1", "j", "1", "As[j]", "As", "j", "L", "i = j", "i", "j", "break", "if i == 0:\n print('Impossible')\nelse:\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)", "i == 0", "i", "0", "print('Impossible')", "print", "'Impossible'", "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", "L = map(int, input().split())", "map(int, input().split())", "L", "N, L = map(int, input().split())", "map(int, input().split())", "N", "i = 0", "0", "i", "i = j", "j", "i", "As = list(map(int, input().split()))", "list(map(int, input().split()))", "As" ]

[ 7, 12, 13, 41, 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, 29, 2, 13, 17, 29, 17, 0, 13, 4, 13, 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, 12, 13, 10, 4, 13 ]

[ [ 6, 5 ], [ 6, 14 ], [ 17, 16 ], [ 29, 28 ], [ 5, 32 ], [ 16, 38 ], [ 28, 39 ], [ 16, 41 ], [ 28, 43 ], [ 14, 45 ], [ 28, 48 ], [ 92, 53 ], [ 90, 55 ], [ 63, 62 ], [ 93, 66 ], [ 62, 69 ], [ 72, 71 ], [ 93, 77 ], [ 71, 81 ], [ 93, 84 ], [ 92, 93 ] ]

[ "def solve():\n global N, L\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 return i+1\n return False\nans = solve()\nif ans:\n print('Possible')\n for i in range(1, ans):\n print(i)\n for i in range(N-1, ans, -1):\n print(i)\n print(ans)\nelse:\n print(\"Impossible\")", "def solve():\n global N, L\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 return i+1\n return False", "solve", "global N, L", "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 return i+1\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if a[i]+a[i+1]>=L:\n return i+1\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", "return i+1", "i+1", "i", "1", "return False", "False", "ans = solve()", "ans", "solve()", "solve", "if ans:\n print('Possible')\n for i in range(1, ans):\n print(i)\n for i in range(N-1, ans, -1):\n print(i)\n print(ans)\nelse:\n print(\"Impossible\")", "ans", "print('Possible')", "print", "'Possible'", "for i in range(1, ans):\n print(i)\n ", "i", "range(1, ans)", "range", "1", "ans", "print(i)", "print", "i", "for i in range(N-1, ans, -1):\n print(i)\n ", "i", "range(N-1, ans, -1)", "range", "N-1", "N", "1", "ans", "-1", "print(i)", "print", "i", "print(ans)", "print", "ans", "print(\"Impossible\")", "print", "\"Impossible\"", "def solve():\n global N, L\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 return i+1\n return False", "def solve():\n global N, L\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 return i+1\n return False", "solve", "ans = solve()", "solve()", "ans" ]

[ 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, 39, 13, 13, 4, 13, 4, 13, 13, 18, 13, 39, 17, 14, 40, 2, 13, 13, 13, 0, 13, 13, 3, 14, 2, 13, 17, 4, 13, 17, 4, 13, 4, 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, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 103, 2 ], [ 103, 11 ], [ 91, 13 ], [ 97, 25 ], [ 92, 36 ], [ 92, 38 ], [ 104, 46 ], [ 106, 48 ], [ 107, 53 ], [ 98, 53 ], [ 100, 64 ], [ 95, 79 ], [ 101, 86 ], [ 89, 88 ], [ 91, 92 ], [ 103, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ] ]

[ "N,L = map(int,input().split())\nA = list(map(int,input().split()))\n\nlast = -1\nfor i,(a,b) in enumerate(zip(A,A[1:])):\n if a+b >= L:\n last = i\n break\nif last < 0:\n print('Impossible')\n exit()\nprint('Possible')\n\nans = list(range(1,i+1)) + list(range(N-1,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", "last = -1", "last", "-1", "for i,(a,b) in enumerate(zip(A,A[1:])):\n if a+b >= L:\n last = i\n break", "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 last = i\n break", "a+b >= L", "a+b", "a", "b", "L", "last = i", "last", "i", "break", "if last < 0:\n print('Impossible')\n exit()", "last < 0", "last", "0", "print('Impossible')", "print", "'Impossible'", "exit()", "exit", "print('Possible')", "print", "'Possible'", "ans = list(range(1,i+1)) + list(range(N-1,i,-1))", "ans", "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(*ans, sep='\\n')", "print", "*ans", "ans", "sep='\\n'", "sep", "'\\n'", "A = list(map(int,input().split()))", "list(map(int,input().split()))", "A", "N,L = map(int,input().split())", "map(int,input().split())", "N", "last = -1", "-1", "last", "ans = list(range(1,i+1)) + list(range(N-1,i,-1))", "list(range(1,i+1)) + list(range(N-1,i,-1))", "ans", "L = map(int,input().split())", "map(int,input().split())", "L", "last = i", "i", "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, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 40, 13, 2, 18, 13, 13, 18, 13, 2, 13, 17, 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, 2, 13, 13, 17, 4, 13, 2, 2, 13, 17, 13, 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 ], [ 94, 32 ], [ 91, 36 ], [ 97, 39 ], [ 28, 40 ], [ 97, 42 ], [ 28, 44 ], [ 99, 47 ], [ 28, 48 ], [ 100, 52 ], [ 88, 52 ], [ 62, 61 ], [ 100, 64 ], [ 88, 64 ], [ 61, 68 ], [ 72, 71 ], [ 94, 76 ], [ 100, 77 ], [ 88, 77 ], [ 94, 83 ], [ 71, 85 ], [ 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\natom = -1\nfor i in range(n-1):\n if l <= a[i] + a[i+1]:\n atom = i\n break\n \nif atom < 0:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(atom):\n print(i+1)\n for i in range(n-atom-1):\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", "atom = -1", "atom", "-1", "for i in range(n-1):\n if l <= a[i] + a[i+1]:\n atom = i\n break\n ", "i", "range(n-1)", "range", "n-1", "n", "1", "if l <= a[i] + a[i+1]:\n atom = i\n break\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", "atom = i", "atom", "i", "break", "if atom < 0:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(atom):\n print(i+1)\n for i in range(n-atom-1):\n print(n-1-i)", "atom < 0", "atom", "0", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "for i in range(atom):\n print(i+1)\n ", "i", "range(atom)", "range", "atom", "print(i+1)", "print", "i+1", "i", "1", "for i in range(n-atom-1):\n print(n-1-i)", "i", "range(n-atom-1)", "range", "n-atom-1", "n-atom", "n", "atom", "1", "print(n-1-i)", "print", "n-1-i", "n-1", "n", "1", "i", "atom = -1", "-1", "atom", "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", "atom = i", "i", "atom" ]

[ 7, 15, 13, 0, 13, 18, 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, 3, 4, 13, 17, 4, 13, 17, 0, 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, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 99, 4 ], [ 16, 15 ], [ 100, 22 ], [ 16, 24 ], [ 27, 26 ], [ 100, 35 ], [ 39, 38 ], [ 15, 42 ], [ 26, 48 ], [ 38, 49 ], [ 26, 51 ], [ 38, 53 ], [ 24, 55 ], [ 65, 64 ], [ 71, 70 ], [ 64, 74 ], [ 70, 77 ], [ 80, 79 ], [ 15, 83 ], [ 64, 86 ], [ 79, 91 ], [ 103, 97 ], [ 99, 100 ] ]

[ "import sys\n#input = sys.stdin.readline\ninput = sys.stdin.buffer.readline\n\n# mod=10**9+7\n# rstrip().decode('utf-8')\n# map(int,input().split())\n#import numpy as np\n\n\ndef main():\n\tn,l=map(int,input().split())\n\ta=list(map(int,input().split()))\n\n\tfor i in range(n-1):\n\t\tif a[i]+a[i+1]>=l:\n\t\t\tbreak\n\telse:\n\t\tprint(\"Impossible\")\n\t\texit(0)\n\ti+=1\n\tprint(\"Possible\")\n\tfor j in range(1,i):\n\t\tprint(j)\n\n\tfor j in range(n-1,i-1,-1):\n\t\tprint(j)\n\n\n\n\nif __name__ == \"__main__\":\n\tmain()", "import sys", "sys", "input = sys.stdin.buffer.readline", "input", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "def main():\n\tn,l=map(int,input().split())\n\ta=list(map(int,input().split()))\n\n\tfor i in range(n-1):\n\t\tif a[i]+a[i+1]>=l:\n\t\t\tbreak\n\telse:\n\t\tprint(\"Impossible\")\n\t\texit(0)\n\ti+=1\n\tprint(\"Possible\")\n\tfor j in range(1,i):\n\t\tprint(j)\n\n\tfor j in range(n-1,i-1,-1):\n\t\tprint(j)", "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", "for i in range(n-1):\n\t\tif a[i]+a[i+1]>=l:\n\t\t\tbreak\n\telse:\n\t\tprint(\"Impossible\")\n\t\texit(0)\n\t", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n\t\t\tbreak\n\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", "break", "print(\"Impossible\")", "print", "\"Impossible\"", "exit(0)", "exit", "0", "i+=1", "i", "1", "print(\"Possible\")", "print", "\"Possible\"", "for j in range(1,i):\n\t\tprint(j)\n\n\t", "j", "range(1,i)", "range", "1", "i", "print(j)", "print", "j", "for j in range(n-1,i-1,-1):\n\t\tprint(j)", "j", "range(n-1,i-1,-1)", "range", "n-1", "n", "1", "i-1", "i", "1", "-1", "print(j)", "print", "j", "if __name__ == \"__main__\":\n\tmain()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "input = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "input", "def main():\n\tn,l=map(int,input().split())\n\ta=list(map(int,input().split()))\n\n\tfor i in range(n-1):\n\t\tif a[i]+a[i+1]>=l:\n\t\t\tbreak\n\telse:\n\t\tprint(\"Impossible\")\n\t\texit(0)\n\ti+=1\n\tprint(\"Possible\")\n\tfor j in range(1,i):\n\t\tprint(j)\n\n\tfor j in range(n-1,i-1,-1):\n\t\tprint(j)", "def main():\n\tn,l=map(int,input().split())\n\ta=list(map(int,input().split()))\n\n\tfor i in range(n-1):\n\t\tif a[i]+a[i+1]>=l:\n\t\t\tbreak\n\telse:\n\t\tprint(\"Impossible\")\n\t\texit(0)\n\ti+=1\n\tprint(\"Possible\")\n\tfor j in range(1,i):\n\t\tprint(j)\n\n\tfor j in range(n-1,i-1,-1):\n\t\tprint(j)", "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, 28, 13, 4, 13, 17, 13, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 17, 0, 13, 13, 14, 13, 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, 13, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 104, 2 ], [ 104, 11 ], [ 101, 13 ], [ 92, 25 ], [ 98, 28 ], [ 32, 31 ], [ 105, 35 ], [ 102, 40 ], [ 31, 41 ], [ 102, 43 ], [ 31, 45 ], [ 90, 47 ], [ 95, 49 ], [ 86, 52 ], [ 31, 53 ], [ 64, 63 ], [ 87, 67 ], [ 99, 67 ], [ 63, 70 ], [ 73, 72 ], [ 105, 76 ], [ 87, 79 ], [ 99, 79 ], [ 72, 84 ], [ 31, 86 ], [ 86, 87 ], [ 104, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ] ]

[ "N, L = map(int,input().split())\na = list(map(int,input().split()))\nt = True\nkey_number = -1\nfor i in range(1,N):\n if a[i] + a[i-1] >= L:\n t = False\n key_number = i\n\nif t:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for ans in range(1,key_number):\n print(ans)\n for ans in range(N-1,key_number-1,-1):\n print(ans)", "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", "t = True", "t", "True", "key_number = -1", "key_number", "-1", "for i in range(1,N):\n if a[i] + a[i-1] >= L:\n t = False\n key_number = i", "i", "range(1,N)", "range", "1", "N", "if a[i] + a[i-1] >= L:\n t = False\n key_number = 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", "t = False", "t", "False", "key_number = i", "key_number", "i", "if t:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for ans in range(1,key_number):\n print(ans)\n for ans in range(N-1,key_number-1,-1):\n print(ans)", "t", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for ans in range(1,key_number):\n print(ans)\n ", "ans", "range(1,key_number)", "range", "1", "key_number", "print(ans)", "print", "ans", "for ans in range(N-1,key_number-1,-1):\n print(ans)", "ans", "range(N-1,key_number-1,-1)", "range", "N-1", "N", "1", "key_number-1", "key_number", "1", "-1", "print(ans)", "print", "ans", "key_number = i", "i", "key_number", "L = map(int,input().split())", "map(int,input().split())", "L", "t = True", "True", "t", "t = False", "False", "t", "key_number = -1", "-1", "key_number", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "N, L = map(int,input().split())", "map(int,input().split())", "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, 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, 4, 13, 2, 13, 17, 13, 4, 13, 13, 4, 13, 13, 3, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 78, 2 ], [ 78, 11 ], [ 81, 13 ], [ 26, 25 ], [ 76, 29 ], [ 82, 34 ], [ 25, 36 ], [ 82, 39 ], [ 25, 40 ], [ 79, 41 ], [ 47, 46 ], [ 25, 50 ], [ 46, 53 ], [ 56, 55 ], [ 25, 61 ], [ 76, 63 ], [ 55, 66 ], [ 25, 69 ], [ 78, 76 ], [ 78, 79 ], [ 81, 82 ] ]

[ "N, L = map(int, input().split())\nAs = list(map(int, input().split()))\n\nfor iKnot in range(1, N):\n if As[iKnot - 1] + As[iKnot] >= L:\n print('Possible')\n for i in range(1, iKnot):\n print(i)\n for i in reversed(range(iKnot + 1, N)):\n print(i)\n print(iKnot)\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", "As = list(map(int, input().split()))", "As", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for iKnot in range(1, N):\n if As[iKnot - 1] + As[iKnot] >= L:\n print('Possible')\n for i in range(1, iKnot):\n print(i)\n for i in reversed(range(iKnot + 1, N)):\n print(i)\n print(iKnot)\n break\nelse:\n print('Impossible')", "iKnot", "range(1, N)", "range", "1", "N", "if As[iKnot - 1] + As[iKnot] >= L:\n print('Possible')\n for i in range(1, iKnot):\n print(i)\n for i in reversed(range(iKnot + 1, N)):\n print(i)\n print(iKnot)\n break", "As[iKnot - 1] + As[iKnot] >= L", "As[iKnot - 1] + As[iKnot]", "As[iKnot - 1]", "As", "iKnot - 1", "iKnot", "1", "As[iKnot]", "As", "iKnot", "L", "print('Possible')", "print", "'Possible'", "for i in range(1, iKnot):\n print(i)\n ", "i", "range(1, iKnot)", "range", "1", "iKnot", "print(i)", "print", "i", "for i in reversed(range(iKnot + 1, N)):\n print(i)\n ", "i", "reversed(range(iKnot + 1, N))", "reversed", "range(iKnot + 1, N)", "range", "iKnot + 1", "iKnot", "1", "N", "print(i)", "print", "i", "print(iKnot)", "print", "iKnot", "break", "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", "As = list(map(int, input().split()))", "list(map(int, input().split()))", "As" ]

[ 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, 2, 13, 17, 3, 14, 2, 13, 17, 4, 13, 17, 4, 13, 17, 28, 13, 4, 13, 17, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 17, 4, 13, 13, 4, 13, 2, 13, 17, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 104, 2 ], [ 104, 11 ], [ 95, 13 ], [ 98, 25 ], [ 29, 28 ], [ 102, 32 ], [ 96, 37 ], [ 28, 39 ], [ 96, 42 ], [ 28, 43 ], [ 105, 44 ], [ 92, 46 ], [ 28, 48 ], [ 93, 53 ], [ 99, 53 ], [ 63, 62 ], [ 93, 66 ], [ 99, 66 ], [ 62, 70 ], [ 74, 73 ], [ 102, 77 ], [ 93, 80 ], [ 99, 80 ], [ 73, 85 ], [ 93, 89 ], [ 99, 89 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 104, 102 ], [ 104, 105 ] ]

[ "N,L = map(int, input().split())\nA=list(map(int, input().split()))\nchoose = -1\nfor i in range(1, N):\n if A[i - 1] + A[i] >= L:\n choose = i - 1\n break\nif choose == -1:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(0, choose):\n print(i + 1)\n for i in range(N - 1, choose + 1, -1):\n print(i)\n print(choose + 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", "choose = -1", "choose", "-1", "for i in range(1, N):\n if A[i - 1] + A[i] >= L:\n choose = i - 1\n break", "i", "range(1, N)", "range", "1", "N", "if A[i - 1] + A[i] >= L:\n choose = 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", "choose = i - 1", "choose", "i - 1", "i", "1", "break", "if choose == -1:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(0, choose):\n print(i + 1)\n for i in range(N - 1, choose + 1, -1):\n print(i)\n print(choose + 1)", "choose == -1", "choose", "-1", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "for i in range(0, choose):\n print(i + 1)\n ", "i", "range(0, choose)", "range", "0", "choose", "print(i + 1)", "print", "i + 1", "i", "1", "for i in range(N - 1, choose + 1, -1):\n print(i)\n ", "i", "range(N - 1, choose + 1, -1)", "range", "N - 1", "N", "1", "choose + 1", "choose", "1", "-1", "print(i)", "print", "i", "print(choose + 1)", "print", "choose + 1", "choose", "1", "choose = i - 1", "i - 1", "choose", "A=list(map(int, input().split()))", "list(map(int, input().split()))", "A", "choose = -1", "-1", "choose", "N,L = map(int, input().split())", "map(int, input().split())", "N", "L = map(int, input().split())", "map(int, input().split())", "L" ]

[ 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, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 31, 13, 41, 28, 13, 13, 4, 13, 13, 18, 13, 39, 17, 4, 2, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 4, 13, 13, 0, 13, 4, 18, 13, 13, 13, 14, 2, 13, 13, 4, 13, 17, 4, 13, 0, 13, 18, 4, 13, 4, 18, 13, 13, 4, 13, 13, 17, 17, 4, 13, 2, 13, 17, 13, 39, 17, 4, 13, 17, 4, 13, 4, 18, 17, 13, 4, 13, 13, 13, 10, 18, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 18, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 123, 4 ], [ 141, 13 ], [ 138, 22 ], [ 144, 33 ], [ 124, 40 ], [ 144, 42 ], [ 144, 43 ], [ 126, 61 ], [ 147, 67 ], [ 127, 70 ], [ 132, 72 ], [ 127, 75 ], [ 148, 77 ], [ 148, 80 ], [ 145, 81 ], [ 135, 88 ], [ 133, 98 ], [ 133, 104 ], [ 130, 106 ], [ 136, 121 ], [ 123, 124 ], [ 126, 127 ], [ 144, 130 ], [ 132, 133 ], [ 135, 136 ], [ 138, 139 ], [ 141, 142 ], [ 144, 145 ], [ 147, 148 ] ]

[ "import sys\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\n\nimport itertools\n\n# 和がL以上の2つをつなぐ\n# 和がL以上のものが1つ作れたら、その周辺だけ処理していけばよい\n\nN,L,*A = map(int,read().split())\n\nS = [0] + [x+y for x,y in zip(A,A[1:])]\nM = max(S)\ni = S.index(M)\n\nif M < L:\n print('Impossible')\n exit()\n\nanswer = list(itertools.chain(range(i,0,-1),range(i+1,N)))[::-1]\nprint('Possible')\nprint('\\n'.join(map(str,answer)))", "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", "import itertools", "itertools", "N,L,*A = map(int,read().split())", "N", "map(int,read().split())", "map", "int", "read().split()", "().split", "()", "read", "split", "L", "*A", "A", "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", "S = [0] + [x+y for x,y in zip(A,A[1:])]", "S", "[0] + [x+y for x,y in zip(A,A[1:])]", "[0]", "0", "[x+y for x,y in zip(A,A[1:])]", "M = max(S)", "M", "max(S)", "max", "S", "i = S.index(M)", "i", "S.index(M)", "S.index", "S", "index", "M", "if M < L:\n print('Impossible')\n exit()", "M < L", "M", "L", "print('Impossible')", "print", "'Impossible'", "exit()", "exit", "answer = list(itertools.chain(range(i,0,-1),range(i+1,N)))[::-1]", "answer", "list(itertools.chain(range(i,0,-1),range(i+1,N)))[::-1]", "(itertools.chain(range(i,0,-1),range(i+1,N)))", "list", "itertools.chain(range(i,0,-1),range(i+1,N))", "itertools.chain", "itertools", "chain", "range(i,0,-1)", "range", "i", "0", "-1", "range(i+1,N)", "range", "i+1", "i", "1", "N", "::-1", "-1", "print('Possible')", "print", "'Possible'", "print('\\n'.join(map(str,answer)))", "print", "'\\n'.join(map(str,answer))", "'\\n'.join", "'\\n'", "join", "map(str,answer)", "map", "str", "answer", "read = sys.stdin.buffer.read", "sys.stdin.buffer.read", "read", "S = [0] + [x+y for x,y in zip(A,A[1:])]", "[0] + [x+y for x,y in zip(A,A[1:])]", "S", "N,L,*A = map(int,read().split())", "map(int,read().split())", "N", "i = S.index(M)", "S.index(M)", "i", "answer = list(itertools.chain(range(i,0,-1),range(i+1,N)))[::-1]", "list(itertools.chain(range(i,0,-1),range(i+1,N)))[::-1]", "answer", "readlines = sys.stdin.buffer.readlines", "sys.stdin.buffer.readlines", "readlines", "readline = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "readline", "L,*A = map(int,read().split())", "map(int,read().split())", "L", "M = max(S)", "max(S)", "M" ]

[ 7, 0, 13, 12, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 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, 13, 3, 14, 13, 4, 13, 17, 0, 13, 4, 13, 4, 13, 13, 0, 13, 18, 13, 39, 17, 13, 0, 13, 18, 13, 39, 17, 13, 17, 0, 13, 39, 13, 4, 13, 31, 13, 0, 13, 17, 4, 13, 17, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 18, 13, 10, 12, 13, 10, 13, 13, 10, 4, 13, 10, 39, 13, 10, 18, 13 ]

[ [ 111, 2 ], [ 117, 15 ], [ 112, 17 ], [ 117, 18 ], [ 99, 20 ], [ 112, 22 ], [ 93, 24 ], [ 28, 27 ], [ 118, 31 ], [ 100, 36 ], [ 27, 38 ], [ 100, 41 ], [ 27, 42 ], [ 103, 43 ], [ 105, 45 ], [ 114, 48 ], [ 27, 49 ], [ 96, 57 ], [ 118, 62 ], [ 108, 64 ], [ 97, 66 ], [ 123, 71 ], [ 97, 73 ], [ 120, 79 ], [ 121, 85 ], [ 124, 85 ], [ 109, 85 ], [ 88, 87 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 117, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 27, 114 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ] ]

[ "ai = lambda: list(map(int, input().split()))\n\nn,l = ai()\na = ai()\n\nf = 0\nfor i in range(1,n):\n if a[i-1]+a[i] >= l:\n f = 1\n key = i\n break\nif f:\n print('Possible')\n b = list(range(n))\n c = b[1:key]\n c += b[-1:key:-1]\n c += [key]\n print(*c, sep='\\n')\nelse:\n print('Impossible')", "ai = lambda: list(map(int, input().split()))", "ai", "lambda: list(map(int, input().split()))", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "n,l = ai()", "n", "ai()", "ai", "l", "a = ai()", "a", "ai()", "ai", "f = 0", "f", "0", "for i in range(1,n):\n if a[i-1]+a[i] >= l:\n f = 1\n key = i\n break", "i", "range(1,n)", "range", "1", "n", "if a[i-1]+a[i] >= l:\n f = 1\n key = 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", "f = 1", "f", "1", "key = i", "key", "i", "break", "if f:\n print('Possible')\n b = list(range(n))\n c = b[1:key]\n c += b[-1:key:-1]\n c += [key]\n print(*c, sep='\\n')\nelse:\n print('Impossible')", "f", "print('Possible')", "print", "'Possible'", "b = list(range(n))", "b", "list(range(n))", "list", "range(n)", "range", "n", "c = b[1:key]", "c", "b[1:key]", "b", "1:key", "1", "key", "c += b[-1:key:-1]", "c", "b[-1:key:-1]", "b", "-1:key:-1", "-1", "key", "-1", "c += [key]", "c", "[key]", "key", "print(*c, sep='\\n')", "print", "*c", "c", "sep='\\n'", "sep", "'\\n'", "print('Impossible')", "print", "'Impossible'", "f = 0", "0", "f", "b = list(range(n))", "list(range(n))", "b", "a = ai()", "ai()", "a", "l = ai()", "ai()", "l", "f = 1", "1", "f", "c = b[1:key]", "b[1:key]", "c", "ai = lambda: list(map(int, input().split()))", "lambda: list(map(int, input().split()))", "ai", "key = i", "i", "key", "n,l = ai()", "ai()", "n", "c += [key]", "[key]", "c", "c += b[-1:key:-1]", "b[-1:key:-1]", "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, 0, 13, 17, 0, 13, 17, 28, 13, 13, 4, 13, 4, 13, 18, 13, 39, 17, 18, 13, 39, 17, 14, 2, 13, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 17, 2, 13, 17, 4, 4, 13, 13, 4, 13, 8, 40, 13, 13, 2, 17, 4, 18, 17, 13, 2, 13, 13, 17, 10, 17, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 101, 2 ], [ 101, 11 ], [ 92, 13 ], [ 107, 25 ], [ 107, 28 ], [ 93, 38 ], [ 93, 42 ], [ 108, 47 ], [ 105, 47 ], [ 104, 52 ], [ 95, 57 ], [ 62, 61 ], [ 96, 66 ], [ 90, 66 ], [ 61, 71 ], [ 105, 76 ], [ 108, 76 ], [ 102, 77 ], [ 107, 90 ], [ 92, 93 ], [ 95, 96 ], [ 101, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ] ]

[ "N, L = map(int, input().split())\na = list(map(int, input().split()))\nmax_value = max_value_index = 0\nfor index, i in enumerate(zip(a[:-1], a[1:])):\n if max_value < sum(i):\n max_value = sum(i)\n max_value_index = index\n\nprint(\"Possible\\n\" + \"\\n\".join([str(i) for i in range(1, max_value_index + 1)] + [str(i) for i in range(N - 1, max_value_index, -1)]) if max_value >= L else \"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", "max_value = max_value_index = 0", "max_value", "0", "= max_value_index = 0", "max_value_index", "0", "for index, i in enumerate(zip(a[:-1], a[1:])):\n if max_value < sum(i):\n max_value = sum(i)\n max_value_index = index", "index", "i", "enumerate(zip(a[:-1], a[1:]))", "enumerate", "zip(a[:-1], a[1:])", "zip", "a[:-1]", "a", ":-1", "-1", "a[1:]", "a", "1:", "1", "if max_value < sum(i):\n max_value = sum(i)\n max_value_index = index", "max_value < sum(i)", "max_value", "sum(i)", "sum", "i", "max_value = sum(i)", "max_value", "sum(i)", "sum", "i", "max_value_index = index", "max_value_index", "index", "str(i) for i in range(1, max_value_index + 1)", "for i in range(1, max_value_index + 1)", "i", "range(1, max_value_index + 1)", "range", "1", "max_value_index + 1", "max_value_index", "1", "for i in range(1, max_value_index + 1)", "str(i)", "str", "i", "print(\"Possible\\n\" + \"\\n\".join([str(i) for i in range(1, max_value_index + 1)] + [str(i) for i in range(N - 1, max_value_index, -1)]) if max_value >= L else \"Impossible\")", "print", "\"Possible\\n\" + \"\\n\".join([str(i) for i in range(1, max_value_index + 1)] + [str(i) for i in range(N - 1, max_value_index, -1)]) if max_value >= L else \"Impossible\"", "max_value >= L", "max_value", "L", "\"Possible\\n\" + \"\\n\".join([str(i) for i in range(1, max_value_index + 1)] + [str(i) for i in range(N - 1, max_value_index, -1)])", "\"Possible\\n\"", "\"\\n\".join([str(i) for i in range(1, max_value_index + 1)] + [str(i) for i in range(N - 1, max_value_index, -1)])", "\"\\n\".join", "\"\\n\"", "join", "[str(i) for i in range(1, max_value_index + 1)] + [str(i) for i in range(N - 1, max_value_index, -1)]", "[str(i) for i in range(1, max_value_index + 1)]", "[str(i) for i in range(N - 1, max_value_index, -1)]", "\"Impossible\"", "max_value_index = 0", "0", "max_value_index", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "max_value_index = index", "index", "max_value_index", "N, L = map(int, input().split())", "map(int, input().split())", "N", "L = map(int, input().split())", "map(int, input().split())", "L", "max_value = sum(i)", "sum(i)", "max_value", "max_value = max_value_index = 0", "0", "max_value" ]

[ 7, 15, 13, 0, 13, 39, 17, 17, 17, 0, 13, 17, 0, 13, 18, 13, 13, 0, 13, 12, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 12, 4, 13, 4, 13, 0, 13, 17, 12, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 28, 13, 4, 13, 2, 4, 13, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 3, 4, 13, 17, 29, 4, 13, 17, 0, 13, 2, 13, 17, 4, 13, 39, 17, 13, 28, 13, 4, 13, 17, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 13, 17, 4, 13, 13, 4, 13, 13, 0, 13, 17, 12, 13, 14, 13, 4, 13, 13, 23, 13, 12, 13, 15, 13, 0, 13, 4, 18, 13, 13, 0, 13, 4, 18, 13, 13, 28, 13, 13, 27, 13, 14, 2, 13, 17, 14, 2, 18, 13, 13, 17, 14, 2, 13, 18, 13, 17, 0, 13, 4, 13, 0, 13, 12, 4, 18, 13, 13, 14, 2, 13, 18, 13, 17, 0, 18, 13, 13, 4, 13, 17, 0, 13, 17, 0, 13, 4, 13, 14, 40, 13, 17, 4, 13, 13, 10, 39, 13, 10, 12, 13, 10, 17, 13, 10, 18, 13, 10, 12, 13, 10, 17, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 17, 13, 10, 12, 13, 10, 12, 13, 10, 17, 13 ]

[ [ 200, 4 ], [ 215, 10 ], [ 209, 13 ], [ 201, 15 ], [ 216, 16 ], [ 203, 18 ], [ 233, 29 ], [ 204, 34 ], [ 206, 36 ], [ 42, 41 ], [ 204, 43 ], [ 42, 44 ], [ 47, 46 ], [ 234, 48 ], [ 51, 50 ], [ 46, 56 ], [ 46, 62 ], [ 50, 63 ], [ 46, 65 ], [ 50, 67 ], [ 44, 69 ], [ 80, 79 ], [ 90, 89 ], [ 79, 93 ], [ 89, 96 ], [ 99, 98 ], [ 41, 102 ], [ 79, 104 ], [ 98, 108 ], [ 79, 111 ], [ 239, 113 ], [ 123, 121 ], [ 123, 123 ], [ 130, 129 ], [ 136, 135 ], [ 129, 138 ], [ 142, 141 ], [ 135, 141 ], [ 141, 144 ], [ 210, 157 ], [ 201, 159 ], [ 221, 162 ], [ 225, 164 ], [ 236, 166 ], [ 222, 170 ], [ 210, 174 ], [ 201, 176 ], [ 182, 179 ], [ 230, 186 ], [ 227, 189 ], [ 213, 191 ], [ 228, 194 ], [ 228, 198 ], [ 200, 201 ], [ 203, 204 ], [ 206, 207 ], [ 209, 210 ], [ 215, 216 ], [ 221, 222 ], [ 227, 228 ], [ 230, 231 ], [ 233, 234 ], [ 236, 237 ], [ 239, 240 ] ]

[ "import sys\n\ninput_methods=['clipboard','file','key']\nusing_method=0\ninput_method=input_methods[using_method]\n\nIN=lambda : map(int, input().split())\nLIN=lambda : list(IN())\nmod=1000000007\n\n#+++++\n\ndef main():\n\t#a = int(input())\n\tn , l = IN()\n\t#s = input()\n\tal = LIN()\n\tfor i in range(len(al)-1):\n\t\tif al[i]+al[i+1] >= l:\n\t\t\tbreak\n\telse:\n\t\tprint('Impossible')\n\t\treturn \n\tprint('Possible')\n\tlast_tie = i + 1\n\tpa(('lt',last_tie))\n\tfor i in range(1, last_tie):\n\t\tprint(i)\n\tfor i in range(n-1, last_tie, -1):\n\t\tprint(i)\n\tprint(last_tie)\n\t\n\t\n\t\n#+++++\nisTest=False\n\ndef pa(v):\n\tif isTest:\n\t\tprint(v)\n\t\t\ndef input_clipboard():\n\timport clipboard\n\tinput_text=clipboard.get()\n\tinput_l=input_text.splitlines()\n\tfor l in input_l:\n\t\tyield l\n\nif __name__ == \"__main__\":\n\tif sys.platform =='ios':\n\t\tif input_method==input_methods[0]:\n\t\t\tic=input_clipboard()\n\t\t\tinput = lambda : ic.__next__()\n\t\telif input_method==input_methods[1]:\n\t\t\tsys.stdin=open('inputFile.txt')\n\t\telse:\n\t\t\tpass\n\t\tisTest=True\n\telse:\n\t\tpass\n\t\t#input = sys.stdin.readline\n\t\t\t\n\tret = main()\n\tif ret is not None:\n\t\tprint(ret)", "import sys", "sys", "input_methods=['clipboard','file','key']", "input_methods", "['clipboard','file','key']", "'clipboard'", "'file'", "'key'", "using_method=0", "using_method", "0", "input_method=input_methods[using_method]", "input_method", "input_methods[using_method]", "input_methods", "using_method", "IN=lambda : map(int, input().split())", "IN", "lambda : map(int, input().split())", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "LIN=lambda : list(IN())", "LIN", "lambda : list(IN())", "list(IN())", "list", "IN()", "IN", "mod=1000000007", "mod", "1000000007", "def main():\n\t#a = int(input())\n\tn , l = IN()\n\t#s = input()\n\tal = LIN()\n\tfor i in range(len(al)-1):\n\t\tif al[i]+al[i+1] >= l:\n\t\t\tbreak\n\telse:\n\t\tprint('Impossible')\n\t\treturn \n\tprint('Possible')\n\tlast_tie = i + 1\n\tpa(('lt',last_tie))\n\tfor i in range(1, last_tie):\n\t\tprint(i)\n\tfor i in range(n-1, last_tie, -1):\n\t\tprint(i)\n\tprint(last_tie)\n\t\n\t\n\t\n#+++++", "main", "n , l = IN()", "n", "IN()", "IN", "l", "al = LIN()", "al", "LIN()", "LIN", "for i in range(len(al)-1):\n\t\tif al[i]+al[i+1] >= l:\n\t\t\tbreak\n\telse:\n\t\tprint('Impossible')\n\t\treturn \n\t", "i", "range(len(al)-1)", "range", "len(al)-1", "len(al)", "len", "al", "1", "if al[i]+al[i+1] >= l:\n\t\t\tbreak\n\t", "al[i]+al[i+1] >= l", "al[i]+al[i+1]", "al[i]", "al", "i", "al[i+1]", "al", "i+1", "i", "1", "l", "break", "print('Impossible')", "print", "'Impossible'", "return", "print('Possible')", "print", "'Possible'", "last_tie = i + 1", "last_tie", "i + 1", "i", "1", "pa(('lt',last_tie))", "pa", "('lt',last_tie)", "'lt'", "last_tie", "for i in range(1, last_tie):\n\t\tprint(i)\n\t", "i", "range(1, last_tie)", "range", "1", "last_tie", "print(i)", "print", "i", "for i in range(n-1, last_tie, -1):\n\t\tprint(i)\n\t", "i", "range(n-1, last_tie, -1)", "range", "n-1", "n", "1", "last_tie", "-1", "print(i)", "print", "i", "print(last_tie)", "print", "last_tie", "isTest=False", "isTest", "False", "def pa(v):\n\tif isTest:\n\t\tprint(v)\n\t\t", "pa", "if isTest:\n\t\tprint(v)\n\t\t", "isTest", "print(v)", "print", "v", "v", "v", "def input_clipboard():\n\timport clipboard\n\tinput_text=clipboard.get()\n\tinput_l=input_text.splitlines()\n\tfor l in input_l:\n\t\tyield l", "input_clipboard", "import clipboard", "clipboard", "input_text=clipboard.get()", "input_text", "clipboard.get()", "clipboard.get", "clipboard", "get", "input_l=input_text.splitlines()", "input_l", "input_text.splitlines()", "input_text.splitlines", "input_text", "splitlines", "for l in input_l:\n\t\tyield l", "l", "input_l", "yield l", "l", "if __name__ == \"__main__\":\n\tif sys.platform =='ios':\n\t\tif input_method==input_methods[0]:\n\t\t\tic=input_clipboard()\n\t\t\tinput = lambda : ic.__next__()\n\t\telif input_method==input_methods[1]:\n\t\t\tsys.stdin=open('inputFile.txt')\n\t\telse:\n\t\t\tpass\n\t\tisTest=True\n\telse:\n\t\tpass\n\t\t#input = sys.stdin.readline\n\t\t\t\n\tret = main()\n\tif ret is not None:\n\t\tprint(ret)", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "if sys.platform =='ios':\n\t\tif input_method==input_methods[0]:\n\t\t\tic=input_clipboard()\n\t\t\tinput = lambda : ic.__next__()\n\t\telif input_method==input_methods[1]:\n\t\t\tsys.stdin=open('inputFile.txt')\n\t\telse:\n\t\t\tpass\n\t\tisTest=True\n\telse:\n\t\tpass\n\t\t#input = sys.stdin.readline\n\t\t\t\n\t", "sys.platform =='ios'", "sys.platform", "sys", "platform", "'ios'", "if input_method==input_methods[0]:\n\t\t\tic=input_clipboard()\n\t\t\tinput = lambda : ic.__next__()\n\t\telif input_method==input_methods[1]:\n\t\t\tsys.stdin=open('inputFile.txt')\n\t\telse:\n\t\t\tpass\n\t\t", "input_method==input_methods[0]", "input_method", "input_methods[0]", "input_methods", "0", "ic=input_clipboard()", "ic", "input_clipboard()", "input_clipboard", "input = lambda : ic.__next__()", "input", "lambda : ic.__next__()", "ic.__next__()", "ic.__next__", "ic", "__next__", "elif input_method==input_methods[1]:\n\t\t\tsys.stdin=open('inputFile.txt')\n\t\t", "input_method==input_methods[1]", "input_method", "input_methods[1]", "input_methods", "1", "sys.stdin=open('inputFile.txt')", "sys.stdin", "sys", "stdin", "open('inputFile.txt')", "open", "'inputFile.txt'", "isTest=True", "isTest", "True", "ret = main()", "ret", "main()", "main", "if ret is not None:\n\t\tprint(ret)", "ret is not None", "ret", "None", "print(ret)", "print", "ret", "input_methods=['clipboard','file','key']", "['clipboard','file','key']", "input_methods", "IN=lambda : map(int, input().split())", "lambda : map(int, input().split())", "IN", "mod=1000000007", "1000000007", "mod", "input_method=input_methods[using_method]", "input_methods[using_method]", "input_method", "def main():\n\t#a = int(input())\n\tn , l = IN()\n\t#s = input()\n\tal = LIN()\n\tfor i in range(len(al)-1):\n\t\tif al[i]+al[i+1] >= l:\n\t\t\tbreak\n\telse:\n\t\tprint('Impossible')\n\t\treturn \n\tprint('Possible')\n\tlast_tie = i + 1\n\tpa(('lt',last_tie))\n\tfor i in range(1, last_tie):\n\t\tprint(i)\n\tfor i in range(n-1, last_tie, -1):\n\t\tprint(i)\n\tprint(last_tie)\n\t\n\t\n\t\n#+++++", "def main():\n\t#a = int(input())\n\tn , l = IN()\n\t#s = input()\n\tal = LIN()\n\tfor i in range(len(al)-1):\n\t\tif al[i]+al[i+1] >= l:\n\t\t\tbreak\n\telse:\n\t\tprint('Impossible')\n\t\treturn \n\tprint('Possible')\n\tlast_tie = i + 1\n\tpa(('lt',last_tie))\n\tfor i in range(1, last_tie):\n\t\tprint(i)\n\tfor i in range(n-1, last_tie, -1):\n\t\tprint(i)\n\tprint(last_tie)\n\t\n\t\n\t\n#+++++", "main", "using_method=0", "0", "using_method", "def pa(v):\n\tif isTest:\n\t\tprint(v)\n\t\t", "def pa(v):\n\tif isTest:\n\t\tprint(v)\n\t\t", "pa", "ic=input_clipboard()", "input_clipboard()", "ic", "def input_clipboard():\n\timport clipboard\n\tinput_text=clipboard.get()\n\tinput_l=input_text.splitlines()\n\tfor l in input_l:\n\t\tyield l", "def input_clipboard():\n\timport clipboard\n\tinput_text=clipboard.get()\n\tinput_l=input_text.splitlines()\n\tfor l in input_l:\n\t\tyield l", "input_clipboard", "ret = main()", "main()", "ret", "isTest=True", "True", "isTest", "LIN=lambda : list(IN())", "lambda : list(IN())", "LIN", "input = lambda : ic.__next__()", "lambda : ic.__next__()", "input", "isTest=False", "False", "isTest" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 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, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 13, 28, 13, 4, 13, 2, 13, 17, 13, 17, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 77, 2 ], [ 77, 11 ], [ 83, 13 ], [ 86, 23 ], [ 27, 26 ], [ 78, 30 ], [ 84, 36 ], [ 26, 37 ], [ 84, 39 ], [ 26, 41 ], [ 75, 43 ], [ 80, 45 ], [ 26, 46 ], [ 81, 50 ], [ 87, 50 ], [ 56, 55 ], [ 81, 60 ], [ 87, 60 ], [ 65, 64 ], [ 78, 68 ], [ 81, 70 ], [ 87, 70 ], [ 77, 75 ], [ 77, 78 ], [ 26, 80 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ] ]

[ "n, k = map(int, raw_input().split())\nl = map(int, raw_input().split())\nind = -1\nfor i in range(n - 1):\n\tif l[i] + l[i + 1] >= k:\n\t\tind = i\n\t\tbreak\nif ind == -1:\n\tprint \"Impossible\"\nelse:\n\tprint \"Possible\"\n\tfor i in range(1, ind + 1):\n\t\tprint i \n\tfor i in range(n - 1, ind, -1):\n\t\tprint i ", "n, k = map(int, raw_input().split())", "n", "map(int, raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "k", "l = map(int, raw_input().split())", "l", "map(int, raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "ind = -1", "ind", "-1", "for i in range(n - 1):\n\tif l[i] + l[i + 1] >= k:\n\t\tind = i\n\t\tbreak", "i", "range(n - 1)", "range", "n - 1", "n", "1", "if l[i] + l[i + 1] >= k:\n\t\tind = i\n\t\tbreak", "l[i] + l[i + 1] >= k", "l[i] + l[i + 1]", "l[i]", "l", "i", "l[i + 1]", "l", "i + 1", "i", "1", "k", "ind = i", "ind", "i", "break", "if ind == -1:\n\tprint \"Impossible\"\nelse:\n\tprint \"Possible\"\n\tfor i in range(1, ind + 1):\n\t\tprint i \n\tfor i in range(n - 1, ind, -1):\n\t\tprint i ", "ind == -1", "ind", "-1", "print", "print", "for i in range(1, ind + 1):\n\t\tprint i \n\t", "i", "range(1, ind + 1)", "range", "1", "ind + 1", "ind", "1", "print", "for i in range(n - 1, ind, -1):\n\t\tprint i ", "i", "range(n - 1, ind, -1)", "range", "n - 1", "n", "1", "ind", "-1", "print", "k = map(int, raw_input().split())", "map(int, raw_input().split())", "k", "n, k = map(int, raw_input().split())", "map(int, raw_input().split())", "n", "ind = i", "i", "ind", "l = map(int, raw_input().split())", "map(int, raw_input().split())", "l", "ind = -1", "-1", "ind" ]

[ 7, 12, 13, 0, 13, 4, 13, 13, 14, 2, 13, 13, 0, 13, 13, 13, 13, 14, 2, 40, 13, 17, 40, 17, 13, 4, 13, 17, 14, 2, 17, 13, 4, 13, 17, 0, 13, 2, 2, 13, 13, 17, 14, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 17, 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, 4, 13, 13, 4, 13, 13, 29, 12, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 0, 13, 4, 13, 14, 2, 13, 17, 14, 2, 4, 13, 13, 13, 4, 13, 17, 29, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 18, 13, 13, 18, 13, 2, 13, 17, 14, 40, 13, 13, 0, 13, 4, 13, 13, 13, 4, 18, 13, 13, 13, 14, 40, 13, 4, 13, 17, 29, 4, 13, 17, 0, 13, 39, 28, 13, 4, 13, 13, 4, 18, 13, 13, 2, 13, 17, 28, 13, 18, 4, 13, 13, 2, 13, 17, 39, 17, 14, 2, 13, 13, 9, 4, 18, 13, 13, 2, 13, 17, 28, 13, 13, 4, 18, 13, 13, 2, 13, 17, 28, 13, 13, 4, 13, 13, 29, 12, 13, 0, 13, 17, 4, 13, 13, 29, 12, 13, 0, 13, 17, 4, 13, 13, 29, 12, 13, 0, 13, 17, 4, 13, 13, 29, 15, 13, 13, 13, 13, 13, 13, 15, 15, 15, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 41, 0, 13, 2, 2, 17, 17, 17, 0, 13, 17, 0, 13, 2, 17, 17, 0, 13, 2, 17, 17, 41, 28, 13, 4, 13, 17, 4, 4, 13, 2, 4, 13, 17, 13, 0, 13, 13, 4, 18, 13, 13, 2, 17, 17, 14, 2, 13, 17, 4, 13, 17, 10, 12, 13, 10, 12, 13, 10, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 7 ], [ 7, 10 ], [ 4, 11 ], [ 14, 13 ], [ 7, 14 ], [ 16, 15 ], [ 13, 16 ], [ 4, 16 ], [ 13, 20 ], [ 4, 20 ], [ 15, 24 ], [ 7, 24 ], [ 13, 31 ], [ 4, 31 ], [ 37, 36 ], [ 15, 39 ], [ 7, 39 ], [ 13, 40 ], [ 4, 40 ], [ 36, 45 ], [ 59, 58 ], [ 59, 61 ], [ 64, 63 ], [ 58, 67 ], [ 70, 69 ], [ 58, 73 ], [ 78, 75 ], [ 63, 76 ], [ 81, 80 ], [ 61, 83 ], [ 86, 85 ], [ 86, 88 ], [ 91, 90 ], [ 94, 93 ], [ 63, 97 ], [ 90, 98 ], [ 85, 98 ], [ 103, 100 ], [ 63, 101 ], [ 93, 102 ], [ 88, 102 ], [ 108, 105 ], [ 69, 106 ], [ 93, 107 ], [ 88, 107 ], [ 113, 110 ], [ 69, 111 ], [ 90, 112 ], [ 85, 112 ], [ 110, 116 ], [ 69, 117 ], [ 90, 118 ], [ 85, 118 ], [ 124, 121 ], [ 63, 122 ], [ 90, 123 ], [ 85, 123 ], [ 127, 126 ], [ 63, 129 ], [ 126, 132 ], [ 138, 137 ], [ 138, 140 ], [ 143, 142 ], [ 147, 146 ], [ 137, 151 ], [ 142, 157 ], [ 140, 158 ], [ 165, 164 ], [ 168, 167 ], [ 137, 171 ], [ 175, 174 ], [ 142, 177 ], [ 167, 178 ], [ 142, 180 ], [ 167, 182 ], [ 174, 186 ], [ 140, 187 ], [ 190, 189 ], [ 164, 192 ], [ 189, 192 ], [ 167, 193 ], [ 146, 196 ], [ 167, 198 ], [ 146, 201 ], [ 211, 210 ], [ 214, 213 ], [ 189, 216 ], [ 164, 216 ], [ 210, 219 ], [ 213, 222 ], [ 226, 225 ], [ 189, 229 ], [ 164, 229 ], [ 137, 231 ], [ 225, 237 ], [ 146, 238 ], [ 210, 242 ], [ 225, 245 ], [ 249, 248 ], [ 146, 248 ], [ 210, 252 ], [ 248, 255 ], [ 259, 258 ], [ 210, 258 ], [ 258, 262 ], [ 268, 267 ], [ 267, 271 ], [ 277, 276 ], [ 276, 280 ], [ 286, 285 ], [ 285, 289 ], [ 371, 313 ], [ 392, 320 ], [ 401, 323 ], [ 395, 328 ], [ 335, 334 ], [ 334, 345 ], [ 389, 347 ], [ 365, 361 ], [ 371, 372 ], [ 389, 390 ], [ 392, 393 ], [ 395, 396 ], [ 401, 402 ] ]

[ "def examA():\n a, b = LI()\n if b<a:\n a,b = b,a\n if a<=0 and 0<=b:\n print(\"Zero\")\n elif 0<a:\n print(\"Positive\")\n else:\n judge = b-a+1\n if judge%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")\n return\n\ndef examB():\n N, M = LI()\n flag_R = [False]*N\n cnt = [1]*N\n flag_R[0] = True\n for _ in range(M):\n x, y = LI()\n x -= 1; y -= 1\n if flag_R[x]:\n flag_R[y] = True\n cnt[y] += 1\n cnt[x] -= 1\n if cnt[x]==0:\n flag_R[x] = False\n ans = sum(flag_R)\n print(ans)\n return\n\ndef examC():\n N, L = LI()\n A = LI()\n can = set()\n\n if N==2:\n if sum(A)<L:\n print(\"Impossible\")\n return\n\n l = inf\n for i in range(N-1):\n cur_R = A[i]+A[i+1]\n if cur_R>=L:\n l = min(l,i)\n can.add(i)\n if not can:\n print(\"Impossible\")\n return\n print(\"Possible\")\n ans = []\n\n for i in range(l):\n ans.append(i+1)\n for i in range(l,N-1)[::-1]:\n if i in can:\n continue\n ans.append(i+1)\n for i in can:\n ans.append(i+1)\n for v in ans:\n print(v)\n return\n\ndef examD():\n ans = 0\n print(ans)\n return\n\ndef examE():\n ans = 0\n print(ans)\n return\n\ndef examF():\n ans = 0\n print(ans)\n return\n\nimport sys,bisect,itertools,heapq,math,random\nfrom copy import deepcopy\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()\nglobal mod,mod2,inf,alphabet,_ep\nmod = 10**9 + 7\nmod2 = 998244353\ninf = 10**18\n_ep = 10**(-12)\nalphabet = [chr(ord('a') + i) for i in range(26)]\n\nsys.setrecursionlimit(10**6)\n\nif __name__ == '__main__':\n examC()\n\n\"\"\"\n\n\"\"\"", "def examA():\n a, b = LI()\n if b<a:\n a,b = b,a\n if a<=0 and 0<=b:\n print(\"Zero\")\n elif 0<a:\n print(\"Positive\")\n else:\n judge = b-a+1\n if judge%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")\n return", "examA", "a, b = LI()", "a", "LI()", "LI", "b", "if b<a:\n a,b = b,a\n ", "b<a", "b", "a", "a,b = b,a", "a", "b", "b", "a", "if a<=0 and 0<=b:\n print(\"Zero\")\n elif 0<a:\n print(\"Positive\")\n else:\n judge = b-a+1\n if judge%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")\n ", "a<=0 and 0<=b", "a<=0", "a", "0", "0<=b", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "elif 0<a:\n print(\"Positive\")\n ", "0<a", "0", "a", "print(\"Positive\")", "print", "\"Positive\"", "judge = b-a+1", "judge", "b-a+1", "b-a", "b", "a", "1", "if judge%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")\n ", "judge%2==0", "judge%2", "judge", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "return", "def examB():\n N, M = LI()\n flag_R = [False]*N\n cnt = [1]*N\n flag_R[0] = True\n for _ in range(M):\n x, y = LI()\n x -= 1; y -= 1\n if flag_R[x]:\n flag_R[y] = True\n cnt[y] += 1\n cnt[x] -= 1\n if cnt[x]==0:\n flag_R[x] = False\n ans = sum(flag_R)\n print(ans)\n return", "examB", "N, M = LI()", "N", "LI()", "LI", "M", "flag_R = [False]*N", "flag_R", "[False]*N", "[False]", "False", "N", "cnt = [1]*N", "cnt", "[1]*N", "[1]", "1", "N", "flag_R[0] = True", "flag_R[0]", "flag_R", "0", "True", "for _ in range(M):\n x, y = LI()\n x -= 1; y -= 1\n if flag_R[x]:\n flag_R[y] = True\n cnt[y] += 1\n cnt[x] -= 1\n if cnt[x]==0:\n flag_R[x] = False\n ", "_", "range(M)", "range", "M", "x, y = LI()", "x", "LI()", "LI", "y", "x -= 1", "x", "1", "y -= 1", "y", "1", "if flag_R[x]:\n flag_R[y] = True\n ", "flag_R[x]", "flag_R", "x", "flag_R[y] = True", "flag_R[y]", "flag_R", "y", "True", "cnt[y] += 1", "cnt[y]", "cnt", "y", "1", "cnt[x] -= 1", "cnt[x]", "cnt", "x", "1", "if cnt[x]==0:\n flag_R[x] = False\n ", "cnt[x]==0", "cnt[x]", "cnt", "x", "0", "flag_R[x] = False", "flag_R[x]", "flag_R", "x", "False", "ans = sum(flag_R)", "ans", "sum(flag_R)", "sum", "flag_R", "print(ans)", "print", "ans", "return", "def examC():\n N, L = LI()\n A = LI()\n can = set()\n\n if N==2:\n if sum(A)<L:\n print(\"Impossible\")\n return\n\n l = inf\n for i in range(N-1):\n cur_R = A[i]+A[i+1]\n if cur_R>=L:\n l = min(l,i)\n can.add(i)\n if not can:\n print(\"Impossible\")\n return\n print(\"Possible\")\n ans = []\n\n for i in range(l):\n ans.append(i+1)\n for i in range(l,N-1)[::-1]:\n if i in can:\n continue\n ans.append(i+1)\n for i in can:\n ans.append(i+1)\n for v in ans:\n print(v)\n return", "examC", "N, L = LI()", "N", "LI()", "LI", "L", "A = LI()", "A", "LI()", "LI", "can = set()", "can", "set()", "set", "if N==2:\n if sum(A)<L:\n print(\"Impossible\")\n return\n\n ", "N==2", "N", "2", "if sum(A)<L:\n print(\"Impossible\")\n return\n\n ", "sum(A)<L", "sum(A)", "sum", "A", "L", "print(\"Impossible\")", "print", "\"Impossible\"", "return", "l = inf", "l", "inf", "for i in range(N-1):\n cur_R = A[i]+A[i+1]\n if cur_R>=L:\n l = min(l,i)\n can.add(i)\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "cur_R = A[i]+A[i+1]", "cur_R", "A[i]+A[i+1]", "A[i]", "A", "i", "A[i+1]", "A", "i+1", "i", "1", "if cur_R>=L:\n l = min(l,i)\n can.add(i)\n ", "cur_R>=L", "cur_R", "L", "l = min(l,i)", "l", "min(l,i)", "min", "l", "i", "can.add(i)", "can.add", "can", "add", "i", "if not can:\n print(\"Impossible\")\n return\n ", "not can", "can", "print(\"Impossible\")", "print", "\"Impossible\"", "return", "print(\"Possible\")", "print", "\"Possible\"", "ans = []", "ans", "[]", "for i in range(l):\n ans.append(i+1)\n ", "i", "range(l)", "range", "l", "ans.append(i+1)", "ans.append", "ans", "append", "i+1", "i", "1", "for i in range(l,N-1)[::-1]:\n if i in can:\n continue\n ans.append(i+1)\n ", "i", "range(l,N-1)[::-1]", "(l,N-1)", "range", "l", "N-1", "N", "1", "::-1", "-1", "if i in can:\n continue\n ", "i in can", "i", "can", "continue", "ans.append(i+1)", "ans.append", "ans", "append", "i+1", "i", "1", "for i in can:\n ans.append(i+1)\n ", "i", "can", "ans.append(i+1)", "ans.append", "ans", "append", "i+1", "i", "1", "for v in ans:\n print(v)\n ", "v", "ans", "print(v)", "print", "v", "return", "def examD():\n ans = 0\n print(ans)\n return", "examD", "ans = 0", "ans", "0", "print(ans)", "print", "ans", "return", "def examE():\n ans = 0\n print(ans)\n return", "examE", "ans = 0", "ans", "0", "print(ans)", "print", "ans", "return", "def examF():\n ans = 0\n print(ans)\n return", "examF", "ans = 0", "ans", "0", "print(ans)", "print", "ans", "return", "import sys,bisect,itertools,heapq,math,random", "sys", "bisect", "itertools", "heapq", "math", "random", "from copy import deepcopy", "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", "global mod,mod2,inf,alphabet,_ep", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "mod2 = 998244353", "mod2", "998244353", "inf = 10**18", "inf", "10**18", "10", "18", "_ep = 10**(-12)", "_ep", "10**(-12)", "10", "-12", "chr(ord('a') + i) for i in range(26)", "for i in range(26)", "i", "range(26)", "range", "26", "for i in range(26)", "chr(ord('a') + i)", "chr", "ord('a') + i", "ord('a')", "ord", "'a'", "i", "alphabet = [chr(ord('a') + i) for i in range(26)]", "alphabet", "[chr(ord('a') + i) for i in range(26)]", "sys.setrecursionlimit(10**6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**6", "10", "6", "if __name__ == '__main__':\n examC()", "__name__ == '__main__'", "__name__", "'__main__'", "examC()", "examC", "\"\"\"\n\n\"\"\"", "def examC():\n N, L = LI()\n A = LI()\n can = set()\n\n if N==2:\n if sum(A)<L:\n print(\"Impossible\")\n return\n\n l = inf\n for i in range(N-1):\n cur_R = A[i]+A[i+1]\n if cur_R>=L:\n l = min(l,i)\n can.add(i)\n if not can:\n print(\"Impossible\")\n return\n print(\"Possible\")\n ans = []\n\n for i in range(l):\n ans.append(i+1)\n for i in range(l,N-1)[::-1]:\n if i in can:\n continue\n ans.append(i+1)\n for i in can:\n ans.append(i+1)\n for v in ans:\n print(v)\n return", "def examC():\n N, L = LI()\n A = LI()\n can = set()\n\n if N==2:\n if sum(A)<L:\n print(\"Impossible\")\n return\n\n l = inf\n for i in range(N-1):\n cur_R = A[i]+A[i+1]\n if cur_R>=L:\n l = min(l,i)\n can.add(i)\n if not can:\n print(\"Impossible\")\n return\n print(\"Possible\")\n ans = []\n\n for i in range(l):\n ans.append(i+1)\n for i in range(l,N-1)[::-1]:\n if i in can:\n continue\n ans.append(i+1)\n for i in can:\n ans.append(i+1)\n for v in ans:\n print(v)\n return", "examC", "def LSI(): return list(map(str,sys.stdin.readline().split()))", "def LSI(): return list(map(str,sys.stdin.readline().split()))", "LSI", "global mod,mod2,inf,alphabet,_ep", "mod = 10**9 + 7", "10**9 + 7", "mod", "def examA():\n a, b = LI()\n if b<a:\n a,b = b,a\n if a<=0 and 0<=b:\n print(\"Zero\")\n elif 0<a:\n print(\"Positive\")\n else:\n judge = b-a+1\n if judge%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")\n return", "def examA():\n a, b = LI()\n if b<a:\n a,b = b,a\n if a<=0 and 0<=b:\n print(\"Zero\")\n elif 0<a:\n print(\"Positive\")\n else:\n judge = b-a+1\n if judge%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")\n return", "examA", "def examF():\n ans = 0\n print(ans)\n return", "def examF():\n ans = 0\n print(ans)\n return", "examF", "def examB():\n N, M = LI()\n flag_R = [False]*N\n cnt = [1]*N\n flag_R[0] = True\n for _ in range(M):\n x, y = LI()\n x -= 1; y -= 1\n if flag_R[x]:\n flag_R[y] = True\n cnt[y] += 1\n cnt[x] -= 1\n if cnt[x]==0:\n flag_R[x] = False\n ans = sum(flag_R)\n print(ans)\n return", "def examB():\n N, M = LI()\n flag_R = [False]*N\n cnt = [1]*N\n flag_R[0] = True\n for _ in range(M):\n x, y = LI()\n x -= 1; y -= 1\n if flag_R[x]:\n flag_R[y] = True\n cnt[y] += 1\n cnt[x] -= 1\n if cnt[x]==0:\n flag_R[x] = False\n ans = sum(flag_R)\n print(ans)\n return", "examB", "def LS(): return sys.stdin.readline().split()", "def LS(): return sys.stdin.readline().split()", "LS", "def examE():\n ans = 0\n print(ans)\n return", "def examE():\n ans = 0\n print(ans)\n return", "examE", "alphabet = [chr(ord('a') + i) for i in range(26)]", "[chr(ord('a') + i) for i in range(26)]", "alphabet", "mod2 = 998244353", "998244353", "mod2", "_ep = 10**(-12)", "10**(-12)", "_ep", "def examD():\n ans = 0\n print(ans)\n return", "def examD():\n ans = 0\n print(ans)\n return", "examD", "inf = 10**18", "10**18", "inf", "def LI(): return list(map(int,sys.stdin.readline().split()))", "def LI(): return list(map(int,sys.stdin.readline().split()))", "LI", "def I(): return int(sys.stdin.readline())", "def I(): return int(sys.stdin.readline())", "I", "def SI(): return sys.stdin.readline().strip()", "def SI(): return sys.stdin.readline().strip()", "SI" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 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, 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, 3, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 77, 2 ], [ 77, 11 ], [ 74, 13 ], [ 24, 23 ], [ 78, 27 ], [ 75, 33 ], [ 23, 34 ], [ 75, 36 ], [ 23, 38 ], [ 72, 40 ], [ 44, 43 ], [ 23, 46 ], [ 43, 49 ], [ 53, 52 ], [ 78, 56 ], [ 23, 58 ], [ 52, 62 ], [ 23, 66 ], [ 77, 72 ], [ 74, 75 ], [ 77, 78 ] ]

[ "N,L = map(int, raw_input().split())\na = map(int, raw_input().split())\n\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):\n print j+1\n print i+1\n break\nelse:\n print \"Impossible\"", "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", "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):\n print j+1\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(i):\n print j+1\n for j in range(N-2,i,-1):\n print j+1\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", "for j in range(i):\n print j+1\n ", "j", "range(i)", "range", "i", "print", "j+1", "j", "1", "for j in range(N-2,i,-1):\n print j+1\n ", "j", "range(N-2,i,-1)", "range", "N-2", "N", "2", "i", "-1", "print", "j+1", "j", "1", "print", "i+1", "i", "1", "break", "print", "L = map(int, raw_input().split())", "map(int, raw_input().split())", "L", "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" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 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, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 13, 28, 13, 4, 13, 2, 13, 17, 13, 17, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 80, 2 ], [ 80, 11 ], [ 86, 13 ], [ 83, 23 ], [ 27, 26 ], [ 81, 30 ], [ 87, 36 ], [ 26, 37 ], [ 87, 39 ], [ 26, 41 ], [ 75, 43 ], [ 77, 45 ], [ 26, 46 ], [ 78, 50 ], [ 84, 50 ], [ 56, 55 ], [ 78, 60 ], [ 84, 60 ], [ 65, 64 ], [ 81, 68 ], [ 78, 70 ], [ 84, 70 ], [ 80, 75 ], [ 26, 77 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ] ]

[ "N, L = map(int, raw_input().split())\nA = map(int, raw_input().split())\n\nk = None\nfor i in range(N-1):\n if A[i] + A[i+1] >= L:\n k = i\n break\n \nif k is None:\n print \"Impossible\"\nelse:\n print \"Possible\"\n for j in range(1,k+1):\n print j\n for j in range(N-1, k, -1):\n print j", "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", "k = None", "k", "None", "for i in range(N-1):\n if A[i] + A[i+1] >= L:\n k = i\n break\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i] + A[i+1] >= L:\n k = 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", "k = i", "k", "i", "break", "if k is None:\n print \"Impossible\"\nelse:\n print \"Possible\"\n for j in range(1,k+1):\n print j\n for j in range(N-1, k, -1):\n print j", "k is None", "k", "None", "print", "print", "for j in range(1,k+1):\n print j\n ", "j", "range(1,k+1)", "range", "1", "k+1", "k", "1", "print", "for j in range(N-1, k, -1):\n print j", "j", "range(N-1, k, -1)", "range", "N-1", "N", "1", "k", "-1", "print", "L = map(int, raw_input().split())", "map(int, raw_input().split())", "L", "k = i", "i", "k", "N, L = map(int, raw_input().split())", "map(int, raw_input().split())", "N", "k = None", "None", "k", "A = map(int, raw_input().split())", "map(int, raw_input().split())", "A" ]

[ 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, 17, 4, 13, 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, 0, 13, 39, 28, 13, 4, 13, 17, 13, 4, 18, 13, 13, 13, 0, 13, 39, 28, 13, 4, 13, 2, 4, 13, 13, 17, 13, 17, 4, 18, 13, 13, 13, 4, 13, 17, 28, 13, 13, 4, 13, 13, 28, 13, 13, 4, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 18, 13, 10, 39, 13, 10, 4, 13, 10, 39, 13, 10, 17, 13 ]

[ [ 131, 4 ], [ 125, 11 ], [ 132, 18 ], [ 125, 20 ], [ 137, 22 ], [ 132, 31 ], [ 143, 34 ], [ 38, 37 ], [ 138, 43 ], [ 138, 48 ], [ 37, 49 ], [ 138, 51 ], [ 37, 53 ], [ 126, 55 ], [ 128, 57 ], [ 37, 58 ], [ 129, 62 ], [ 144, 62 ], [ 140, 71 ], [ 75, 74 ], [ 129, 78 ], [ 144, 78 ], [ 141, 81 ], [ 74, 83 ], [ 134, 85 ], [ 89, 88 ], [ 138, 94 ], [ 129, 96 ], [ 144, 96 ], [ 135, 100 ], [ 88, 102 ], [ 108, 107 ], [ 141, 107 ], [ 107, 111 ], [ 114, 113 ], [ 135, 113 ], [ 113, 117 ], [ 129, 120 ], [ 144, 120 ], [ 125, 123 ], [ 125, 126 ], [ 37, 128 ], [ 128, 129 ], [ 131, 132 ], [ 134, 135 ], [ 137, 138 ], [ 140, 141 ], [ 143, 144 ] ]

[ "import sys\nreadline = sys.stdin.readline\n\nN,L = map(int,readline().split())\nA = list(map(int,readline().split()))\n\n# 2個でL以上の隣合うペアがどこかにあれば、そこを最後に残せば大丈夫\ntarget = -1\nfor i in range(1,len(A)):\n if A[i] + A[i - 1] >= L:\n target = i\n break\nif target == -1:\n print(\"Impossible\")\n exit(0)\n\nleft = []\nfor i in range(1,target):\n left.append(i)\n \nright = []\nfor i in range(len(A) - 1,target,-1):\n right.append(i)\n\nprint(\"Possible\")\nfor l in left:\n print(l)\nfor r in right:\n print(r)\nprint(target)", "import sys", "sys", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "N,L = map(int,readline().split())", "N", "map(int,readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "L", "A = list(map(int,readline().split()))", "A", "list(map(int,readline().split()))", "list", "map(int,readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "target = -1", "target", "-1", "for i in range(1,len(A)):\n if A[i] + A[i - 1] >= L:\n target = i\n break", "i", "range(1,len(A))", "range", "1", "len(A)", "len", "A", "if A[i] + A[i - 1] >= L:\n target = 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", "target = i", "target", "i", "break", "if target == -1:\n print(\"Impossible\")\n exit(0)", "target == -1", "target", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "exit(0)", "exit", "0", "left = []", "left", "[]", "for i in range(1,target):\n left.append(i)\n ", "i", "range(1,target)", "range", "1", "target", "left.append(i)", "left.append", "left", "append", "i", "right = []", "right", "[]", "for i in range(len(A) - 1,target,-1):\n right.append(i)", "i", "range(len(A) - 1,target,-1)", "range", "len(A) - 1", "len(A)", "len", "A", "1", "target", "-1", "right.append(i)", "right.append", "right", "append", "i", "print(\"Possible\")", "print", "\"Possible\"", "for l in left:\n print(l)", "l", "left", "print(l)", "print", "l", "for r in right:\n print(r)", "r", "right", "print(r)", "print", "r", "print(target)", "print", "target", "N,L = map(int,readline().split())", "map(int,readline().split())", "N", "L = map(int,readline().split())", "map(int,readline().split())", "L", "target = i", "i", "target", "readline = sys.stdin.readline", "sys.stdin.readline", "readline", "right = []", "[]", "right", "A = list(map(int,readline().split()))", "list(map(int,readline().split()))", "A", "left = []", "[]", "left", "target = -1", "-1", "target" ]

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 4, 18, 13, 13, 17, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 13, 13, 4, 18, 4, 13, 13, 17, 12, 13, 29, 4, 13, 12, 13, 29, 4, 18, 4, 13, 13, 17, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 18, 17, 13, 13, 23, 13, 12, 13, 0, 13, 17, 12, 13, 14, 40, 13, 13, 0, 18, 13, 13, 4, 13, 31, 13, 29, 18, 13, 13, 23, 29, 13, 23, 13, 0, 13, 4, 13, 39, 17, 17, 17, 17, 39, 17, 17, 17, 17, 0, 13, 4, 13, 17, 0, 13, 17, 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, 14, 2, 13, 17, 13, 13, 0, 13, 39, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 13, 4, 18, 13, 13, 13, 28, 13, 4, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 13, 4, 18, 13, 13, 28, 13, 13, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 17, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 63, 61 ], [ 63, 63 ], [ 68, 67 ], [ 67, 74 ], [ 79, 76 ], [ 67, 77 ], [ 91, 80 ], [ 76, 84 ], [ 67, 85 ], [ 70, 89 ], [ 91, 91 ], [ 200, 93 ], [ 236, 107 ], [ 215, 112 ], [ 239, 115 ], [ 222, 117 ], [ 239, 118 ], [ 203, 120 ], [ 222, 122 ], [ 218, 124 ], [ 128, 127 ], [ 210, 131 ], [ 204, 137 ], [ 127, 138 ], [ 204, 140 ], [ 127, 142 ], [ 240, 144 ], [ 212, 146 ], [ 127, 147 ], [ 213, 150 ], [ 219, 150 ], [ 197, 155 ], [ 213, 158 ], [ 219, 158 ], [ 162, 161 ], [ 213, 165 ], [ 219, 165 ], [ 210, 167 ], [ 198, 170 ], [ 161, 172 ], [ 175, 174 ], [ 213, 181 ], [ 219, 181 ], [ 198, 185 ], [ 174, 187 ], [ 198, 190 ], [ 194, 193 ], [ 198, 193 ], [ 197, 198 ], [ 200, 201 ], [ 203, 204 ], [ 239, 210 ], [ 127, 212 ], [ 212, 213 ], [ 215, 216 ], [ 218, 219 ], [ 236, 237 ], [ 239, 240 ] ]

[ "import bisect\nimport sys\nimport math\nimport itertools\nsys.setrecursionlimit(10000)\n \n# input macro\ndef i():\n return int(raw_input())\ndef ii():\n return map(int,raw_input().split(\" \"))\ndef s():\n return raw_input()\ndef ss():\n return raw_input().split(\" \")\ndef slist():\n return list(raw_input())\n#\n \ndef join(s):\n return ''.join(s)\n \n#memoize macro\ndef memoize(f):\n cache = {}\n def helper(*args):\n if args not in cache:\n cache[(args)] = f(*args)\n return cache[args]\n return helper\n \nnh=zip([1,0,-1,0],[0,1,0,-1])\nINF = float('inf')\nmod=1000000007\n \n###########\n\nn,l=ii()\na=ii()\np=-1\nfor j in range(n-1):\n if a[j]+a[j+1]>=l:\n p=j\n\nif p==-1:\n print \"Impossible\"\nelse:\n print \"Possible\"\n x=[p+1]\n for j in range(p+2,n):\n x.append(j)\n for j in reversed(range(1,p+1)):\n x.append(j)\n x.reverse()\n for j in x:\n print j", "import bisect", "bisect", "import sys", "sys", "import math", "math", "import itertools", "itertools", "sys.setrecursionlimit(10000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10000", "def i():\n return int(raw_input())", "i", "return int(raw_input())", "int(raw_input())", "int", "raw_input()", "raw_input", "def ii():\n return map(int,raw_input().split(\" \"))", "ii", "return map(int,raw_input().split(\" \"))", "map(int,raw_input().split(\" \"))", "map", "int", "raw_input().split(\" \")", "().split", "()", "raw_input", "split", "\" \"", "def s():\n return raw_input()", "s", "return raw_input()", "raw_input()", "raw_input", "def ss():\n return raw_input().split(\" \")", "ss", "return raw_input().split(\" \")", "raw_input().split(\" \")", "().split", "()", "raw_input", "split", "\" \"", "def slist():\n return list(raw_input())\n#\n ", "slist", "return list(raw_input())", "list(raw_input())", "list", "raw_input()", "raw_input", "def join(s):\n return ''.join(s)\n \n#memoize macro", "join", "return ''.join(s)", "''.join(s)", "''.join", "''", "join", "s", "s", "s", "def memoize(f):\n cache = {}\n def helper(*args):\n if args not in cache:\n cache[(args)] = f(*args)\n return cache[args]\n return helper\n ", "memoize", "cache = {}", "cache", "{}", "def helper(*args):\n if args not in cache:\n cache[(args)] = f(*args)\n return cache[args]\n ", "helper", "if args not in cache:\n cache[(args)] = f(*args)\n ", "args not in cache", "args", "cache", "cache[(args)] = f(*args)", "cache[(args)]", "cache", "args", "f(*args)", "f", "*args", "args", "return cache[args]", "cache[args]", "cache", "args", "*args", "return helper", "helper", "f", "f", "nh=zip([1,0,-1,0],[0,1,0,-1])", "nh", "zip([1,0,-1,0],[0,1,0,-1])", "zip", "[1,0,-1,0]", "1", "0", "-1", "0", "[0,1,0,-1]", "0", "1", "0", "-1", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "mod=1000000007", "mod", "1000000007", "n,l=ii()", "n", "ii()", "ii", "l", "a=ii()", "a", "ii()", "ii", "p=-1", "p", "-1", "for j in range(n-1):\n if a[j]+a[j+1]>=l:\n p=j", "j", "range(n-1)", "range", "n-1", "n", "1", "if a[j]+a[j+1]>=l:\n p=j", "a[j]+a[j+1]>=l", "a[j]+a[j+1]", "a[j]", "a", "j", "a[j+1]", "a", "j+1", "j", "1", "l", "p=j", "p", "j", "if p==-1:\n print \"Impossible\"\nelse:\n print \"Possible\"\n x=[p+1]\n for j in range(p+2,n):\n x.append(j)\n for j in reversed(range(1,p+1)):\n x.append(j)\n x.reverse()\n for j in x:\n print j", "p==-1", "p", "-1", "print", "print", "x=[p+1]", "x", "[p+1]", "p+1", "p", "1", "for j in range(p+2,n):\n x.append(j)\n ", "j", "range(p+2,n)", "range", "p+2", "p", "2", "n", "x.append(j)", "x.append", "x", "append", "j", "for j in reversed(range(1,p+1)):\n x.append(j)\n ", "j", "reversed(range(1,p+1))", "reversed", "range(1,p+1)", "range", "1", "p+1", "p", "1", "x.append(j)", "x.append", "x", "append", "j", "x.reverse()", "x.reverse", "x", "reverse", "for j in x:\n print j", "j", "x", "print", "x=[p+1]", "[p+1]", "x", "nh=zip([1,0,-1,0],[0,1,0,-1])", "zip([1,0,-1,0],[0,1,0,-1])", "nh", "a=ii()", "ii()", "a", "def ss():\n return raw_input().split(\" \")", "def ss():\n return raw_input().split(\" \")", "ss", "n,l=ii()", "ii()", "n", "p=j", "j", "p", "mod=1000000007", "1000000007", "mod", "p=-1", "-1", "p", "def ii():\n return map(int,raw_input().split(\" \"))", "def ii():\n return map(int,raw_input().split(\" \"))", "ii", "def join(s):\n return ''.join(s)\n \n#memoize macro", "def join(s):\n return ''.join(s)\n \n#memoize macro", "join", "def memoize(f):\n cache = {}\n def helper(*args):\n if args not in cache:\n cache[(args)] = f(*args)\n return cache[args]\n return helper\n ", "def memoize(f):\n cache = {}\n def helper(*args):\n if args not in cache:\n cache[(args)] = f(*args)\n return cache[args]\n return helper\n ", "memoize", "def s():\n return raw_input()", "def s():\n return raw_input()", "s", "def slist():\n return list(raw_input())\n#\n ", "def slist():\n return list(raw_input())\n#\n ", "slist", "INF = float('inf')", "float('inf')", "INF", "l=ii()", "ii()", "l", "def i():\n return int(raw_input())", "def i():\n return int(raw_input())", "i" ]

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 15, 15, 15, 15, 4, 18, 13, 13, 17, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 4, 13, 31, 13, 0, 13, 18, 13, 13, 23, 12, 13, 15, 13, 12, 13, 0, 13, 4, 18, 13, 13, 0, 13, 4, 13, 31, 13, 32, 13, 0, 13, 4, 18, 13, 13, 4, 13, 2, 13, 13, 17, 29, 13, 23, 16, 29, 13, 23, 13, 12, 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, 4, 13, 2, 13, 17, 2, 13, 17, 4, 13, 2, 13, 17, 4, 13, 2, 13, 17, 29, 4, 13, 17, 23, 13, 23, 13, 23, 13, 0, 13, 13, 13, 12, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 4, 13, 13, 13, 13, 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 ]

[ [ 90, 89 ], [ 102, 101 ], [ 108, 107 ], [ 133, 109 ], [ 116, 115 ], [ 240, 121 ], [ 115, 123 ], [ 101, 124 ], [ 107, 127 ], [ 99, 131 ], [ 133, 133 ], [ 252, 135 ], [ 138, 137 ], [ 195, 141 ], [ 199, 147 ], [ 137, 148 ], [ 199, 150 ], [ 137, 152 ], [ 197, 154 ], [ 160, 159 ], [ 137, 162 ], [ 159, 166 ], [ 170, 169 ], [ 137, 175 ], [ 195, 178 ], [ 169, 183 ], [ 137, 188 ], [ 195, 195 ], [ 197, 197 ], [ 199, 199 ], [ 252, 201 ], [ 246, 202 ], [ 252, 203 ], [ 208, 207 ], [ 243, 209 ], [ 208, 210 ], [ 213, 212 ], [ 243, 214 ], [ 252, 216 ], [ 207, 217 ], [ 210, 218 ], [ 212, 219 ], [ 255, 225 ], [ 252, 252 ] ]

[ "# -*- coding: utf-8 -*-\nimport bisect\nimport heapq\nimport math\nimport random\nimport sys\nfrom collections import Counter, defaultdict, deque\nfrom decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal\nfrom functools import lru_cache, reduce\nfrom itertools import combinations, combinations_with_replacement, product, permutations\nfrom operator import add, mul, sub\n\nsys.setrecursionlimit(10000)\n\n\ndef read_int():\n return int(input())\n\n\ndef read_int_n():\n return list(map(int, input().split()))\n\n\ndef read_float():\n return float(input())\n\n\ndef read_float_n():\n return list(map(float, input().split()))\n\n\ndef read_str():\n return input().strip()\n\n\ndef read_str_n():\n return list(map(str, input().split()))\n\n\ndef error_print(*args):\n print(*args, file=sys.stderr)\n\n\ndef mt(f):\n import time\n\n def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n return wrap\n\n\n@mt\ndef slv(N, L, A):\n\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 reversed(range(i+1, N-1)):\n print(j+1)\n print(i+1)\n return\n\n else:\n print('Impossible')\n\n\ndef main():\n N, L = read_int_n()\n A = read_int_n()\n slv(N, L, A)\n\n\nif __name__ == '__main__':\n main()", "import bisect", "bisect", "import heapq", "heapq", "import math", "math", "import random", "random", "import sys", "sys", "from collections import Counter, defaultdict, deque", "from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal", "from functools import lru_cache, reduce", "from itertools import combinations, combinations_with_replacement, product, permutations", "from operator import add, mul, sub", "sys.setrecursionlimit(10000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10000", "def read_int():\n return int(input())", "read_int", "return int(input())", "int(input())", "int", "input()", "input", "def read_int_n():\n return list(map(int, input().split()))", "read_int_n", "return list(map(int, input().split()))", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def read_float():\n return float(input())", "read_float", "return float(input())", "float(input())", "float", "input()", "input", "def read_float_n():\n return list(map(float, input().split()))", "read_float_n", "return list(map(float, input().split()))", "list(map(float, input().split()))", "list", "map(float, input().split())", "map", "float", "input().split()", "().split", "()", "input", "split", "def read_str():\n return input().strip()", "read_str", "return input().strip()", "input().strip()", "().strip", "()", "input", "strip", "def read_str_n():\n return list(map(str, input().split()))", "read_str_n", "return list(map(str, input().split()))", "list(map(str, input().split()))", "list", "map(str, input().split())", "map", "str", "input().split()", "().split", "()", "input", "split", "def error_print(*args):\n print(*args, file=sys.stderr)", "error_print", "print(*args, file=sys.stderr)", "print", "*args", "args", "file=sys.stderr", "file", "sys.stderr", "sys", "stderr", "*args", "def mt(f):\n import time\n\n def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n return wrap", "mt", "import time", "time", "def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n ", "wrap", "s = time.time()", "s", "time.time()", "time.time", "time", "time", "ret = f(*args, **kwargs)", "ret", "f(*args, **kwargs)", "f", "*args", "args", "**kwargs", "kwargs", "e = time.time()", "e", "time.time()", "time.time", "time", "time", "error_print(e - s, 'sec')", "error_print", "e - s", "e", "s", "'sec'", "return ret", "ret", "*args", "**kwargs", "return wrap", "wrap", "f", "f", "def slv(N, L, A):\n\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 reversed(range(i+1, N-1)):\n print(j+1)\n print(i+1)\n return\n\n else:\n print('Impossible')", "slv", "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 reversed(range(i+1, N-1)):\n print(j+1)\n print(i+1)\n return\n\n else:\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(i):\n print(j+1)\n for j in reversed(range(i+1, N-1)):\n print(j+1)\n print(i+1)\n return\n\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 reversed(range(i+1, N-1)):\n print(j+1)\n ", "j", "reversed(range(i+1, N-1))", "reversed", "range(i+1, N-1)", "range", "i+1", "i", "1", "N-1", "N", "1", "print(j+1)", "print", "j+1", "j", "1", "print(i+1)", "print", "i+1", "i", "1", "return", "print('Impossible')", "print", "'Impossible'", "N", "N", "L", "L", "A", "A", "@mt", "slv", "mt", "slv", "def main():\n N, L = read_int_n()\n A = read_int_n()\n slv(N, L, A)", "main", "N, L = read_int_n()", "N", "read_int_n()", "read_int_n", "L", "A = read_int_n()", "A", "read_int_n()", "read_int_n", "slv(N, L, A)", "slv", "N", "L", "A", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def read_str():\n return input().strip()", "def read_str():\n return input().strip()", "read_str", "def read_int():\n return int(input())", "def read_int():\n return int(input())", "read_int", "def read_float():\n return float(input())", "def read_float():\n return float(input())", "read_float", "def read_float_n():\n return list(map(float, input().split()))", "def read_float_n():\n return list(map(float, input().split()))", "read_float_n", "def error_print(*args):\n print(*args, file=sys.stderr)", "def error_print(*args):\n print(*args, file=sys.stderr)", "error_print", "def read_int_n():\n return list(map(int, input().split()))", "def read_int_n():\n return list(map(int, input().split()))", "read_int_n", "def mt(f):\n import time\n\n def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n return wrap", "def mt(f):\n import time\n\n def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n return wrap", "mt", "def read_str_n():\n return list(map(str, input().split()))", "def read_str_n():\n return list(map(str, input().split()))", "read_str_n", "def slv(N, L, A):\n\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 reversed(range(i+1, N-1)):\n print(j+1)\n print(i+1)\n return\n\n else:\n print('Impossible')", "def slv(N, L, A):\n\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 reversed(range(i+1, N-1)):\n print(j+1)\n print(i+1)\n return\n\n else:\n print('Impossible')", "slv", "def main():\n N, L = read_int_n()\n A = read_int_n()\n slv(N, L, A)", "def main():\n N, L = read_int_n()\n A = read_int_n()\n slv(N, L, A)", "main" ]

[ 7, 15, 13, 0, 13, 4, 13, 17, 0, 13, 2, 2, 17, 17, 17, 41, 28, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 4, 4, 13, 13, 12, 13, 41, 28, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 4, 2, 4, 13, 13, 17, 12, 13, 41, 28, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 4, 4, 13, 13, 12, 13, 12, 13, 12, 13, 12, 13, 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, 0, 13, 13, 4, 13, 17, 3, 4, 13, 17, 29, 17, 28, 13, 4, 13, 13, 4, 13, 2, 13, 17, 28, 13, 18, 4, 13, 13, 2, 13, 17, 39, 17, 4, 13, 2, 13, 17, 29, 17, 4, 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, 10, 12, 13 ]

[ [ 156, 4 ], [ 150, 9 ], [ 18, 17 ], [ 17, 30 ], [ 36, 35 ], [ 35, 49 ], [ 56, 55 ], [ 55, 68 ], [ 81, 80 ], [ 172, 82 ], [ 81, 83 ], [ 86, 85 ], [ 172, 87 ], [ 90, 89 ], [ 80, 93 ], [ 85, 99 ], [ 89, 100 ], [ 85, 102 ], [ 89, 104 ], [ 83, 106 ], [ 109, 108 ], [ 89, 109 ], [ 121, 120 ], [ 108, 123 ], [ 120, 127 ], [ 131, 130 ], [ 108, 134 ], [ 80, 136 ], [ 130, 143 ], [ 169, 148 ], [ 150, 151 ], [ 156, 157 ] ]

[ "# coding:utf-8\n\nimport sys\n\nINF = float('inf')\nMOD = 10 ** 9 + 7\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef II(): return int(sys.stdin.readline())\ndef SI(): return input()\n\n\ndef main():\n n, l = LI()\n A = LI()\n\n for i in range(n - 1):\n if A[i] + A[i + 1] >= l:\n k = i\n print('Possible')\n break\n else:\n print('Impossible')\n return 0\n\n for i in range(k):\n print(i + 1)\n\n for i in range(k, n - 1)[::-1]:\n print(i + 1)\n\n return 1\n\n\nmain()", "import sys", "sys", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "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", "int(x) - 1 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) - 1", "int(x)", "int", "x", "1", "def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]", "LI_", "float(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()", "float(x)", "float", "x", "def LF(): return [float(x) for x in sys.stdin.readline().split()]", "LF", "def LS(): return sys.stdin.readline().split()", "LS", "def II(): return int(sys.stdin.readline())", "II", "def SI(): return input()", "SI", "def main():\n n, l = LI()\n A = LI()\n\n for i in range(n - 1):\n if A[i] + A[i + 1] >= l:\n k = i\n print('Possible')\n break\n else:\n print('Impossible')\n return 0\n\n for i in range(k):\n print(i + 1)\n\n for i in range(k, n - 1)[::-1]:\n print(i + 1)\n\n return 1", "main", "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 k = i\n print('Possible')\n break\n else:\n print('Impossible')\n return 0\n\n ", "i", "range(n - 1)", "range", "n - 1", "n", "1", "if A[i] + A[i + 1] >= l:\n k = i\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", "k = i", "k", "i", "print('Possible')", "print", "'Possible'", "break", "print('Impossible')", "print", "'Impossible'", "return 0", "0", "for i in range(k):\n print(i + 1)\n\n ", "i", "range(k)", "range", "k", "print(i + 1)", "print", "i + 1", "i", "1", "for i in range(k, n - 1)[::-1]:\n print(i + 1)\n\n ", "i", "range(k, n - 1)[::-1]", "(k, n - 1)", "range", "k", "n - 1", "n", "1", "::-1", "-1", "print(i + 1)", "print", "i + 1", "i", "1", "return 1", "1", "main()", "main", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "def SI(): return input()", "def SI(): return input()", "SI", "INF = float('inf')", "float('inf')", "INF", "def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]", "def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]", "LI_", "def II(): return int(sys.stdin.readline())", "def II(): return int(sys.stdin.readline())", "II", "def LF(): return [float(x) for x in sys.stdin.readline().split()]", "def LF(): return [float(x) for x in sys.stdin.readline().split()]", "LF", "def main():\n n, l = LI()\n A = LI()\n\n for i in range(n - 1):\n if A[i] + A[i + 1] >= l:\n k = i\n print('Possible')\n break\n else:\n print('Impossible')\n return 0\n\n for i in range(k):\n print(i + 1)\n\n for i in range(k, n - 1)[::-1]:\n print(i + 1)\n\n return 1", "def main():\n n, l = LI()\n A = LI()\n\n for i in range(n - 1):\n if A[i] + A[i + 1] >= l:\n k = i\n print('Possible')\n break\n else:\n print('Impossible')\n return 0\n\n for i in range(k):\n print(i + 1)\n\n for i in range(k, n - 1)[::-1]:\n print(i + 1)\n\n return 1", "main", "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 LS(): return sys.stdin.readline().split()", "def LS(): return sys.stdin.readline().split()", "LS" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 4, 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, 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, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 92, 4 ], [ 101, 11 ], [ 98, 16 ], [ 93, 23 ], [ 98, 25 ], [ 89, 27 ], [ 93, 36 ], [ 40, 39 ], [ 96, 43 ], [ 90, 48 ], [ 39, 49 ], [ 90, 51 ], [ 39, 53 ], [ 99, 55 ], [ 61, 60 ], [ 39, 64 ], [ 60, 67 ], [ 70, 69 ], [ 96, 73 ], [ 39, 75 ], [ 69, 79 ], [ 39, 82 ], [ 89, 90 ], [ 92, 93 ], [ 98, 96 ], [ 98, 99 ], [ 101, 102 ] ]

[ "import sys\ninput = sys.stdin.readline\ninf = float(\"inf\")\n\nn,L = map(int,input().split())\na = tuple(map(int,input().split()))\n\nfor 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\nprint('Impossible')", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "inf = float(\"inf\")", "inf", "float(\"inf\")", "float", "\"inf\"", "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", "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()", "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()", "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'", "a = tuple(map(int,input().split()))", "tuple(map(int,input().split()))", "a", "input = sys.stdin.readline", "sys.stdin.readline", "input", "n,L = map(int,input().split())", "map(int,input().split())", "n", "L = map(int,input().split())", "map(int,input().split())", "L", "inf = float(\"inf\")", "float(\"inf\")", "inf" ]

[ 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, 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, 2, 13, 17, 14, 2, 13, 13, 4, 13, 17, 4, 13, 4, 13, 17, 28, 13, 4, 13, 17, 13, 4, 13, 13, 28, 13, 18, 4, 13, 2, 13, 17, 13, 39, 17, 4, 13, 13, 4, 13, 13, 10, 17, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 125, 2 ], [ 125, 11 ], [ 15, 14 ], [ 14, 23 ], [ 113, 25 ], [ 107, 28 ], [ 116, 31 ], [ 35, 34 ], [ 126, 38 ], [ 114, 44 ], [ 34, 45 ], [ 114, 47 ], [ 34, 49 ], [ 108, 51 ], [ 120, 51 ], [ 119, 53 ], [ 114, 56 ], [ 34, 57 ], [ 114, 59 ], [ 34, 61 ], [ 122, 64 ], [ 34, 66 ], [ 120, 70 ], [ 108, 70 ], [ 111, 71 ], [ 82, 81 ], [ 123, 85 ], [ 117, 85 ], [ 81, 88 ], [ 91, 90 ], [ 123, 95 ], [ 117, 95 ], [ 126, 97 ], [ 90, 102 ], [ 123, 105 ], [ 117, 105 ], [ 107, 108 ], [ 125, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ] ]

[ "N,L=map(int,input().split())\na=[int(i) for i in input().split()]\nLongest_pair=0\np=0\nfor i in range(N-1):\n if a[i]+a[i+1]>Longest_pair:\n Longest_pair=a[i]+a[i+1]\n p=i+1\nif Longest_pair<L:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")\nfor i in range(1,p):\n print(i)\nfor i in range(p+1,N)[::-1]:\n print(i)\nprint(p)", "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()]", "Longest_pair=0", "Longest_pair", "0", "p=0", "p", "0", "for i in range(N-1):\n if a[i]+a[i+1]>Longest_pair:\n Longest_pair=a[i]+a[i+1]\n p=i+1", "i", "range(N-1)", "range", "N-1", "N", "1", "if a[i]+a[i+1]>Longest_pair:\n Longest_pair=a[i]+a[i+1]\n p=i+1", "a[i]+a[i+1]>Longest_pair", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "Longest_pair", "Longest_pair=a[i]+a[i+1]", "Longest_pair", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "p=i+1", "p", "i+1", "i", "1", "if Longest_pair<L:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")", "Longest_pair<L", "Longest_pair", "L", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,p):\n print(i)", "i", "range(1,p)", "range", "1", "p", "print(i)", "print", "i", "for i in range(p+1,N)[::-1]:\n print(i)", "i", "range(p+1,N)[::-1]", "(p+1,N)", "range", "p+1", "p", "1", "N", "::-1", "-1", "print(i)", "print", "i", "print(p)", "print", "p", "Longest_pair=0", "0", "Longest_pair", "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", "p=0", "0", "p", "Longest_pair=a[i]+a[i+1]", "a[i]+a[i+1]", "Longest_pair", "p=i+1", "i+1", "p", "N,L=map(int,input().split())", "map(int,input().split())", "N" ]

[ 7, 15, 13, 0, 13, 18, 13, 13, 4, 18, 13, 13, 2, 17, 17, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 4, 13, 0, 13, 17, 28, 13, 39, 13, 13, 4, 13, 4, 13, 18, 13, 39, 17, 18, 13, 39, 17, 14, 40, 2, 13, 13, 13, 41, 28, 13, 4, 13, 13, 4, 2, 13, 17, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 13, 17, 4, 2, 13, 17, 0, 13, 13, 0, 13, 2, 2, 13, 13, 39, 2, 13, 17, 0, 13, 17, 3, 14, 13, 4, 13, 17, 28, 13, 13, 4, 13, 13, 4, 13, 17, 10, 12, 13, 10, 13, 13, 10, 18, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 12, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 133, 4 ], [ 169, 32 ], [ 173, 34 ], [ 169, 35 ], [ 151, 37 ], [ 173, 41 ], [ 148, 43 ], [ 152, 55 ], [ 152, 59 ], [ 161, 67 ], [ 71, 70 ], [ 70, 76 ], [ 130, 79 ], [ 84, 83 ], [ 170, 87 ], [ 83, 93 ], [ 157, 96 ], [ 163, 99 ], [ 131, 102 ], [ 158, 103 ], [ 145, 109 ], [ 119, 118 ], [ 164, 118 ], [ 118, 122 ], [ 130, 131 ], [ 133, 134 ], [ 145, 146 ], [ 148, 149 ], [ 151, 152 ], [ 157, 158 ], [ 169, 161 ], [ 163, 164 ], [ 169, 170 ] ]

[ "import sys\nstdin = sys.stdin\n \nsys.setrecursionlimit(10**5) \n \ndef li(): return map(int, stdin.readline().split())\ndef li_(): return map(lambda x: int(x)-1, stdin.readline().split())\ndef lf(): return map(float, stdin.readline().split())\ndef ls(): return stdin.readline().split()\ndef ns(): return stdin.readline().rstrip()\ndef lc(): return list(ns())\ndef ni(): return int(stdin.readline())\ndef nf(): return float(stdin.readline())\n\nn,l = li()\na = list(li())\n\nexist = False\n\nfor i, (ap, an) in enumerate(zip(a[:-1], a[1:])):\n if ap + an >= l:\n bef = [j+1 for j in range(i)]\n aft = [j+1 for j in range(n-2,i,-1)]\n ans = bef + aft + [i+1]\n exist = True\n break\n\nif exist:\n print(\"Possible\")\n for ai in ans:\n print(ai)\n\nelse:\n print(\"Impossible\")", "import sys", "sys", "stdin = sys.stdin", "stdin", "sys.stdin", "sys", "stdin", "sys.setrecursionlimit(10**5)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**5", "10", "5", "def li(): return map(int, stdin.readline().split())", "li", "def li_(): return map(lambda x: int(x)-1, stdin.readline().split())", "li_", "def lf(): return map(float, stdin.readline().split())", "lf", "def ls(): return stdin.readline().split()", "ls", "def ns(): return stdin.readline().rstrip()", "ns", "def lc(): return list(ns())", "lc", "def ni(): return int(stdin.readline())", "ni", "def nf(): return float(stdin.readline())", "nf", "n,l = li()", "n", "li()", "li", "l", "a = list(li())", "a", "list(li())", "list", "li()", "li", "exist = False", "exist", "False", "for i, (ap, an) in enumerate(zip(a[:-1], a[1:])):\n if ap + an >= l:\n bef = [j+1 for j in range(i)]\n aft = [j+1 for j in range(n-2,i,-1)]\n ans = bef + aft + [i+1]\n exist = True\n break", "i", "(ap, an)", "ap", "an", "enumerate(zip(a[:-1], a[1:]))", "enumerate", "zip(a[:-1], a[1:])", "zip", "a[:-1]", "a", ":-1", "-1", "a[1:]", "a", "1:", "1", "if ap + an >= l:\n bef = [j+1 for j in range(i)]\n aft = [j+1 for j in range(n-2,i,-1)]\n ans = bef + aft + [i+1]\n exist = True\n break", "ap + an >= l", "ap + an", "ap", "an", "l", "j+1 for j in range(i)", "for j in range(i)", "j", "range(i)", "range", "i", "for j in range(i)", "j+1", "j", "1", "bef = [j+1 for j in range(i)]", "bef", "[j+1 for j in range(i)]", "j+1 for j in range(n-2,i,-1)", "for j in range(n-2,i,-1)", "j", "range(n-2,i,-1)", "range", "n-2", "n", "2", "i", "-1", "for j in range(n-2,i,-1)", "j+1", "j", "1", "aft = [j+1 for j in range(n-2,i,-1)]", "aft", "[j+1 for j in range(n-2,i,-1)]", "ans = bef + aft + [i+1]", "ans", "bef + aft + [i+1]", "bef + aft", "bef", "aft", "[i+1]", "i+1", "i", "1", "exist = True", "exist", "True", "break", "if exist:\n print(\"Possible\")\n for ai in ans:\n print(ai)\n\nelse:\n print(\"Impossible\")", "exist", "print(\"Possible\")", "print", "\"Possible\"", "for ai in ans:\n print(ai)", "ai", "ans", "print(ai)", "print", "ai", "print(\"Impossible\")", "print", "\"Impossible\"", "def li_(): return map(lambda x: int(x)-1, stdin.readline().split())", "def li_(): return map(lambda x: int(x)-1, stdin.readline().split())", "li_", "bef = [j+1 for j in range(i)]", "[j+1 for j in range(i)]", "bef", "stdin = sys.stdin", "sys.stdin", "stdin", "def lf(): return map(float, stdin.readline().split())", "def lf(): return map(float, stdin.readline().split())", "lf", "def nf(): return float(stdin.readline())", "def nf(): return float(stdin.readline())", "nf", "def ls(): return stdin.readline().split()", "def ls(): return stdin.readline().split()", "ls", "exist = True", "True", "exist", "exist = False", "False", "exist", "a = list(li())", "list(li())", "a", "def lc(): return list(ns())", "def lc(): return list(ns())", "lc", "aft = [j+1 for j in range(n-2,i,-1)]", "[j+1 for j in range(n-2,i,-1)]", "aft", "l = li()", "li()", "l", "ans = bef + aft + [i+1]", "bef + aft + [i+1]", "ans", "def ns(): return stdin.readline().rstrip()", "def ns(): return stdin.readline().rstrip()", "ns", "n,l = li()", "li()", "n", "def li(): return map(int, stdin.readline().split())", "def li(): return map(int, stdin.readline().split())", "li", "def ni(): return int(stdin.readline())", "def ni(): return int(stdin.readline())", "ni" ]

[ 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, 2, 39, 17, 2, 13, 17, 28, 13, 13, 4, 13, 13, 0, 13, 39, 0, 13, 17, 0, 13, 2, 13, 17, 42, 2, 13, 13, 14, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 4, 13, 17, 3, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 2, 18, 13, 13, 18, 13, 2, 13, 17, 4, 18, 13, 13, 2, 13, 17, 0, 13, 17, 4, 18, 13, 13, 13, 0, 13, 17, 4, 13, 17, 28, 13, 13, 10, 17, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 39, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 134, 2 ], [ 134, 11 ], [ 15, 13 ], [ 125, 24 ], [ 135, 29 ], [ 128, 38 ], [ 119, 41 ], [ 116, 44 ], [ 135, 46 ], [ 120, 50 ], [ 114, 50 ], [ 117, 51 ], [ 132, 51 ], [ 126, 56 ], [ 117, 58 ], [ 132, 58 ], [ 126, 61 ], [ 120, 62 ], [ 114, 62 ], [ 123, 63 ], [ 120, 73 ], [ 114, 73 ], [ 120, 77 ], [ 114, 77 ], [ 117, 82 ], [ 132, 82 ], [ 117, 86 ], [ 132, 86 ], [ 129, 90 ], [ 120, 93 ], [ 114, 93 ], [ 113, 96 ], [ 129, 100 ], [ 117, 102 ], [ 132, 102 ], [ 131, 104 ], [ 111, 110 ], [ 129, 110 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 134, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ], [ 134, 135 ] ]

[ "N,L = map(int,input().split())\n*A, = map(int,input().split())\n\nS = [0]*(N+1)\nfor i,a in enumerate(A): S[i+1] = S[i] + a\nans = []\ni=0\nj=N-1\nwhile i<j:\n if S[j+1]-S[i] < L:\n print(\"Impossible\")\n break\n if A[i]+A[i+1] <= A[j]+A[j-1]:\n ans.append(i+1)\n i+=1\n else:\n ans.append(j)\n j-=1\nelse:\n print(\"Possible\")\n for a in ans: print(a)", "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", "S = [0]*(N+1)", "S", "[0]*(N+1)", "[0]", "0", "N+1", "N", "1", "for i,a in enumerate(A): S[i+1] = S[i] + a", "i", "a", "enumerate(A)", "enumerate", "A", "ans = []", "ans", "[]", "i=0", "i", "0", "j=N-1", "j", "N-1", "N", "1", "while i<j:\n if S[j+1]-S[i] < L:\n print(\"Impossible\")\n break\n if A[i]+A[i+1] <= A[j]+A[j-1]:\n ans.append(i+1)\n i+=1\n else:\n ans.append(j)\n j-=1\nelse:\n print(\"Possible\")\n for a in ans: print(a)", "i<j", "i", "j", "if S[j+1]-S[i] < L:\n print(\"Impossible\")\n break\n ", "S[j+1]-S[i] < L", "S[j+1]-S[i]", "S[j+1]", "S", "j+1", "j", "1", "S[i]", "S", "i", "L", "print(\"Impossible\")", "print", "\"Impossible\"", "break", "if A[i]+A[i+1] <= A[j]+A[j-1]:\n ans.append(i+1)\n i+=1\n else:\n ans.append(j)\n j-=1", "A[i]+A[i+1] <= A[j]+A[j-1]", "A[i]+A[i+1]", "A[i]", "A", "i", "A[i+1]", "A", "i+1", "i", "1", "A[j]+A[j-1]", "A[j]", "A", "j", "A[j-1]", "A", "j-1", "j", "1", "ans.append(i+1)", "ans.append", "ans", "append", "i+1", "i", "1", "i+=1", "i", "1", "ans.append(j)", "ans.append", "ans", "append", "j", "j-=1", "j", "1", "print(\"Possible\")", "print", "\"Possible\"", "for a in ans: print(a)", "a", "ans", "i+=1", "1", "i", "j=N-1", "N-1", "j", "i=0", "0", "i", "L = map(int,input().split())", "map(int,input().split())", "L", "S = [0]*(N+1)", "[0]*(N+1)", "S", "ans = []", "[]", "ans", "j-=1", "1", "j", "N,L = map(int,input().split())", "map(int,input().split())", "N" ]

[ 7, 15, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 39, 39, 17, 17, 39, 17, 17, 39, 17, 17, 39, 17, 17, 12, 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, 13, 13, 4, 4, 13, 12, 13, 23, 13, 12, 13, 42, 40, 2, 13, 13, 17, 0, 13, 13, 13, 2, 13, 13, 29, 13, 23, 13, 23, 13, 12, 13, 29, 2, 2, 13, 13, 4, 13, 13, 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, 17, 0, 13, 2, 13, 17, 3, 14, 2, 13, 17, 4, 13, 13, 4, 13, 13, 28, 13, 4, 13, 17, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 13, 17, 4, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 39, 13, 10, 12, 13 ]

[ [ 187, 6 ], [ 202, 13 ], [ 32, 31 ], [ 31, 44 ], [ 52, 51 ], [ 200, 57 ], [ 61, 61 ], [ 80, 67 ], [ 71, 67 ], [ 82, 68 ], [ 73, 68 ], [ 72, 71 ], [ 82, 72 ], [ 73, 72 ], [ 74, 73 ], [ 71, 75 ], [ 80, 75 ], [ 82, 76 ], [ 73, 76 ], [ 73, 78 ], [ 82, 78 ], [ 80, 80 ], [ 82, 82 ], [ 95, 88 ], [ 97, 89 ], [ 194, 91 ], [ 95, 92 ], [ 97, 93 ], [ 95, 95 ], [ 97, 97 ], [ 102, 101 ], [ 182, 103 ], [ 102, 104 ], [ 107, 106 ], [ 182, 108 ], [ 111, 110 ], [ 114, 113 ], [ 101, 117 ], [ 106, 123 ], [ 113, 124 ], [ 106, 126 ], [ 113, 128 ], [ 104, 130 ], [ 133, 132 ], [ 136, 135 ], [ 113, 137 ], [ 132, 142 ], [ 110, 142 ], [ 132, 146 ], [ 110, 146 ], [ 132, 149 ], [ 110, 149 ], [ 152, 151 ], [ 135, 155 ], [ 151, 158 ], [ 161, 160 ], [ 101, 164 ], [ 135, 166 ], [ 160, 170 ], [ 135, 173 ], [ 185, 179 ], [ 187, 188 ], [ 202, 203 ] ]

[ "import sys,bisect,heapq\n\nmod = 10**9+7\ndd = ((-1, 0), (0, -1), (1, 0), (0, 1))\n\ndef I(): return(int(sys.stdin.readline()))\ndef LI(): return([int(x) for x in sys.stdin.readline().split()])\ndef S(): return(input())\ndef IR(n): return([I() for _ in range(n)])\n\ndef GCD(a,b):\n while(a%b != 0):\n a,b = b,a%b\n return b\n\ndef LCM(a,b):\n return a*b//GCD(a,b)\n\ndef main():\n N,L = LI()\n A = LI()\n ans = \"Impossible\"\n\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n ans = \"Possible\"\n last = i+1\n break\n\n if ans == \"Impossible\":\n print(ans)\n else:\n print(ans)\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)\n\n\n\n\n\n\n\n \n\nif __name__ == \"__main__\":\n main()", "import sys,bisect,heapq", "sys", "bisect", "heapq", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "dd = ((-1, 0), (0, -1), (1, 0), (0, 1))", "dd", "((-1, 0), (0, -1), (1, 0), (0, 1))", "(-1, 0)", "-1", "0", "(0, -1)", "0", "-1", "(1, 0)", "1", "0", "(0, 1)", "0", "1", "def I(): return(int(sys.stdin.readline()))", "I", "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 S(): return(input())", "S", "I() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "I()", "I", "def IR(n): return([I() for _ in range(n)])", "IR", "n", "n", "def GCD(a,b):\n while(a%b != 0):\n a,b = b,a%b\n return b", "GCD", "while(a%b != 0):\n a,b = b,a%b\n ", "a%b != 0", "a%b", "a", "b", "0", "a,b = b,a%b", "a", "b", "b", "a%b", "a", "b", "return b", "b", "a", "a", "b", "b", "def LCM(a,b):\n return a*b//GCD(a,b)", "LCM", "return a*b//GCD(a,b)", "a*b//GCD(a,b)", "a*b", "a", "b", "GCD(a,b)", "GCD", "a", "b", "a", "a", "b", "b", "def main():\n N,L = LI()\n A = LI()\n ans = \"Impossible\"\n\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n ans = \"Possible\"\n last = i+1\n break\n\n if ans == \"Impossible\":\n print(ans)\n else:\n print(ans)\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)\n\n\n\n\n\n\n\n ", "main", "N,L = LI()", "N", "LI()", "LI", "L", "A = LI()", "A", "LI()", "LI", "ans = \"Impossible\"", "ans", "\"Impossible\"", "for i in range(N-1):\n if A[i]+A[i+1] >= L:\n ans = \"Possible\"\n last = i+1\n break\n\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i]+A[i+1] >= L:\n ans = \"Possible\"\n last = i+1\n break\n\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\"", "last = i+1", "last", "i+1", "i", "1", "break", "if ans == \"Impossible\":\n print(ans)\n else:\n print(ans)\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)\n\n\n\n\n\n\n\n ", "ans == \"Impossible\"", "ans", "\"Impossible\"", "print(ans)", "print", "ans", "print(ans)", "print", "ans", "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", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "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 main():\n N,L = LI()\n A = LI()\n ans = \"Impossible\"\n\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n ans = \"Possible\"\n last = i+1\n break\n\n if ans == \"Impossible\":\n print(ans)\n else:\n print(ans)\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)\n\n\n\n\n\n\n\n ", "def main():\n N,L = LI()\n A = LI()\n ans = \"Impossible\"\n\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n ans = \"Possible\"\n last = i+1\n break\n\n if ans == \"Impossible\":\n print(ans)\n else:\n print(ans)\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)\n\n\n\n\n\n\n\n ", "main", "mod = 10**9+7", "10**9+7", "mod", "def S(): return(input())", "def S(): return(input())", "S", "def GCD(a,b):\n while(a%b != 0):\n a,b = b,a%b\n return b", "def GCD(a,b):\n while(a%b != 0):\n a,b = b,a%b\n return b", "GCD", "def LCM(a,b):\n return a*b//GCD(a,b)", "def LCM(a,b):\n return a*b//GCD(a,b)", "LCM", "def I(): return(int(sys.stdin.readline()))", "def I(): return(int(sys.stdin.readline()))", "I", "dd = ((-1, 0), (0, -1), (1, 0), (0, 1))", "((-1, 0), (0, -1), (1, 0), (0, 1))", "dd", "def IR(n): return([I() for _ in range(n)])", "def IR(n): return([I() for _ in range(n)])", "IR" ]

[ 7, 0, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 13, 13, 4, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 4, 18, 4, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 4, 13, 18, 13, 13, 12, 13, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 29, 13, 29, 17, 0, 13, 4, 13, 14, 2, 13, 17, 4, 13, 17, 4, 13, 17, 28, 13, 4, 13, 17, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 4, 13, 2, 13, 2, 13, 13, 4, 13, 2, 13, 17, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 139, 2 ], [ 139, 8 ], [ 121, 10 ], [ 140, 13 ], [ 130, 14 ], [ 125, 17 ], [ 127, 19 ], [ 122, 23 ], [ 140, 23 ], [ 136, 25 ], [ 33, 32 ], [ 122, 35 ], [ 140, 35 ], [ 40, 37 ], [ 128, 38 ], [ 32, 39 ], [ 137, 43 ], [ 32, 44 ], [ 49, 48 ], [ 122, 52 ], [ 140, 52 ], [ 37, 57 ], [ 128, 58 ], [ 48, 59 ], [ 128, 61 ], [ 48, 63 ], [ 131, 65 ], [ 125, 65 ], [ 48, 67 ], [ 133, 71 ], [ 119, 73 ], [ 134, 76 ], [ 86, 85 ], [ 134, 89 ], [ 85, 93 ], [ 97, 96 ], [ 134, 100 ], [ 122, 103 ], [ 140, 103 ], [ 122, 108 ], [ 140, 108 ], [ 96, 110 ], [ 134, 111 ], [ 134, 115 ], [ 121, 122 ], [ 139, 125 ], [ 127, 128 ], [ 130, 131 ], [ 133, 134 ], [ 136, 137 ], [ 139, 140 ] ]

[ "N, L = input().split()\nN, L = int(N), int(L)\n\na = [0]*N\n\ninputStr = input().split()\nfor i in range(N):\n a[i] = int(inputStr[i])\n\ndef check():\n for i in range(N-1):\n if(a[i]+a[i+1]>=L):\n return i\n return -1\n\nb = check()\n\nif(b==-1):\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(0,b):\n print(i+1)\n for i in range(b+1,N-1):\n print(N - (i-b))\n print(b+1)\n\n", "N, L = input().split()", "N", "input().split()", "().split", "()", "input", "split", "L", "N, L = int(N), int(L)", "N", "int(N)", "int", "N", "L", "int(L)", "int", "L", "a = [0]*N", "a", "[0]*N", "[0]", "0", "N", "inputStr = input().split()", "inputStr", "input().split()", "().split", "()", "input", "split", "for i in range(N):\n a[i] = int(inputStr[i])", "i", "range(N)", "range", "N", "a[i] = int(inputStr[i])", "a[i]", "a", "i", "int(inputStr[i])", "int", "inputStr[i]", "inputStr", "i", "def check():\n for i in range(N-1):\n if(a[i]+a[i+1]>=L):\n return i\n return -1", "check", "for i in range(N-1):\n if(a[i]+a[i+1]>=L):\n return i\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if(a[i]+a[i+1]>=L):\n return i\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", "return i", "i", "return -1", "-1", "b = check()", "b", "check()", "check", "if(b==-1):\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(0,b):\n print(i+1)\n for i in range(b+1,N-1):\n print(N - (i-b))\n print(b+1)", "b==-1", "b", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(0,b):\n print(i+1)\n ", "i", "range(0,b)", "range", "0", "b", "print(i+1)", "print", "i+1", "i", "1", "for i in range(b+1,N-1):\n print(N - (i-b))\n ", "i", "range(b+1,N-1)", "range", "b+1", "b", "1", "N-1", "N", "1", "print(N - (i-b))", "print", "N - (i-b)", "N", "i-b", "i", "b", "print(b+1)", "print", "b+1", "b", "1", "def check():\n for i in range(N-1):\n if(a[i]+a[i+1]>=L):\n return i\n return -1", "def check():\n for i in range(N-1):\n if(a[i]+a[i+1]>=L):\n return i\n return -1", "check", "N, L = int(N), int(L)", "int(N)", "N", "L = input().split()", "input().split()", "L", "a = [0]*N", "[0]*N", "a", "L = int(N), int(L)", "int(L)", "L", "b = check()", "check()", "b", "inputStr = input().split()", "input().split()", "inputStr", "N, L = input().split()", "input().split()", "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, 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, 13, 4, 13, 2, 2, 13, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13 ]

[ [ 92, 2 ], [ 92, 11 ], [ 89, 13 ], [ 98, 25 ], [ 29, 28 ], [ 93, 32 ], [ 90, 38 ], [ 28, 39 ], [ 90, 41 ], [ 28, 43 ], [ 87, 45 ], [ 95, 47 ], [ 28, 49 ], [ 96, 54 ], [ 99, 54 ], [ 64, 63 ], [ 96, 67 ], [ 99, 67 ], [ 63, 70 ], [ 73, 72 ], [ 93, 76 ], [ 96, 77 ], [ 99, 77 ], [ 93, 82 ], [ 72, 83 ], [ 92, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ] ]

[ "n,l = map(int, input().split())\na = list(map(int, input().split()))\n\nx = -1\n\nfor i in range(n-1):\n if a[i]+a[i+1] >= l:\n x = i+1\n break\n\nif x == -1:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,x):\n print(i)\n for i in range(n-x):\n print(n-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(n-1):\n if a[i]+a[i+1] >= l:\n x = i+1\n break", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1] >= l:\n x = 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", "x = i+1", "x", "i+1", "i", "1", "break", "if x == -1:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,x):\n print(i)\n for i in range(n-x):\n print(n-i-1)", "x == -1", "x", "-1", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "for i in range(1,x):\n print(i)\n ", "i", "range(1,x)", "range", "1", "x", "print(i)", "print", "i", "for i in range(n-x):\n print(n-i-1)", "i", "range(n-x)", "range", "n-x", "n", "x", "print(n-i-1)", "print", "n-i-1", "n-i", "n", "i", "1", "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", "x = i+1", "i+1", "x", "x = -1", "-1", "x" ]

[ 7, 15, 13, 15, 13, 15, 15, 15, 0, 13, 18, 18, 13, 13, 13, 4, 18, 13, 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, 4, 13, 17, 0, 13, 13, 3, 4, 13, 17, 29, 28, 13, 4, 13, 13, 4, 13, 2, 13, 17, 28, 13, 18, 4, 13, 13, 2, 13, 17, 39, 17, 4, 13, 2, 13, 17, 4, 13, 10, 12, 13, 10, 2, 13, 10, 18, 13 ]

[ [ 122, 9 ], [ 119, 23 ], [ 33, 32 ], [ 123, 39 ], [ 33, 41 ], [ 44, 43 ], [ 123, 52 ], [ 56, 55 ], [ 59, 58 ], [ 32, 62 ], [ 43, 68 ], [ 58, 69 ], [ 43, 71 ], [ 58, 73 ], [ 41, 75 ], [ 81, 80 ], [ 58, 81 ], [ 89, 88 ], [ 80, 91 ], [ 55, 91 ], [ 88, 95 ], [ 99, 98 ], [ 80, 102 ], [ 55, 102 ], [ 32, 104 ], [ 98, 111 ], [ 117, 114 ], [ 119, 120 ], [ 122, 123 ] ]

[ "import sys\nimport heapq\nfrom operator import itemgetter\nfrom collections import deque, defaultdict\nfrom bisect import bisect_left, bisect_right\ninput = sys.stdin.readline\nsys.setrecursionlimit(10 ** 7)\nMOD = 10**9 + 7\n\ndef sol():\n N, L = map(int, input().split())\n A = list(map(int, input().split()))\n\n left = 0\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n print('Possible')\n left = i\n break\n else:\n print('Impossible')\n return\n\n for i in range(left):\n print(i + 1)\n for j in range(left, N - 1)[:: -1]:\n print(j + 1)\n\n\nsol()", "import sys", "sys", "import heapq", "heapq", "from operator import itemgetter", "from collections import deque, defaultdict", "from bisect import bisect_left, bisect_right", "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", "MOD = 10**9 + 7", "MOD", "10**9 + 7", "10**9", "10", "9", "7", "def sol():\n N, L = map(int, input().split())\n A = list(map(int, input().split()))\n\n left = 0\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n print('Possible')\n left = i\n break\n else:\n print('Impossible')\n return\n\n for i in range(left):\n print(i + 1)\n for j in range(left, N - 1)[:: -1]:\n print(j + 1)", "sol", "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", "left = 0", "left", "0", "for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n print('Possible')\n left = 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 print('Possible')\n left = 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", "print('Possible')", "print", "'Possible'", "left = i", "left", "i", "break", "print('Impossible')", "print", "'Impossible'", "return", "for i in range(left):\n print(i + 1)\n ", "i", "range(left)", "range", "left", "print(i + 1)", "print", "i + 1", "i", "1", "for j in range(left, N - 1)[:: -1]:\n print(j + 1)", "j", "range(left, N - 1)[:: -1]", "(left, N - 1)", "range", "left", "N - 1", "N", "1", ":: -1", "-1", "print(j + 1)", "print", "j + 1", "j", "1", "sol()", "sol", "def sol():\n N, L = map(int, input().split())\n A = list(map(int, input().split()))\n\n left = 0\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n print('Possible')\n left = i\n break\n else:\n print('Impossible')\n return\n\n for i in range(left):\n print(i + 1)\n for j in range(left, N - 1)[:: -1]:\n print(j + 1)", "def sol():\n N, L = map(int, input().split())\n A = list(map(int, input().split()))\n\n left = 0\n for i in range(N - 1):\n if A[i] + A[i + 1] >= L:\n print('Possible')\n left = i\n break\n else:\n print('Impossible')\n return\n\n for i in range(left):\n print(i + 1)\n for j in range(left, N - 1)[:: -1]:\n print(j + 1)", "sol", "MOD = 10**9 + 7", "10**9 + 7", "MOD", "input = sys.stdin.readline", "sys.stdin.readline", "input" ]

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 15, 15, 12, 13, 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, 13, 3, 14, 13, 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, 2, 13, 17, 17, 4, 13, 13, 4, 13, 2, 13, 17, 10, 12, 13, 10, 13, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 12, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 113, 23 ], [ 108, 25 ], [ 113, 26 ], [ 122, 28 ], [ 102, 30 ], [ 116, 32 ], [ 36, 35 ], [ 111, 39 ], [ 123, 45 ], [ 35, 46 ], [ 123, 48 ], [ 35, 50 ], [ 114, 52 ], [ 125, 54 ], [ 104, 57 ], [ 35, 58 ], [ 72, 71 ], [ 105, 76 ], [ 71, 80 ], [ 83, 82 ], [ 111, 86 ], [ 105, 89 ], [ 82, 94 ], [ 105, 98 ], [ 35, 104 ], [ 104, 105 ], [ 113, 111 ], [ 113, 114 ], [ 116, 117 ], [ 122, 123 ], [ 125, 126 ] ]

[ "import sys\nimport heapq\nimport math\nimport fractions\nimport bisect\nimport itertools\nfrom collections import Counter\nfrom collections import deque\nfrom operator import itemgetter\ndef input(): return sys.stdin.readline().strip()\ndef mp(): return map(int,input().split())\ndef lmp(): return list(map(int,input().split()))\n\nn,l=mp()\na=lmp()\nc=True\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n c=False\n ind=i\n break\nif c:\n print(\"Impossible\")\n exit()\nprint(\"Possible\")\nfor i in range(1,ind+1):\n print(i)\nfor i in range(n-1,ind+1,-1):\n print(i)\nprint(ind+1)", "import sys", "sys", "import heapq", "heapq", "import math", "math", "import fractions", "fractions", "import bisect", "bisect", "import itertools", "itertools", "from collections import Counter", "from collections import deque", "from operator import itemgetter", "def input(): return sys.stdin.readline().strip()", "input", "def mp(): return map(int,input().split())", "mp", "def lmp(): return list(map(int,input().split()))", "lmp", "n,l=mp()", "n", "mp()", "mp", "l", "a=lmp()", "a", "lmp()", "lmp", "c=True", "c", "True", "for i in range(n-1):\n if a[i]+a[i+1]>=l:\n c=False\n ind=i\n break", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n c=False\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", "c=False", "c", "False", "ind=i", "ind", "i", "break", "if c:\n print(\"Impossible\")\n exit()", "c", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,ind+1):\n print(i)", "i", "range(1,ind+1)", "range", "1", "ind+1", "ind", "1", "print(i)", "print", "i", "for i in range(n-1,ind+1,-1):\n print(i)", "i", "range(n-1,ind+1,-1)", "range", "n-1", "n", "1", "ind+1", "ind", "1", "-1", "print(i)", "print", "i", "print(ind+1)", "print", "ind+1", "ind", "1", "def lmp(): return list(map(int,input().split()))", "def lmp(): return list(map(int,input().split()))", "lmp", "ind=i", "i", "ind", "def mp(): return map(int,input().split())", "def mp(): return map(int,input().split())", "mp", "n,l=mp()", "mp()", "n", "l=mp()", "mp()", "l", "c=True", "True", "c", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "a=lmp()", "lmp()", "a", "c=False", "False", "c" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 17, 13, 13, 13, 31, 13, 0, 13, 39, 28, 13, 4, 13, 17, 13, 14, 2, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 4, 18, 13, 13, 13, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 17, 4, 18, 13, 13, 13, 4, 13, 17, 4, 13, 31, 13, 0, 13, 17, 4, 13, 4, 13, 17, 10, 4, 13, 10, 39, 13, 10, 4, 13 ]

[ [ 82, 2 ], [ 82, 15 ], [ 82, 16 ], [ 79, 19 ], [ 23, 22 ], [ 83, 26 ], [ 22, 32 ], [ 22, 36 ], [ 77, 38 ], [ 80, 41 ], [ 22, 43 ], [ 46, 45 ], [ 83, 49 ], [ 22, 52 ], [ 80, 57 ], [ 45, 59 ], [ 80, 66 ], [ 69, 68 ], [ 82, 77 ], [ 79, 80 ], [ 82, 83 ] ]

[ "n,l,*a=map(int,open(0).read().split())\nans=[] \nfor i in range(1,n):\n if a[i]+a[i-1]<l:\n ans.append(i)\n else:\n for j in range(n-1,i-1,-1):\n ans.append(j)\n print(\"Possible\")\n print(*ans,sep=\"\\n\")\n exit()\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", "ans=[]", "ans", "[]", "for i in range(1,n):\n if a[i]+a[i-1]<l:\n ans.append(i)\n else:\n for j in range(n-1,i-1,-1):\n ans.append(j)\n print(\"Possible\")\n print(*ans,sep=\"\\n\")\n exit()", "i", "range(1,n)", "range", "1", "n", "if a[i]+a[i-1]<l:\n ans.append(i)\n else:\n for j in range(n-1,i-1,-1):\n ans.append(j)\n print(\"Possible\")\n print(*ans,sep=\"\\n\")\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", "ans.append(i)", "ans.append", "ans", "append", "i", "for j in range(n-1,i-1,-1):\n ans.append(j)\n ", "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", "print(\"Possible\")", "print", "\"Possible\"", "print(*ans,sep=\"\\n\")", "print", "*ans", "ans", "sep=\"\\n\"", "sep", "\"\\n\"", "exit()", "exit", "print(\"Impossible\")", "print", "\"Impossible\"", "l,*a=map(int,open(0).read().split())", "map(int,open(0).read().split())", "l", "ans=[]", "[]", "ans", "n,l,*a=map(int,open(0).read().split())", "map(int,open(0).read().split())", "n" ]

[ 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, 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, 31, 13, 0, 13, 17, 4, 13, 4, 13, 17, 10, 4, 13, 10, 39, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 100, 2 ], [ 100, 11 ], [ 15, 14 ], [ 14, 23 ], [ 103, 25 ], [ 29, 28 ], [ 101, 32 ], [ 104, 37 ], [ 28, 39 ], [ 104, 42 ], [ 28, 43 ], [ 95, 44 ], [ 97, 49 ], [ 53, 52 ], [ 28, 56 ], [ 98, 59 ], [ 52, 61 ], [ 64, 63 ], [ 101, 67 ], [ 28, 69 ], [ 98, 73 ], [ 63, 75 ], [ 98, 78 ], [ 28, 80 ], [ 98, 84 ], [ 87, 86 ], [ 100, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ] ]

[ "N, L = map(int, input().split())\nA = [int(i) for i in input().split()]\n\nfor i in range(1, N):\n if A[i-1]+A[i] >= L:\n print('Possible')\n ans = []\n for j in range(1, i):\n ans.append(j)\n for k in range(N-1, i, -1):\n ans.append(k)\n ans.append(i)\n print(*ans, sep='\\n')\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(1, N):\n if A[i-1]+A[i] >= L:\n print('Possible')\n ans = []\n for j in range(1, i):\n ans.append(j)\n for k in range(N-1, i, -1):\n ans.append(k)\n ans.append(i)\n print(*ans, sep='\\n')\n exit()", "i", "range(1, N)", "range", "1", "N", "if A[i-1]+A[i] >= L:\n print('Possible')\n ans = []\n for j in range(1, i):\n ans.append(j)\n for k in range(N-1, i, -1):\n ans.append(k)\n ans.append(i)\n print(*ans, sep='\\n')\n exit()", "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'", "ans = []", "ans", "[]", "for j in range(1, i):\n ans.append(j)\n ", "j", "range(1, i)", "range", "1", "i", "ans.append(j)", "ans.append", "ans", "append", "j", "for k in range(N-1, i, -1):\n ans.append(k)\n ", "k", "range(N-1, i, -1)", "range", "N-1", "N", "1", "i", "-1", "ans.append(k)", "ans.append", "ans", "append", "k", "ans.append(i)", "ans.append", "ans", "append", "i", "print(*ans, sep='\\n')", "print", "*ans", "ans", "sep='\\n'", "sep", "'\\n'", "exit()", "exit", "print('Impossible')", "print", "'Impossible'", "L = map(int, input().split())", "map(int, input().split())", "L", "ans = []", "[]", "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" ]

[ 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, 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, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13 ]

[ [ 94, 4 ], [ 94, 13 ], [ 17, 16 ], [ 16, 25 ], [ 100, 27 ], [ 97, 30 ], [ 34, 33 ], [ 95, 37 ], [ 101, 43 ], [ 33, 44 ], [ 101, 46 ], [ 33, 48 ], [ 92, 50 ], [ 88, 52 ], [ 33, 53 ], [ 89, 57 ], [ 98, 57 ], [ 67, 66 ], [ 89, 69 ], [ 98, 69 ], [ 66, 73 ], [ 77, 76 ], [ 95, 80 ], [ 89, 82 ], [ 98, 82 ], [ 76, 86 ], [ 33, 88 ], [ 88, 89 ], [ 94, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ] ]

[ "import sys\nn, l = map(int, input().split())\na = [int(x) for x in input().split()]\n\nkey = -1\nfor i in range(n-1):\n if a[i]+a[i+1] >= l:\n key = i\n break\n\nif key == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(key):\n print(i+1)\n for i in range(n-1, key, -1):\n print(i)", "import sys", "sys", "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()]", "key = -1", "key", "-1", "for i in range(n-1):\n if a[i]+a[i+1] >= l:\n key = i\n break", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1] >= l:\n key = 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", "key = i", "key", "i", "break", "if key == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(key):\n print(i+1)\n for i in range(n-1, key, -1):\n print(i)", "key == -1", "key", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(key):\n print(i+1)\n ", "i", "range(key)", "range", "key", "print(i+1)", "print", "i+1", "i", "1", "for i in range(n-1, key, -1):\n print(i)", "i", "range(n-1, key, -1)", "range", "n-1", "n", "1", "key", "-1", "print(i)", "print", "i", "key = i", "i", "key", "l = map(int, input().split())", "map(int, input().split())", "l", "n, l = map(int, input().split())", "map(int, input().split())", "n", "key = -1", "-1", "key", "a = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "a" ]

[ 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, 0, 13, 39, 28, 13, 4, 13, 17, 2, 4, 13, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 17, 4, 13, 17, 4, 18, 13, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 13, 4, 18, 13, 13, 13, 28, 13, 4, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 13, 3, 14, 2, 13, 17, 4, 13, 17, 28, 13, 4, 13, 13, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13 ]

[ [ 124, 4 ], [ 124, 13 ], [ 121, 15 ], [ 118, 27 ], [ 127, 30 ], [ 34, 33 ], [ 125, 40 ], [ 122, 46 ], [ 33, 47 ], [ 122, 49 ], [ 33, 51 ], [ 113, 53 ], [ 115, 55 ], [ 128, 62 ], [ 33, 65 ], [ 69, 68 ], [ 33, 72 ], [ 125, 74 ], [ 128, 77 ], [ 68, 79 ], [ 82, 81 ], [ 33, 88 ], [ 128, 92 ], [ 81, 94 ], [ 116, 98 ], [ 119, 98 ], [ 105, 104 ], [ 128, 107 ], [ 104, 110 ], [ 124, 113 ], [ 115, 116 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ], [ 127, 128 ] ]

[ "import numpy as np\n\nn, l = map(int, input().split())\nknot = list(map(int, input().split()))\n\nflg = 0\nli = []\nfor i in range(0, int(n) - 1):\n if(knot[i] + knot[i + 1] >= l):\n flg = 1\n print(\"Possible\")\n li.append(i + 1)\n\n for j in range(i + 2, n):\n li.append(j)\n for j in reversed(range(1, i + 1)):\n li.append(j)\n break\n\nif flg == 0:\n print(\"Impossible\")\n\nfor i in reversed(li):\n print(i)", "import numpy as np", "numpy", "n, l = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "knot = list(map(int, input().split()))", "knot", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "flg = 0", "flg", "0", "li = []", "li", "[]", "for i in range(0, int(n) - 1):\n if(knot[i] + knot[i + 1] >= l):\n flg = 1\n print(\"Possible\")\n li.append(i + 1)\n\n for j in range(i + 2, n):\n li.append(j)\n for j in reversed(range(1, i + 1)):\n li.append(j)\n break", "i", "range(0, int(n) - 1)", "range", "0", "int(n) - 1", "int(n)", "int", "n", "1", "if(knot[i] + knot[i + 1] >= l):\n flg = 1\n print(\"Possible\")\n li.append(i + 1)\n\n for j in range(i + 2, n):\n li.append(j)\n for j in reversed(range(1, i + 1)):\n li.append(j)\n break", "knot[i] + knot[i + 1] >= l", "knot[i] + knot[i + 1]", "knot[i]", "knot", "i", "knot[i + 1]", "knot", "i + 1", "i", "1", "l", "flg = 1", "flg", "1", "print(\"Possible\")", "print", "\"Possible\"", "li.append(i + 1)", "li.append", "li", "append", "i + 1", "i", "1", "for j in range(i + 2, n):\n li.append(j)\n ", "j", "range(i + 2, n)", "range", "i + 2", "i", "2", "n", "li.append(j)", "li.append", "li", "append", "j", "for j in reversed(range(1, i + 1)):\n li.append(j)\n ", "j", "reversed(range(1, i + 1))", "reversed", "range(1, i + 1)", "range", "1", "i + 1", "i", "1", "li.append(j)", "li.append", "li", "append", "j", "break", "if flg == 0:\n print(\"Impossible\")", "flg == 0", "flg", "0", "print(\"Impossible\")", "print", "\"Impossible\"", "for i in reversed(li):\n print(i)", "i", "reversed(li)", "reversed", "li", "print(i)", "print", "i", "l = map(int, input().split())", "map(int, input().split())", "l", "flg = 1", "1", "flg", "flg = 0", "0", "flg", "knot = list(map(int, input().split()))", "list(map(int, input().split()))", "knot", "n, l = map(int, input().split())", "map(int, input().split())", "n", "li = []", "[]", "li" ]

[ 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, 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, 14, 2, 4, 13, 13, 13, 4, 13, 17, 4, 13, 17, 0, 13, 4, 18, 13, 13, 4, 13, 13, 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, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 109, 2 ], [ 109, 11 ], [ 103, 13 ], [ 100, 25 ], [ 98, 30 ], [ 34, 33 ], [ 98, 37 ], [ 43, 40 ], [ 101, 41 ], [ 33, 42 ], [ 104, 45 ], [ 33, 46 ], [ 104, 48 ], [ 33, 50 ], [ 101, 56 ], [ 110, 57 ], [ 106, 65 ], [ 101, 68 ], [ 101, 72 ], [ 75, 74 ], [ 107, 79 ], [ 74, 83 ], [ 86, 85 ], [ 98, 89 ], [ 107, 91 ], [ 85, 95 ], [ 109, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ] ]

[ "n,l=map(int,input().split())\na=list(map(int,input().split()))\nmu=[0]*(n-1)\nfor i in range(n-1):\n mu[i]=a[i]+a[i+1]\nif max(mu)<l:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n s=mu.index(max(mu))\n for i in range(1,s+1):\n print(i)\n for i in range(n-1,s,-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", "mu=[0]*(n-1)", "mu", "[0]*(n-1)", "[0]", "0", "n-1", "n", "1", "for i in range(n-1):\n mu[i]=a[i]+a[i+1]", "i", "range(n-1)", "range", "n-1", "n", "1", "mu[i]=a[i]+a[i+1]", "mu[i]", "mu", "i", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "if max(mu)<l:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n s=mu.index(max(mu))\n for i in range(1,s+1):\n print(i)\n for i in range(n-1,s,-1):\n print(i)", "max(mu)<l", "max(mu)", "max", "mu", "l", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "s=mu.index(max(mu))", "s", "mu.index(max(mu))", "mu.index", "mu", "index", "max(mu)", "max", "mu", "for i in range(1,s+1):\n print(i)\n ", "i", "range(1,s+1)", "range", "1", "s+1", "s", "1", "print(i)", "print", "i", "for i in range(n-1,s,-1):\n print(i)", "i", "range(n-1,s,-1)", "range", "n-1", "n", "1", "s", "-1", "print(i)", "print", "i", "n,l=map(int,input().split())", "map(int,input().split())", "n", "mu=[0]*(n-1)", "[0]*(n-1)", "mu", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "s=mu.index(max(mu))", "mu.index(max(mu))", "s", "l=map(int,input().split())", "map(int,input().split())", "l" ]

[ 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, 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, 14, 2, 4, 13, 13, 13, 4, 13, 17, 4, 13, 17, 0, 13, 4, 18, 13, 13, 4, 13, 13, 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, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 115, 2 ], [ 115, 11 ], [ 112, 13 ], [ 109, 25 ], [ 116, 30 ], [ 34, 33 ], [ 116, 37 ], [ 43, 40 ], [ 110, 41 ], [ 33, 42 ], [ 113, 45 ], [ 33, 46 ], [ 113, 48 ], [ 33, 50 ], [ 110, 56 ], [ 107, 57 ], [ 118, 65 ], [ 110, 68 ], [ 110, 72 ], [ 75, 74 ], [ 119, 77 ], [ 74, 81 ], [ 85, 84 ], [ 119, 90 ], [ 116, 93 ], [ 84, 98 ], [ 119, 103 ], [ 115, 107 ], [ 109, 110 ], [ 112, 113 ], [ 115, 116 ], [ 118, 119 ] ]

[ "N, L = map(int, input().split())\na = list(map(int, input().split()))\n\nsum = [0]*(N - 1)\nfor i in range(N-1):\n sum[i] = a[i] + a[i+1]\n\nif max(sum) < L:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n id = sum.index(max(sum))\n for i in range(id):\n print(i+1)\n for i in reversed(range(id+1, N-1)):\n print(i+1)\n print(id+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", "sum = [0]*(N - 1)", "sum", "[0]*(N - 1)", "[0]", "0", "N - 1", "N", "1", "for i in range(N-1):\n sum[i] = a[i] + a[i+1]", "i", "range(N-1)", "range", "N-1", "N", "1", "sum[i] = a[i] + a[i+1]", "sum[i]", "sum", "i", "a[i] + a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "if max(sum) < L:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n id = sum.index(max(sum))\n for i in range(id):\n print(i+1)\n for i in reversed(range(id+1, N-1)):\n print(i+1)\n print(id+1)", "max(sum) < L", "max(sum)", "max", "sum", "L", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "id = sum.index(max(sum))", "id", "sum.index(max(sum))", "sum.index", "sum", "index", "max(sum)", "max", "sum", "for i in range(id):\n print(i+1)\n ", "i", "range(id)", "range", "id", "print(i+1)", "print", "i+1", "i", "1", "for i in reversed(range(id+1, N-1)):\n print(i+1)\n ", "i", "reversed(range(id+1, N-1))", "reversed", "range(id+1, N-1)", "range", "id+1", "id", "1", "N-1", "N", "1", "print(i+1)", "print", "i+1", "i", "1", "print(id+1)", "print", "id+1", "id", "1", "L = map(int, input().split())", "map(int, input().split())", "L", "sum = [0]*(N - 1)", "[0]*(N - 1)", "sum", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "N, L = map(int, input().split())", "map(int, input().split())", "N", "id = sum.index(max(sum))", "sum.index(max(sum))", "id" ]

[ 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, 41, 28, 13, 13, 4, 13, 18, 13, 39, 17, 4, 2, 13, 18, 13, 2, 13, 17, 0, 13, 13, 4, 18, 13, 13, 4, 13, 13, 14, 2, 4, 13, 13, 13, 4, 13, 17, 4, 13, 17, 0, 13, 4, 18, 13, 13, 4, 13, 13, 28, 13, 4, 13, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 17, 4, 13, 13, 4, 13, 2, 13, 17, 10, 13, 13, 10, 13, 13, 10, 4, 13, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 123, 14 ], [ 123, 16 ], [ 20, 19 ], [ 19, 28 ], [ 111, 30 ], [ 112, 39 ], [ 112, 46 ], [ 114, 51 ], [ 115, 55 ], [ 115, 59 ], [ 115, 64 ], [ 124, 65 ], [ 117, 73 ], [ 115, 76 ], [ 115, 80 ], [ 83, 82 ], [ 118, 85 ], [ 82, 89 ], [ 93, 92 ], [ 121, 96 ], [ 118, 99 ], [ 92, 104 ], [ 118, 108 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 123, 121 ], [ 123, 124 ] ]

[ "N,L = [int(x) for x in input().split()]\nA = [int(x) for x in input().split()]\n\nA2 = [x+A[ind+1] for ind,x in enumerate(A[:-1])]\nA2.index(max(A2))\nif(max(A2)<L):\n print('Impossible')\nelse:\n print('Possible')\n last = A2.index(max(A2))\n for i in range(last):\n print(i+1)\n for i in range(N-1,last+1,-1):\n print(i)\n print(last+1)", "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", "N,L = [int(x) for x in input().split()]", "N", "[int(x) for x in 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+A[ind+1] for ind,x in enumerate(A[:-1])", "for ind,x in enumerate(A[:-1])", "ind", "x", "enumerate(A[:-1])", "enumerate", "A[:-1]", "A", ":-1", "-1", "for ind,x in enumerate(A[:-1])", "x+A[ind+1]", "x", "A[ind+1]", "A", "ind+1", "ind", "1", "A2 = [x+A[ind+1] for ind,x in enumerate(A[:-1])]", "A2", "[x+A[ind+1] for ind,x in enumerate(A[:-1])]", "A2.index(max(A2))", "A2.index", "A2", "index", "max(A2)", "max", "A2", "if(max(A2)<L):\n print('Impossible')\nelse:\n print('Possible')\n last = A2.index(max(A2))\n for i in range(last):\n print(i+1)\n for i in range(N-1,last+1,-1):\n print(i)\n print(last+1)", "max(A2)<L", "max(A2)", "max", "A2", "L", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "last = A2.index(max(A2))", "last", "A2.index(max(A2))", "A2.index", "A2", "index", "max(A2)", "max", "A2", "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-1,last+1,-1):\n print(i)\n ", "i", "range(N-1,last+1,-1)", "range", "N-1", "N", "1", "last+1", "last", "1", "-1", "print(i)", "print", "i", "print(last+1)", "print", "last+1", "last", "1", "A = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "A", "A2 = [x+A[ind+1] for ind,x in enumerate(A[:-1])]", "[x+A[ind+1] for ind,x in enumerate(A[:-1])]", "A2", "last = A2.index(max(A2))", "A2.index(max(A2))", "last", "N,L = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "N", "L = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "L" ]

[ 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, 0, 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, 17, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 105, 2 ], [ 105, 11 ], [ 96, 13 ], [ 102, 25 ], [ 29, 28 ], [ 106, 32 ], [ 97, 38 ], [ 28, 39 ], [ 97, 41 ], [ 28, 43 ], [ 94, 45 ], [ 99, 47 ], [ 28, 48 ], [ 100, 52 ], [ 103, 52 ], [ 90, 63 ], [ 67, 66 ], [ 91, 70 ], [ 100, 70 ], [ 103, 70 ], [ 66, 73 ], [ 76, 75 ], [ 106, 79 ], [ 91, 81 ], [ 100, 81 ], [ 103, 81 ], [ 75, 85 ], [ 91, 88 ], [ 100, 88 ], [ 103, 88 ], [ 90, 91 ], [ 105, 94 ], [ 96, 97 ], [ 28, 99 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ] ]

[ "N, L = map(int, input().split())\n\nA = list(map(int, input().split()))\n\nans_index = -1\nfor i in range(N-1):\n if A[i] + A[i+1] >= L:\n ans_index = i\n break\n\nif ans_index == -1:\n print('Impossible')\n exit()\nprint('Possible')\n\nans_index += 1\nfor i in range(1, ans_index):\n print(i)\nfor i in range(N-1, ans_index, -1):\n print(i)\n\nprint(ans_index)", "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_index = -1", "ans_index", "-1", "for i in range(N-1):\n if A[i] + A[i+1] >= L:\n ans_index = i\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i] + A[i+1] >= L:\n ans_index = 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", "ans_index = i", "ans_index", "i", "break", "if ans_index == -1:\n print('Impossible')\n exit()", "ans_index == -1", "ans_index", "-1", "print('Impossible')", "print", "'Impossible'", "exit()", "exit", "print('Possible')", "print", "'Possible'", "ans_index += 1", "ans_index", "1", "for i in range(1, ans_index):\n print(i)", "i", "range(1, ans_index)", "range", "1", "ans_index", "print(i)", "print", "i", "for i in range(N-1, ans_index, -1):\n print(i)", "i", "range(N-1, ans_index, -1)", "range", "N-1", "N", "1", "ans_index", "-1", "print(i)", "print", "i", "print(ans_index)", "print", "ans_index", "ans_index += 1", "1", "ans_index", "L = map(int, input().split())", "map(int, input().split())", "L", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "ans_index = i", "i", "ans_index", "ans_index = -1", "-1", "ans_index", "N, L = map(int, input().split())", "map(int, input().split())", "N" ]