Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 145

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

[ [ 78, 2 ], [ 78, 11 ], [ 15, 13 ], [ 79, 42 ], [ 49, 48 ], [ 48, 54 ], [ 69, 68 ], [ 78, 76 ], [ 78, 79 ] ]

[ "N, L = map(int, input().split())\n*A, = map(int, input().split())\nfor i, (a1, a2) in enumerate(zip(A, A[1:])):\n if a1 + a2 >= L:\n print('Possible')\n print(*([j+1 for j in range(i)]+[j+1 for j in range(N-2, i, -1)]+[i+1]), sep='\\n')\n break\nelse:\n print('Impossible')", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "*A, = map(int, input().split())", "*A", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i, (a1, a2) in enumerate(zip(A, A[1:])):\n if a1 + a2 >= L:\n print('Possible')\n print(*([j+1 for j in range(i)]+[j+1 for j in range(N-2, i, -1)]+[i+1]), sep='\\n')\n break\nelse:\n print('Impossible')", "i", "(a1, a2)", "a1", "a2", "enumerate(zip(A, A[1:]))", "enumerate", "zip(A, A[1:])", "zip", "A", "A[1:]", "A", "1:", "1", "if a1 + a2 >= L:\n print('Possible')\n print(*([j+1 for j in range(i)]+[j+1 for j in range(N-2, i, -1)]+[i+1]), sep='\\n')\n break", "a1 + a2 >= L", "a1 + a2", "a1", "a2", "L", "print('Possible')", "print", "'Possible'", "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", "print(*([j+1 for j in range(i)]+[j+1 for j in range(N-2, i, -1)]+[i+1]), sep='\\n')", "print", "*([j+1 for j in range(i)]+[j+1 for j in range(N-2, i, -1)]+[i+1])", "[j+1 for j in range(i)]+[j+1 for j in range(N-2, i, -1)]+[i+1]", "[j+1 for j in range(i)]+[j+1 for j in range(N-2, i, -1)]", "[j+1 for j in range(i)]", "[j+1 for j in range(N-2, i, -1)]", "[i+1]", "i+1", "i", "1", "sep='\\n'", "sep", "'\\n'", "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" ]

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

[ [ 86, 6 ], [ 86, 15 ], [ 80, 17 ], [ 30, 29 ], [ 84, 33 ], [ 81, 39 ], [ 29, 40 ], [ 81, 42 ], [ 29, 44 ], [ 87, 46 ], [ 52, 51 ], [ 29, 54 ], [ 51, 58 ], [ 62, 61 ], [ 84, 65 ], [ 29, 67 ], [ 61, 71 ], [ 80, 81 ], [ 86, 84 ], [ 86, 87 ] ]

[ "import sys\nimport os\n\nN, L = map(int,input().split())\nA = list(map(int,input().split()))\nfor i in range(N-1):\n if A[i] + A[i+1] >= L:\n print(\"Possible\")\n for j in range(i):\n print(j+1)\n for j in range(N-1,i,-1):\n print(j)\n sys.exit()\nprint(\"Impossible\")", "import sys", "sys", "import os", "os", "N, L = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "A = list(map(int,input().split()))", "A", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(N-1):\n if A[i] + A[i+1] >= L:\n print(\"Possible\")\n for j in range(i):\n print(j+1)\n for j in range(N-1,i,-1):\n print(j)\n sys.exit()", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i] + A[i+1] >= L:\n print(\"Possible\")\n for j in range(i):\n print(j+1)\n for j in range(N-1,i,-1):\n print(j)\n sys.exit()", "A[i] + A[i+1] >= L", "A[i] + A[i+1]", "A[i]", "A", "i", "A[i+1]", "A", "i+1", "i", "1", "L", "print(\"Possible\")", "print", "\"Possible\"", "for j in range(i):\n print(j+1)\n ", "j", "range(i)", "range", "i", "print(j+1)", "print", "j+1", "j", "1", "for j in range(N-1,i,-1):\n print(j)\n ", "j", "range(N-1,i,-1)", "range", "N-1", "N", "1", "i", "-1", "print(j)", "print", "j", "sys.exit()", "sys.exit", "sys", "exit", "print(\"Impossible\")", "print", "\"Impossible\"", "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, 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, 17, 13, 14, 40, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 4, 13, 17, 28, 13, 4, 13, 17, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 17, 4, 13, 13, 29, 4, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 28, 27 ], [ 4, 31 ], [ 15, 36 ], [ 27, 38 ], [ 15, 41 ], [ 27, 42 ], [ 13, 43 ], [ 49, 48 ], [ 27, 52 ], [ 48, 55 ], [ 58, 57 ], [ 4, 61 ], [ 27, 64 ], [ 57, 69 ], [ 82, 79 ] ]

[ "def main():\n N, L = map(int, input().split())\n A = list(map(int, input().split()))\n for i in range(1, N):\n if A[i-1] + A[i] >= L:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(N-1, i-1, -1):\n print(j)\n return\n print(\"Impossible\")\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n N, L = map(int, input().split())\n A = list(map(int, input().split()))\n for i in range(1, N):\n if A[i-1] + A[i] >= L:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(N-1, i-1, -1):\n print(j)\n return\n print(\"Impossible\")", "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(1, N):\n if A[i-1] + A[i] >= L:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(N-1, i-1, -1):\n print(j)\n return\n ", "i", "range(1, N)", "range", "1", "N", "if A[i-1] + A[i] >= L:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(N-1, i-1, -1):\n print(j)\n return\n ", "A[i-1] + A[i] >= L", "A[i-1] + A[i]", "A[i-1]", "A", "i-1", "i", "1", "A[i]", "A", "i", "L", "print(\"Possible\")", "print", "\"Possible\"", "for j in range(1, i):\n print(j)\n ", "j", "range(1, i)", "range", "1", "i", "print(j)", "print", "j", "for j in range(N-1, i-1, -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", "return", "print(\"Impossible\")", "print", "\"Impossible\"", "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 for i in range(1, N):\n if A[i-1] + A[i] >= L:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(N-1, i-1, -1):\n print(j)\n return\n print(\"Impossible\")", "def main():\n N, L = map(int, input().split())\n A = list(map(int, input().split()))\n for i in range(1, N):\n if A[i-1] + A[i] >= L:\n print(\"Possible\")\n for j in range(1, i):\n print(j)\n for j in range(N-1, i-1, -1):\n print(j)\n return\n print(\"Impossible\")", "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, 4, 13, 39, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 13, 0, 13, 39, 14, 40, 13, 13, 4, 13, 17, 14, 2, 13, 2, 13, 17, 0, 13, 4, 13, 4, 13, 2, 13, 17, 13, 17, 0, 13, 4, 13, 4, 13, 17, 2, 13, 17, 0, 13, 4, 13, 4, 13, 17, 2, 13, 17, 4, 13, 31, 13, 0, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 130, 14 ], [ 130, 16 ], [ 20, 19 ], [ 19, 28 ], [ 118, 30 ], [ 121, 33 ], [ 119, 39 ], [ 119, 42 ], [ 121, 47 ], [ 112, 49 ], [ 122, 53 ], [ 128, 54 ], [ 110, 60 ], [ 131, 62 ], [ 106, 65 ], [ 131, 71 ], [ 110, 73 ], [ 124, 76 ], [ 110, 83 ], [ 115, 86 ], [ 110, 93 ], [ 116, 98 ], [ 125, 98 ], [ 107, 98 ], [ 113, 98 ], [ 101, 100 ], [ 106, 107 ], [ 121, 110 ], [ 112, 113 ], [ 115, 116 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ], [ 130, 128 ], [ 130, 131 ] ]

[ "N, L = [int(_) for _ in input().split()]\nA = [int(_) for _ in input().split()]\nl, i = max((A[i] + A[i - 1], i) for i in range(1, N))\nans = []\nif l >= L:\n print('Possible')\n if i < N - 1:\n ans += list(range(N - 1, i, -1))\n ans += list(range(1, i + 1))\n else:\n ans += list(range(1, i + 1))\n print(*ans, sep='\\n')\nelse:\n print('Impossible')", "int(_) for _ in input().split()", "for _ in input().split()", "_", "input().split()", "().split", "()", "input", "split", "for _ in input().split()", "int(_)", "int", "_", "N, L = [int(_) for _ in input().split()]", "N", "[int(_) for _ in input().split()]", "L", "int(_) for _ in input().split()", "for _ in input().split()", "_", "input().split()", "().split", "()", "input", "split", "for _ in input().split()", "int(_)", "int", "_", "A = [int(_) for _ in input().split()]", "A", "[int(_) for _ in input().split()]", "l, i = max((A[i] + A[i - 1], i) for i in range(1, N))", "l", "max((A[i] + A[i - 1], i) for i in range(1, N))", "max", "(A[i] + A[i - 1], i)", "A[i] + A[i - 1]", "A[i]", "A", "i", "A[i - 1]", "A", "i - 1", "i", "1", "i", "i", "ans = []", "ans", "[]", "if l >= L:\n print('Possible')\n if i < N - 1:\n ans += list(range(N - 1, i, -1))\n ans += list(range(1, i + 1))\n else:\n ans += list(range(1, i + 1))\n print(*ans, sep='\\n')\nelse:\n print('Impossible')", "l >= L", "l", "L", "print('Possible')", "print", "'Possible'", "if i < N - 1:\n ans += list(range(N - 1, i, -1))\n ans += list(range(1, i + 1))\n else:\n ans += list(range(1, i + 1))\n ", "i < N - 1", "i", "N - 1", "N", "1", "ans += list(range(N - 1, i, -1))", "ans", "list(range(N - 1, i, -1))", "list", "range(N - 1, i, -1)", "range", "N - 1", "N", "1", "i", "-1", "ans += list(range(1, i + 1))", "ans", "list(range(1, i + 1))", "list", "range(1, i + 1)", "range", "1", "i + 1", "i", "1", "ans += list(range(1, i + 1))", "ans", "list(range(1, i + 1))", "list", "range(1, i + 1)", "range", "1", "i + 1", "i", "1", "print(*ans, sep='\\n')", "print", "*ans", "ans", "sep='\\n'", "sep", "'\\n'", "print('Impossible')", "print", "'Impossible'", "ans += list(range(N - 1, i, -1))", "list(range(N - 1, i, -1))", "ans", "i = max((A[i] + A[i - 1], i) for i in range(1, N))", "max((A[i] + A[i - 1], i) for i in range(1, N))", "i", "ans = []", "[]", "ans", "ans += list(range(1, i + 1))", "list(range(1, i + 1))", "ans", "A = [int(_) for _ in input().split()]", "[int(_) for _ in input().split()]", "A", "l, i = max((A[i] + A[i - 1], i) for i in range(1, N))", "max((A[i] + A[i - 1], i) for i in range(1, N))", "l", "ans += list(range(1, i + 1))", "list(range(1, i + 1))", "ans", "L = [int(_) for _ in input().split()]", "[int(_) for _ in input().split()]", "L", "N, L = [int(_) for _ in input().split()]", "[int(_) for _ in 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, 0, 13, 17, 3, 14, 40, 13, 4, 13, 17, 4, 13, 0, 13, 17, 13, 2, 13, 17, 4, 13, 17, 0, 13, 39, 42, 2, 2, 13, 13, 17, 14, 2, 13, 13, 4, 18, 13, 13, 2, 13, 17, 0, 13, 17, 14, 2, 13, 2, 13, 17, 4, 18, 13, 13, 13, 0, 13, 17, 4, 18, 13, 13, 2, 13, 17, 4, 13, 31, 13, 0, 13, 17, 10, 13, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 39, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 153, 2 ], [ 153, 11 ], [ 147, 13 ], [ 138, 25 ], [ 29, 28 ], [ 154, 32 ], [ 148, 38 ], [ 28, 39 ], [ 148, 41 ], [ 28, 43 ], [ 133, 45 ], [ 123, 47 ], [ 28, 48 ], [ 135, 50 ], [ 136, 55 ], [ 139, 55 ], [ 150, 62 ], [ 144, 64 ], [ 154, 66 ], [ 141, 72 ], [ 145, 77 ], [ 130, 77 ], [ 151, 78 ], [ 127, 78 ], [ 151, 82 ], [ 127, 82 ], [ 124, 83 ], [ 142, 86 ], [ 151, 89 ], [ 127, 89 ], [ 126, 92 ], [ 145, 96 ], [ 130, 96 ], [ 124, 98 ], [ 142, 102 ], [ 145, 104 ], [ 130, 104 ], [ 129, 106 ], [ 142, 110 ], [ 124, 113 ], [ 142, 118 ], [ 121, 120 ], [ 28, 123 ], [ 123, 124 ], [ 126, 127 ], [ 129, 130 ], [ 153, 133 ], [ 135, 136 ], [ 138, 139 ], [ 141, 142 ], [ 144, 145 ], [ 147, 148 ], [ 150, 151 ], [ 153, 154 ] ]

[ "# coding: utf-8\nN, L = map(int, input().split())\nA = list(map(int, input().split()))\n# Lより小さい組み合わせしか無い場合おわり\nflag = False\nfor i in range(N-1):\n if A[i] + A[i+1] >= L:\n importance_i = i\n flag = True\n break\nif not flag:\n print(\"Impossible\")\n exit()\n\nl, r = 0, N-1\nprint(\"Possible\")\nans = []\nwhile r - l > 1:\n # print(l, r)\n if l < importance_i:\n ans.append(l+1)\n l += 1\n if r > importance_i+1:\n ans.append(r)\n r -= 1\n# print(\"importance_i\", importance_i)\nans.append(importance_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", "flag = False", "flag", "False", "for i in range(N-1):\n if A[i] + A[i+1] >= L:\n importance_i = i\n flag = True\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i] + A[i+1] >= L:\n importance_i = i\n flag = 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", "importance_i = i", "importance_i", "i", "flag = True", "flag", "True", "break", "if not flag:\n print(\"Impossible\")\n exit()", "not flag", "flag", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "l, r = 0, N-1", "l", "0", "r", "N-1", "N", "1", "print(\"Possible\")", "print", "\"Possible\"", "ans = []", "ans", "[]", "while r - l > 1:\n # print(l, r)\n if l < importance_i:\n ans.append(l+1)\n l += 1\n if r > importance_i+1:\n ans.append(r)\n r -= 1\n# print(\"importance_i\", importance_i)", "r - l > 1", "r - l", "r", "l", "1", "if l < importance_i:\n ans.append(l+1)\n l += 1\n ", "l < importance_i", "l", "importance_i", "ans.append(l+1)", "ans.append", "ans", "append", "l+1", "l", "1", "l += 1", "l", "1", "if r > importance_i+1:\n ans.append(r)\n r -= 1\n# print(\"importance_i\", importance_i)", "r > importance_i+1", "r", "importance_i+1", "importance_i", "1", "ans.append(r)", "ans.append", "ans", "append", "r", "r -= 1", "r", "1", "ans.append(importance_i+1)", "ans.append", "ans", "append", "importance_i+1", "importance_i", "1", "print(*ans, sep=\"\\n\")", "print", "*ans", "ans", "sep=\"\\n\"", "sep", "\"\\n\"", "importance_i = i", "i", "importance_i", "l += 1", "1", "l", "r -= 1", "1", "r", "L = map(int, input().split())", "map(int, input().split())", "L", "flag = True", "True", "flag", "flag = False", "False", "flag", "ans = []", "[]", "ans", "r = 0, N-1", "N-1", "r", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "l, r = 0, N-1", "0", "l", "N, L = map(int, input().split())", "map(int, input().split())", "N" ]

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

[ [ 261, 11 ], [ 28, 28 ], [ 30, 30 ], [ 246, 32 ], [ 282, 37 ], [ 47, 46 ], [ 52, 52 ], [ 64, 63 ], [ 262, 67 ], [ 63, 73 ], [ 82, 81 ], [ 91, 91 ], [ 95, 94 ], [ 253, 100 ], [ 104, 104 ], [ 108, 107 ], [ 292, 113 ], [ 117, 117 ], [ 121, 120 ], [ 262, 122 ], [ 120, 131 ], [ 145, 144 ], [ 274, 146 ], [ 145, 147 ], [ 150, 149 ], [ 253, 151 ], [ 154, 153 ], [ 157, 156 ], [ 160, 159 ], [ 144, 163 ], [ 149, 169 ], [ 159, 170 ], [ 149, 172 ], [ 159, 174 ], [ 147, 176 ], [ 179, 178 ], [ 182, 181 ], [ 159, 182 ], [ 190, 189 ], [ 144, 193 ], [ 189, 197 ], [ 181, 198 ], [ 156, 198 ], [ 189, 202 ], [ 207, 206 ], [ 144, 211 ], [ 206, 217 ], [ 181, 218 ], [ 156, 218 ], [ 206, 222 ], [ 181, 228 ], [ 156, 228 ], [ 277, 238 ], [ 246, 247 ], [ 261, 262 ], [ 282, 283 ] ]

[ "#\n# 　　 ⋀_⋀　 \n#　　 (･ω･) \n# .／ Ｕ ∽ Ｕ＼\n# │＊　合　＊│\n# │＊　格　＊│ \n# │＊　祈　＊│ \n# │＊　願　＊│ \n# │＊　　　＊│ \n# ￣\n#\nimport sys\nsys.setrecursionlimit(10**6)\ninput=sys.stdin.readline\nfrom math import floor,sqrt,factorial,hypot,log #log2ないｙｐ\nfrom heapq import heappop, heappush, heappushpop\nfrom collections import Counter,defaultdict,deque\nfrom itertools import accumulate,permutations,combinations,product,combinations_with_replacement\nfrom bisect import bisect_left,bisect_right\nfrom copy import deepcopy\nfrom fractions import gcd\nfrom random import randint\ndef ceil(a,b): return (a+b-1)//b\ninf=float('inf')\nmod = 10**9+7\ndef pprint(*A): \n for a in A: print(*a,sep='\\n')\ndef INT_(n): return int(n)-1\ndef MI(): return map(int,input().split())\ndef MF(): return map(float, input().split())\ndef MI_(): return map(INT_,input().split())\ndef LI(): return list(MI())\ndef LI_(): return [int(x) - 1 for x in input().split()]\ndef LF(): return list(MF())\ndef LIN(n:int): return [I() for _ in range(n)]\ndef LLIN(n: int): return [LI() for _ in range(n)]\ndef LLIN_(n: int): return [LI_() for _ in range(n)]\ndef LLI(): return [list(map(int, l.split() )) for l in input()]\ndef I(): return int(input())\ndef F(): return float(input())\ndef ST(): return input().replace('\\n', '')\ndef main():\n N,L=MI()\n A=LI()\n pos = False\n idx = 0\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n pos = True\n idx = i\n if pos:\n print(\"Possible\")\n for i in range(N-1):\n if i!=idx:\n print(i+1)\n else:\n break\n for i in range(N-1)[::-1]:\n if i!=idx:\n print(i+1)\n else:\n break\n print(idx+1)\n else:\n print(\"Impossible\")\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "sys.setrecursionlimit(10**6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**6", "10", "6", "input=sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "from math import floor,sqrt,factorial,hypot,log", "from heapq import heappop, heappush, heappushpop", "from collections import Counter,defaultdict,deque", "from itertools import accumulate,permutations,combinations,product,combinations_with_replacement", "from bisect import bisect_left,bisect_right", "from copy import deepcopy", "from fractions import gcd", "from random import randint", "def ceil(a,b): return (a+b-1)//b", "ceil", "a", "a", "b", "b", "inf=float('inf')", "inf", "float('inf')", "float", "'inf'", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "def pprint(*A): \n for a in A: print(*a,sep='\\n')", "pprint", "for a in A: print(*a,sep='", "a", "A", "*A", "def INT_(n): return int(n)-1", "INT_", "n", "n", "def MI(): return map(int,input().split())", "MI", "def MF(): return map(float, input().split())", "MF", "def MI_(): return map(INT_,input().split())", "MI_", "def LI(): return list(MI())", "LI", "int(x) - 1 for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x) - 1", "int(x)", "int", "x", "1", "def LI_(): return [int(x) - 1 for x in input().split()]", "LI_", "def LF(): return list(MF())", "LF", "I() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "I()", "I", "def LIN(n:int): return [I() for _ in range(n)]", "LIN", "n:int", "n", "LI() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "LI()", "LI", "def LLIN(n: int): return [LI() for _ in range(n)]", "LLIN", "n: int", "n", "LI_() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "LI_()", "LI_", "def LLIN_(n: int): return [LI_() for _ in range(n)]", "LLIN_", "n: int", "n", "list(map(int, l.split() )) for l in input()", "for l in input()", "l", "input()", "input", "for l in input()", "list(map(int, l.split() ))", "list", "map(int, l.split() )", "map", "int", "l.split()", "l.split", "l", "split", "def LLI(): return [list(map(int, l.split() )) for l in input()]", "LLI", "def I(): return int(input())", "I", "def F(): return float(input())", "F", "def ST(): return input().replace('\\n', '')", "ST", "def main():\n N,L=MI()\n A=LI()\n pos = False\n idx = 0\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n pos = True\n idx = i\n if pos:\n print(\"Possible\")\n for i in range(N-1):\n if i!=idx:\n print(i+1)\n else:\n break\n for i in range(N-1)[::-1]:\n if i!=idx:\n print(i+1)\n else:\n break\n print(idx+1)\n else:\n print(\"Impossible\")", "main", "N,L=MI()", "N", "MI()", "MI", "L", "A=LI()", "A", "LI()", "LI", "pos = False", "pos", "False", "idx = 0", "idx", "0", "for i in range(N-1):\n if A[i]+A[i+1] >= L:\n pos = True\n idx = i\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i]+A[i+1] >= L:\n pos = True\n idx = 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", "pos = True", "pos", "True", "idx = i", "idx", "i", "if pos:\n print(\"Possible\")\n for i in range(N-1):\n if i!=idx:\n print(i+1)\n else:\n break\n for i in range(N-1)[::-1]:\n if i!=idx:\n print(i+1)\n else:\n break\n print(idx+1)\n else:\n print(\"Impossible\")", "pos", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(N-1):\n if i!=idx:\n print(i+1)\n else:\n break\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if i!=idx:\n print(i+1)\n else:\n break\n ", "i!=idx", "i", "idx", "print(i+1)", "print", "i+1", "i", "1", "break", "for i in range(N-1)[::-1]:\n if i!=idx:\n print(i+1)\n else:\n break\n ", "i", "range(N-1)[::-1]", "(N-1)", "range", "N-1", "N", "1", "::-1", "-1", "if i!=idx:\n print(i+1)\n else:\n break\n ", "i!=idx", "i", "idx", "print(i+1)", "print", "i+1", "i", "1", "break", "print(idx+1)", "print", "idx+1", "idx", "1", "print(\"Impossible\")", "print", "\"Impossible\"", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def LLI(): return [list(map(int, l.split() )) for l in input()]", "def LLI(): return [list(map(int, l.split() )) for l in input()]", "LLI", "def LLIN(n: int): return [LI() for _ in range(n)]", "def LLIN(n: int): return [LI() for _ in range(n)]", "LLIN", "inf=float('inf')", "float('inf')", "inf", "def MF(): return map(float, input().split())", "def MF(): return map(float, input().split())", "MF", "def LI(): return list(MI())", "def LI(): return list(MI())", "LI", "def INT_(n): return int(n)-1", "def INT_(n): return int(n)-1", "INT_", "def F(): return float(input())", "def F(): return float(input())", "F", "input=sys.stdin.readline", "sys.stdin.readline", "input", "def LIN(n:int): return [I() for _ in range(n)]", "def LIN(n:int): return [I() for _ in range(n)]", "LIN", "def I(): return int(input())", "def I(): return int(input())", "I", "def ceil(a,b): return (a+b-1)//b", "def ceil(a,b): return (a+b-1)//b", "ceil", "def MI(): return map(int,input().split())", "def MI(): return map(int,input().split())", "MI", "def main():\n N,L=MI()\n A=LI()\n pos = False\n idx = 0\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n pos = True\n idx = i\n if pos:\n print(\"Possible\")\n for i in range(N-1):\n if i!=idx:\n print(i+1)\n else:\n break\n for i in range(N-1)[::-1]:\n if i!=idx:\n print(i+1)\n else:\n break\n print(idx+1)\n else:\n print(\"Impossible\")", "def main():\n N,L=MI()\n A=LI()\n pos = False\n idx = 0\n for i in range(N-1):\n if A[i]+A[i+1] >= L:\n pos = True\n idx = i\n if pos:\n print(\"Possible\")\n for i in range(N-1):\n if i!=idx:\n print(i+1)\n else:\n break\n for i in range(N-1)[::-1]:\n if i!=idx:\n print(i+1)\n else:\n break\n print(idx+1)\n else:\n print(\"Impossible\")", "main", "def ST(): return input().replace('\\n', '')", "def ST(): return input().replace('\\n', '')", "ST", "mod = 10**9+7", "10**9+7", "mod", "def MI_(): return map(INT_,input().split())", "def MI_(): return map(INT_,input().split())", "MI_", "def LLIN_(n: int): return [LI_() for _ in range(n)]", "def LLIN_(n: int): return [LI_() for _ in range(n)]", "LLIN_", "def LI_(): return [int(x) - 1 for x in input().split()]", "def LI_(): return [int(x) - 1 for x in input().split()]", "LI_", "def LF(): return list(MF())", "def LF(): return list(MF())", "LF", "def pprint(*A): \n for a in A: print(*a,sep='\\n')", "def pprint(*A): \n for a in A: print(*a,sep='\\n')", "pprint" ]

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

[ [ 46, 2 ], [ 46, 15 ], [ 46, 16 ], [ 44, 27 ], [ 47, 38 ], [ 46, 44 ], [ 46, 47 ] ]

[ "N,L,*A=map(int,open(0).read().split())\nfor i,a,b in zip(range(1,N),A,A[1:]):\n if a+b>=L:print(\"Possible\",*range(1,i));print(*range(N-1,i-1,-1));quit()\nprint(\"Impossible\")", "N,L,*A=map(int,open(0).read().split())", "N", "map(int,open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "L", "*A", "A", "for i,a,b in zip(range(1,N),A,A[1:]):\n if a+b>=L:print(\"Possible\",*range(1,i));print(*range(N-1,i-1,-1));quit()", "i", "a", "b", "zip(range(1,N),A,A[1:])", "zip", "range(1,N)", "range", "1", "N", "A", "A[1:]", "A", "1:", "1", "if a+b>=L:print(\"Possible\",*range(1,i));print(*range(N-1,i-1,-1));qu", "a+b>=L", "a+b", "a", "b", "L", "print(\"Impossible\")", "print", "\"Impossible\"", "N,L,*A=map(int,open(0).read().split())", "map(int,open(0).read().split())", "N", "L,*A=map(int,open(0).read().split())", "map(int,open(0).read().split())", "L" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 134, 14 ], [ 134, 16 ], [ 20, 19 ], [ 19, 28 ], [ 140, 30 ], [ 137, 33 ], [ 37, 36 ], [ 135, 40 ], [ 141, 46 ], [ 36, 47 ], [ 141, 49 ], [ 36, 51 ], [ 126, 53 ], [ 128, 55 ], [ 36, 56 ], [ 119, 59 ], [ 120, 63 ], [ 138, 63 ], [ 120, 66 ], [ 138, 66 ], [ 116, 69 ], [ 129, 74 ], [ 122, 77 ], [ 129, 84 ], [ 129, 87 ], [ 135, 89 ], [ 131, 92 ], [ 129, 98 ], [ 135, 101 ], [ 132, 105 ], [ 123, 105 ], [ 117, 105 ], [ 109, 108 ], [ 132, 108 ], [ 123, 108 ], [ 117, 108 ], [ 108, 113 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 134, 126 ], [ 36, 128 ], [ 128, 129 ], [ 131, 132 ], [ 134, 135 ], [ 137, 138 ], [ 140, 141 ] ]

[ "N, L = (int(i) for i in input().split())\na = [int(i) for i in input().split()]\nP = \"Possible\"\nfor i in range(N-1):\n if a[i] + a[i+1] >= L:\n start = i\n break \nelse:\n P = \"Impossible\"\nprint(P)\n\nif P == \"Possible\":\n ans = [start]\n if start > 0:\n ans += reversed(list(range(start)))\n if start != N-2:\n ans += list(range(start+1, N-1))\n ans.reverse()\n for a in ans:\n print(a+1)", "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()]", "P = \"Possible\"", "P", "\"Possible\"", "for i in range(N-1):\n if a[i] + a[i+1] >= L:\n start = i\n break \nelse:\n P = \"Impossible\"", "i", "range(N-1)", "range", "N-1", "N", "1", "if a[i] + a[i+1] >= L:\n start = 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", "start = i", "start", "i", "break", "P = \"Impossible\"", "P", "\"Impossible\"", "print(P)", "print", "P", "if P == \"Possible\":\n ans = [start]\n if start > 0:\n ans += reversed(list(range(start)))\n if start != N-2:\n ans += list(range(start+1, N-1))\n ans.reverse()\n for a in ans:\n print(a+1)", "P == \"Possible\"", "P", "\"Possible\"", "ans = [start]", "ans", "[start]", "start", "if start > 0:\n ans += reversed(list(range(start)))\n ", "start > 0", "start", "0", "ans += reversed(list(range(start)))", "ans", "reversed(list(range(start)))", "reversed", "list(range(start))", "list", "range(start)", "range", "start", "if start != N-2:\n ans += list(range(start+1, N-1))\n ", "start != N-2", "start", "N-2", "N", "2", "ans += list(range(start+1, N-1))", "ans", "list(range(start+1, N-1))", "list", "range(start+1, N-1)", "range", "start+1", "start", "1", "N-1", "N", "1", "ans.reverse()", "ans.reverse", "ans", "reverse", "for a in ans:\n print(a+1)", "a", "ans", "print(a+1)", "print", "a+1", "a", "1", "ans = [start]", "[start]", "ans", "P = \"Impossible\"", "\"Impossible\"", "P", "ans += reversed(list(range(start)))", "reversed(list(range(start)))", "ans", "L = (int(i) for i in input().split())", "(int(i) for i in input().split())", "L", "start = i", "i", "start", "ans += list(range(start+1, N-1))", "list(range(start+1, N-1))", "ans", "N, L = (int(i) for i in input().split())", "(int(i) for i in input().split())", "N", "P = \"Possible\"", "\"Possible\"", "P", "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, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 0, 13, 2, 18, 13, 17, 18, 13, 17, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 2, 2, 18, 13, 2, 13, 17, 18, 13, 2, 13, 17, 13, 0, 13, 2, 18, 13, 2, 13, 17, 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, 13, 13, 4, 13, 2, 2, 2, 13, 13, 13, 17, 10, 2, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 127, 2 ], [ 127, 11 ], [ 15, 14 ], [ 14, 23 ], [ 130, 25 ], [ 112, 28 ], [ 131, 31 ], [ 131, 34 ], [ 118, 36 ], [ 40, 39 ], [ 128, 43 ], [ 131, 49 ], [ 39, 51 ], [ 131, 54 ], [ 39, 56 ], [ 113, 58 ], [ 122, 58 ], [ 121, 60 ], [ 131, 63 ], [ 39, 65 ], [ 131, 68 ], [ 39, 70 ], [ 115, 73 ], [ 39, 75 ], [ 122, 79 ], [ 113, 79 ], [ 125, 80 ], [ 89, 88 ], [ 116, 92 ], [ 119, 92 ], [ 88, 95 ], [ 98, 97 ], [ 116, 100 ], [ 119, 100 ], [ 128, 101 ], [ 128, 107 ], [ 116, 108 ], [ 119, 108 ], [ 97, 109 ], [ 112, 113 ], [ 115, 116 ], [ 118, 119 ], [ 121, 122 ], [ 127, 125 ], [ 127, 128 ], [ 130, 131 ] ]

[ "n,l=map(int,input().split())\nA=[int(i) for i in input().split()]\nlength,knot=A[0]+A[1],1\nfor i in range(n-2):\n if A[i+1]+A[i+2]>length:\n length=A[i+1]+A[i+2]\n knot=i+2\nif length<l:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,knot):\n print(i)\n for i in range(knot,n):\n print(n+knot-i-1)", "n,l=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "A=[int(i) for i in input().split()]", "A", "[int(i) for i in input().split()]", "length,knot=A[0]+A[1],1", "length", "A[0]+A[1]", "A[0]", "A", "0", "A[1]", "A", "1", "knot", "1", "for i in range(n-2):\n if A[i+1]+A[i+2]>length:\n length=A[i+1]+A[i+2]\n knot=i+2", "i", "range(n-2)", "range", "n-2", "n", "2", "if A[i+1]+A[i+2]>length:\n length=A[i+1]+A[i+2]\n knot=i+2", "A[i+1]+A[i+2]>length", "A[i+1]+A[i+2]", "A[i+1]", "A", "i+1", "i", "1", "A[i+2]", "A", "i+2", "i", "2", "length", "length=A[i+1]+A[i+2]", "length", "A[i+1]+A[i+2]", "A[i+1]", "A", "i+1", "i", "1", "A[i+2]", "A", "i+2", "i", "2", "knot=i+2", "knot", "i+2", "i", "2", "if length<l:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,knot):\n print(i)\n for i in range(knot,n):\n print(n+knot-i-1)", "length<l", "length", "l", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,knot):\n print(i)\n ", "i", "range(1,knot)", "range", "1", "knot", "print(i)", "print", "i", "for i in range(knot,n):\n print(n+knot-i-1)", "i", "range(knot,n)", "range", "knot", "n", "print(n+knot-i-1)", "print", "n+knot-i-1", "n+knot-i", "n+knot", "n", "knot", "i", "1", "length,knot=A[0]+A[1],1", "A[0]+A[1]", "length", "knot=i+2", "i+2", "knot", "knot=A[0]+A[1],1", "1", "knot", "length=A[i+1]+A[i+2]", "A[i+1]+A[i+2]", "length", "l=map(int,input().split())", "map(int,input().split())", "l", "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, 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, 28, 13, 4, 13, 2, 13, 17, 13, 17, 4, 13, 13, 3, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 81, 2 ], [ 81, 11 ], [ 78, 13 ], [ 26, 25 ], [ 76, 30 ], [ 79, 36 ], [ 25, 37 ], [ 79, 39 ], [ 25, 41 ], [ 82, 43 ], [ 49, 48 ], [ 25, 53 ], [ 48, 57 ], [ 60, 59 ], [ 76, 63 ], [ 25, 65 ], [ 59, 69 ], [ 81, 76 ], [ 78, 79 ], [ 81, 82 ] ]

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

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

[ [ 4, 3 ], [ 3, 12 ], [ 114, 14 ], [ 114, 16 ], [ 20, 19 ], [ 19, 28 ], [ 120, 30 ], [ 123, 33 ], [ 105, 36 ], [ 40, 39 ], [ 109, 43 ], [ 111, 46 ], [ 121, 49 ], [ 39, 50 ], [ 121, 52 ], [ 39, 54 ], [ 106, 58 ], [ 112, 60 ], [ 112, 63 ], [ 115, 64 ], [ 117, 66 ], [ 39, 67 ], [ 118, 70 ], [ 124, 70 ], [ 80, 79 ], [ 118, 82 ], [ 124, 82 ], [ 79, 86 ], [ 90, 89 ], [ 109, 93 ], [ 118, 96 ], [ 124, 96 ], [ 89, 102 ], [ 105, 106 ], [ 114, 109 ], [ 111, 112 ], [ 114, 115 ], [ 39, 117 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ] ]

[ "n, l = [int(v) for v in input().split()]\na_s = [int(v) for v in input().split()]\n\npiv = -1\nb_s = []\nfor i in range(n - 1):\n a2 = a_s[i] + a_s[i + 1]\n b_s.append(a2)\n if a2 >= l:\n piv = i\n\nif piv == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(piv):\n print(i + 1)\n for i in range(n-2, piv - 1, -1):\n print(i + 1)", "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", "a_s = [int(v) for v in input().split()]", "a_s", "[int(v) for v in input().split()]", "piv = -1", "piv", "-1", "b_s = []", "b_s", "[]", "for i in range(n - 1):\n a2 = a_s[i] + a_s[i + 1]\n b_s.append(a2)\n if a2 >= l:\n piv = i", "i", "range(n - 1)", "range", "n - 1", "n", "1", "a2 = a_s[i] + a_s[i + 1]", "a2", "a_s[i] + a_s[i + 1]", "a_s[i]", "a_s", "i", "a_s[i + 1]", "a_s", "i + 1", "i", "1", "b_s.append(a2)", "b_s.append", "b_s", "append", "a2", "if a2 >= l:\n piv = i", "a2 >= l", "a2", "l", "piv = i", "piv", "i", "if piv == -1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(piv):\n print(i + 1)\n for i in range(n-2, piv - 1, -1):\n print(i + 1)", "piv == -1", "piv", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(piv):\n print(i + 1)\n ", "i", "range(piv)", "range", "piv", "print(i + 1)", "print", "i + 1", "i", "1", "for i in range(n-2, piv - 1, -1):\n print(i + 1)", "i", "range(n-2, piv - 1, -1)", "range", "n-2", "n", "2", "piv - 1", "piv", "1", "-1", "print(i + 1)", "print", "i + 1", "i", "1", "b_s = []", "[]", "b_s", "n, l = [int(v) for v in input().split()]", "[int(v) for v in input().split()]", "n", "a2 = a_s[i] + a_s[i + 1]", "a_s[i] + a_s[i + 1]", "a2", "l = [int(v) for v in input().split()]", "[int(v) for v in input().split()]", "l", "piv = i", "i", "piv", "a_s = [int(v) for v in input().split()]", "[int(v) for v in input().split()]", "a_s", "piv = -1", "-1", "piv" ]

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

[ [ 98, 2 ], [ 98, 11 ], [ 95, 13 ], [ 28, 27 ], [ 90, 31 ], [ 96, 37 ], [ 27, 38 ], [ 96, 40 ], [ 27, 42 ], [ 99, 44 ], [ 27, 46 ], [ 86, 50 ], [ 93, 52 ], [ 87, 55 ], [ 65, 64 ], [ 87, 67 ], [ 64, 71 ], [ 75, 74 ], [ 90, 78 ], [ 87, 80 ], [ 74, 84 ], [ 86, 87 ], [ 98, 90 ], [ 95, 96 ], [ 98, 99 ] ]

[ "N, L = map(int,input().split())\na_list = list(map(int,input().split()))\n\ndef equal_or_over_idx():\n for i in range(N-1):\n if a_list[i]+a_list[i+1] >=L:\n return i\n return -1\n\nidx = equal_or_over_idx()\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 = list(map(int,input().split()))", "a_list", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def equal_or_over_idx():\n for i in range(N-1):\n if a_list[i]+a_list[i+1] >=L:\n return i\n return -1", "equal_or_over_idx", "for i in range(N-1):\n if a_list[i]+a_list[i+1] >=L:\n return i\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if a_list[i]+a_list[i+1] >=L:\n return i\n ", "a_list[i]+a_list[i+1] >=L", "a_list[i]+a_list[i+1]", "a_list[i]", "a_list", "i", "a_list[i+1]", "a_list", "i+1", "i", "1", "L", "return i", "i", "return -1", "-1", "idx = equal_or_over_idx()", "idx", "equal_or_over_idx()", "equal_or_over_idx", "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 = equal_or_over_idx()", "equal_or_over_idx()", "idx", "N, L = map(int,input().split())", "map(int,input().split())", "N", "def equal_or_over_idx():\n for i in range(N-1):\n if a_list[i]+a_list[i+1] >=L:\n return i\n return -1", "def equal_or_over_idx():\n for i in range(N-1):\n if a_list[i]+a_list[i+1] >=L:\n return i\n return -1", "equal_or_over_idx", "a_list = list(map(int,input().split()))", "list(map(int,input().split()))", "a_list", "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, 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, 2, 39, 2, 13, 17, 4, 13, 4, 13, 13, 17, 17, 4, 13, 4, 13, 2, 13, 17, 13, 4, 13, 31, 18, 13, 39, 17, 0, 13, 17, 3, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 90, 2 ], [ 90, 11 ], [ 87, 13 ], [ 26, 25 ], [ 85, 29 ], [ 88, 35 ], [ 25, 36 ], [ 88, 38 ], [ 25, 40 ], [ 91, 42 ], [ 81, 47 ], [ 25, 52 ], [ 25, 58 ], [ 25, 66 ], [ 85, 68 ], [ 82, 73 ], [ 78, 77 ], [ 81, 82 ], [ 90, 85 ], [ 87, 88 ], [ 90, 91 ] ]

[ "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=[i+1]+list(range(i,0,-1))+list(range(i+2,n))\n print(*ans[::-1],sep='\\n')\n break\nelse: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(n-1):\n if a[i]+a[i+1]>=l:\n print('Possible')\n ans=[i+1]+list(range(i,0,-1))+list(range(i+2,n))\n print(*ans[::-1],sep='\\n')\n break\nelse:print('Impossible')", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n print('Possible')\n ans=[i+1]+list(range(i,0,-1))+list(range(i+2,n))\n print(*ans[::-1],sep='\\n')\n break", "a[i]+a[i+1]>=l", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "l", "print('Possible')", "print", "'Possible'", "ans=[i+1]+list(range(i,0,-1))+list(range(i+2,n))", "ans", "[i+1]+list(range(i,0,-1))+list(range(i+2,n))", "[i+1]+list(range(i,0,-1))", "[i+1]", "i+1", "i", "1", "list(range(i,0,-1))", "list", "range(i,0,-1)", "range", "i", "0", "-1", "list(range(i+2,n))", "list", "range(i+2,n)", "range", "i+2", "i", "2", "n", "print(*ans[::-1],sep='\\n')", "print", "*ans[::-1]", "ans[::-1]", "ans", "::-1", "-1", "sep='\\n'", "sep", "'\\n'", "break", "ans=[i+1]+list(range(i,0,-1))+list(range(i+2,n))", "[i+1]+list(range(i,0,-1))+list(range(i+2,n))", "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" ]

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

[ [ 100, 2 ], [ 100, 11 ], [ 88, 13 ], [ 97, 25 ], [ 29, 28 ], [ 95, 32 ], [ 89, 38 ], [ 28, 39 ], [ 89, 41 ], [ 28, 43 ], [ 101, 45 ], [ 91, 47 ], [ 28, 49 ], [ 92, 54 ], [ 98, 54 ], [ 66, 65 ], [ 92, 69 ], [ 98, 69 ], [ 65, 72 ], [ 75, 74 ], [ 95, 78 ], [ 92, 81 ], [ 98, 81 ], [ 74, 86 ], [ 88, 89 ], [ 91, 92 ], [ 100, 95 ], [ 97, 98 ], [ 100, 101 ] ]

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

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

[ [ 112, 4 ], [ 112, 13 ], [ 17, 16 ], [ 16, 25 ], [ 100, 27 ], [ 115, 30 ], [ 118, 33 ], [ 37, 36 ], [ 113, 40 ], [ 101, 46 ], [ 36, 48 ], [ 101, 51 ], [ 36, 52 ], [ 110, 53 ], [ 103, 55 ], [ 106, 58 ], [ 36, 60 ], [ 77, 76 ], [ 107, 80 ], [ 119, 80 ], [ 76, 83 ], [ 86, 85 ], [ 113, 89 ], [ 107, 91 ], [ 119, 91 ], [ 85, 95 ], [ 107, 98 ], [ 119, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ], [ 112, 110 ], [ 112, 113 ], [ 115, 116 ], [ 118, 119 ] ]

[ "import sys\nN,L=map(int,input().split())\nA=[int(i) for i in input().split()]\nflag=True\na=-1\nfor i in range(N-1):\n if A[i+1]+A[i]>=L:\n flag=False\n a=i+1\n break\nif flag:\n print('Impossible')\n sys.exit()\nprint('Possible')\nfor i in range(1,a):\n print(i)\nfor i in range(N-1,a,-1):\n print(i)\nprint(a)", "import sys", "sys", "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()]", "flag=True", "flag", "True", "a=-1", "a", "-1", "for i in range(N-1):\n if A[i+1]+A[i]>=L:\n flag=False\n a=i+1\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i+1]+A[i]>=L:\n flag=False\n a=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", "flag=False", "flag", "False", "a=i+1", "a", "i+1", "i", "1", "break", "if flag:\n print('Impossible')\n sys.exit()", "flag", "print('Impossible')", "print", "'Impossible'", "sys.exit()", "sys.exit", "sys", "exit", "print('Possible')", "print", "'Possible'", "for i in range(1,a):\n print(i)", "i", "range(1,a)", "range", "1", "a", "print(i)", "print", "i", "for i in range(N-1,a,-1):\n print(i)", "i", "range(N-1,a,-1)", "range", "N-1", "N", "1", "a", "-1", "print(i)", "print", "i", "print(a)", "print", "a", "A=[int(i) for i in input().split()]", "[int(i) for i in input().split()]", "A", "flag=False", "False", "flag", "a=i+1", "i+1", "a", "L=map(int,input().split())", "map(int,input().split())", "L", "N,L=map(int,input().split())", "map(int,input().split())", "N", "flag=True", "True", "flag", "a=-1", "-1", "a" ]

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

[ [ 120, 2 ], [ 135, 9 ], [ 135, 18 ], [ 123, 20 ], [ 33, 32 ], [ 133, 36 ], [ 124, 42 ], [ 32, 43 ], [ 124, 45 ], [ 32, 47 ], [ 136, 49 ], [ 126, 51 ], [ 32, 52 ], [ 127, 59 ], [ 121, 59 ], [ 138, 71 ], [ 127, 73 ], [ 121, 73 ], [ 141, 76 ], [ 139, 82 ], [ 127, 82 ], [ 121, 82 ], [ 129, 84 ], [ 139, 90 ], [ 127, 90 ], [ 121, 90 ], [ 133, 92 ], [ 130, 95 ], [ 142, 99 ], [ 130, 101 ], [ 142, 104 ], [ 139, 106 ], [ 127, 106 ], [ 121, 106 ], [ 109, 108 ], [ 133, 112 ], [ 142, 117 ], [ 108, 118 ], [ 120, 121 ], [ 123, 124 ], [ 32, 126 ], [ 126, 127 ], [ 129, 130 ], [ 135, 133 ], [ 135, 136 ], [ 138, 139 ], [ 141, 142 ] ]

[ "K=10**10\nimport sys\nN,L=map(int,input().split())\nT=list(map(int,input().split()))\nfor i in range(N-1):\n if T[i]+T[i+1]>=L:\n K=i\n print(\"Possible\")\n break\nif K==10**10:\n print(\"Impossible\")\n sys.exit()\nK=K+1\nR=list(range(1,K))\nM=list(range(K+1,N))\nM.reverse()\nR.extend(M)\nR.append(K)\nfor i in range(N-1):\n print(R[i])", "K=10**10", "K", "10**10", "10", "10", "import sys", "sys", "N,L=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "T=list(map(int,input().split()))", "T", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(N-1):\n if T[i]+T[i+1]>=L:\n K=i\n print(\"Possible\")\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if T[i]+T[i+1]>=L:\n K=i\n print(\"Possible\")\n break", "T[i]+T[i+1]>=L", "T[i]+T[i+1]", "T[i]", "T", "i", "T[i+1]", "T", "i+1", "i", "1", "L", "K=i", "K", "i", "print(\"Possible\")", "print", "\"Possible\"", "break", "if K==10**10:\n print(\"Impossible\")\n sys.exit()", "K==10**10", "K", "10**10", "10", "10", "print(\"Impossible\")", "print", "\"Impossible\"", "sys.exit()", "sys.exit", "sys", "exit", "K=K+1", "K", "K+1", "K", "1", "R=list(range(1,K))", "R", "list(range(1,K))", "list", "range(1,K)", "range", "1", "K", "M=list(range(K+1,N))", "M", "list(range(K+1,N))", "list", "range(K+1,N)", "range", "K+1", "K", "1", "N", "M.reverse()", "M.reverse", "M", "reverse", "R.extend(M)", "R.extend", "R", "extend", "M", "R.append(K)", "R.append", "R", "append", "K", "for i in range(N-1):\n print(R[i])", "i", "range(N-1)", "range", "N-1", "N", "1", "print(R[i])", "print", "R[i]", "R", "i", "K=10**10", "10**10", "K", "T=list(map(int,input().split()))", "list(map(int,input().split()))", "T", "K=i", "i", "K", "M=list(range(K+1,N))", "list(range(K+1,N))", "M", "N,L=map(int,input().split())", "map(int,input().split())", "N", "L=map(int,input().split())", "map(int,input().split())", "L", "K=K+1", "K+1", "K", "R=list(range(1,K))", "list(range(1,K))", "R" ]

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

[ [ 128, 22 ], [ 125, 27 ], [ 37, 36 ], [ 37, 47 ], [ 50, 49 ], [ 62, 61 ], [ 65, 64 ], [ 36, 68 ], [ 49, 73 ], [ 64, 74 ], [ 49, 76 ], [ 64, 78 ], [ 47, 80 ], [ 83, 82 ], [ 64, 83 ], [ 82, 87 ], [ 61, 87 ], [ 98, 97 ], [ 82, 101 ], [ 61, 101 ], [ 97, 104 ], [ 107, 106 ], [ 36, 110 ], [ 82, 113 ], [ 61, 113 ], [ 106, 118 ], [ 123, 120 ], [ 125, 126 ], [ 128, 129 ] ]

[ "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time\n\nsys.setrecursionlimit(10**7)\ninf = 10**10\nmod = 10**9 + 7\n\n\ndef f():\n n,l = list(map(int, input().split()))\n a = list(map(int, input().split()))\n g = 0\n for i in range(1,n):\n if a[i] + a[i-1] >= l:\n g = i\n break\n if g == 0:\n print('Impossible')\n return\n print('Possible')\n for i in range(1,g):\n print(i)\n for i in range(n-1,g-1,-1):\n print(i)\n\nf()", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time", "math", "string", "itertools", "fractions", "heapq", "collections", "re", "array", "bisect", "sys", "random", "time", "sys.setrecursionlimit(10**7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**7", "10", "7", "inf = 10**10", "inf", "10**10", "10", "10", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "def f():\n n,l = list(map(int, input().split()))\n a = list(map(int, input().split()))\n g = 0\n for i in range(1,n):\n if a[i] + a[i-1] >= l:\n g = i\n break\n if g == 0:\n print('Impossible')\n return\n print('Possible')\n for i in range(1,g):\n print(i)\n for i in range(n-1,g-1,-1):\n print(i)", "f", "n,l = list(map(int, input().split()))", "n", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "g = 0", "g", "0", "for i in range(1,n):\n if a[i] + a[i-1] >= l:\n g = i\n break\n ", "i", "range(1,n)", "range", "1", "n", "if a[i] + a[i-1] >= l:\n g = 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", "g = i", "g", "i", "break", "if g == 0:\n print('Impossible')\n return\n ", "g == 0", "g", "0", "print('Impossible')", "print", "'Impossible'", "return", "print('Possible')", "print", "'Possible'", "for i in range(1,g):\n print(i)\n ", "i", "range(1,g)", "range", "1", "g", "print(i)", "print", "i", "for i in range(n-1,g-1,-1):\n print(i)", "i", "range(n-1,g-1,-1)", "range", "n-1", "n", "1", "g-1", "g", "1", "-1", "print(i)", "print", "i", "f()", "f", "def f():\n n,l = list(map(int, input().split()))\n a = list(map(int, input().split()))\n g = 0\n for i in range(1,n):\n if a[i] + a[i-1] >= l:\n g = i\n break\n if g == 0:\n print('Impossible')\n return\n print('Possible')\n for i in range(1,g):\n print(i)\n for i in range(n-1,g-1,-1):\n print(i)", "def f():\n n,l = list(map(int, input().split()))\n a = list(map(int, input().split()))\n g = 0\n for i in range(1,n):\n if a[i] + a[i-1] >= l:\n g = i\n break\n if g == 0:\n print('Impossible')\n return\n print('Possible')\n for i in range(1,g):\n print(i)\n for i in range(n-1,g-1,-1):\n print(i)", "f", "mod = 10**9 + 7", "10**9 + 7", "mod", "inf = 10**10", "10**10", "inf" ]

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

[ [ 5, 4 ], [ 5, 15 ], [ 18, 17 ], [ 17, 34 ], [ 17, 36 ], [ 45, 44 ], [ 48, 47 ], [ 44, 50 ], [ 47, 53 ], [ 15, 54 ], [ 57, 56 ], [ 44, 60 ], [ 47, 62 ], [ 67, 66 ], [ 56, 70 ], [ 66, 72 ], [ 75, 74 ], [ 79, 78 ], [ 4, 82 ], [ 56, 84 ], [ 78, 87 ], [ 90, 89 ], [ 89, 100 ], [ 74, 100 ], [ 103, 102 ], [ 115, 112 ] ]

[ "# AGC002C - Knot Puzzle\ndef main():\n N, L = tuple(map(int, input().split()))\n A = tuple(map(int, input().split()))\n B = [i + j for i, j in zip(A, A[1:])]\n x = max(B)\n if x >= L:\n idx = B.index(x) + 1\n ans = [i for i in range(1, idx)] \n ans += [i for i in range(N - 1, idx, -1)] + [idx]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")\n else:\n print(\"Impossible\")\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n N, L = tuple(map(int, input().split()))\n A = tuple(map(int, input().split()))\n B = [i + j for i, j in zip(A, A[1:])]\n x = max(B)\n if x >= L:\n idx = B.index(x) + 1\n ans = [i for i in range(1, idx)] \n ans += [i for i in range(N - 1, idx, -1)] + [idx]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")\n else:\n print(\"Impossible\")", "main", "N, L = tuple(map(int, input().split()))", "N", "tuple(map(int, input().split()))", "tuple", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "A = tuple(map(int, input().split()))", "A", "tuple(map(int, input().split()))", "tuple", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "i + j for i, j in zip(A, A[1:])", "for i, j in zip(A, A[1:])", "i", "j", "zip(A, A[1:])", "zip", "A", "A[1:]", "A", "1:", "1", "for i, j in zip(A, A[1:])", "i + j", "i", "j", "B = [i + j for i, j in zip(A, A[1:])]", "B", "[i + j for i, j in zip(A, A[1:])]", "x = max(B)", "x", "max(B)", "max", "B", "if x >= L:\n idx = B.index(x) + 1\n ans = [i for i in range(1, idx)] \n ans += [i for i in range(N - 1, idx, -1)] + [idx]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")\n else:\n print(\"Impossible\")", "x >= L", "x", "L", "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)]", "ans", "[i for i in range(1, idx)]", "i for i in range(N - 1, idx, -1)", "for i in range(N - 1, idx, -1)", "i", "range(N - 1, idx, -1)", "range", "N - 1", "N", "1", "idx", "-1", "for i in range(N - 1, idx, -1)", "i", "ans += [i for i in range(N - 1, idx, -1)] + [idx]", "ans", "[i for i in range(N - 1, idx, -1)] + [idx]", "[i for i in range(N - 1, idx, -1)]", "[idx]", "idx", "print(\"Possible\")", "print", "\"Possible\"", "print(*ans, sep=\"\\n\")", "print", "*ans", "ans", "sep=\"\\n\"", "sep", "\"\\n\"", "print(\"Impossible\")", "print", "\"Impossible\"", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n N, L = tuple(map(int, input().split()))\n A = tuple(map(int, input().split()))\n B = [i + j for i, j in zip(A, A[1:])]\n x = max(B)\n if x >= L:\n idx = B.index(x) + 1\n ans = [i for i in range(1, idx)] \n ans += [i for i in range(N - 1, idx, -1)] + [idx]\n print(\"Possible\")\n print(*ans, sep=\"\\n\")\n else:\n print(\"Impossible\")", "def main():\n N, L = tuple(map(int, input().split()))\n A = tuple(map(int, input().split()))\n B = [i + j for i, j in zip(A, A[1:])]\n x = max(B)\n if x >= L:\n idx = B.index(x) + 1\n ans = [i for i in range(1, idx)] \n ans += [i for i in range(N - 1, idx, -1)] + [idx]\n print(\"Possible\")\n print(*ans, 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, 0, 13, 4, 13, 13, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 2, 4, 13, 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, 17, 4, 13, 4, 13, 17, 28, 13, 4, 13, 17, 13, 4, 13, 13, 28, 13, 4, 13, 2, 4, 13, 13, 2, 13, 17, 4, 13, 2, 2, 4, 13, 13, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13 ]

[ [ 113, 2 ], [ 113, 11 ], [ 116, 13 ], [ 125, 25 ], [ 117, 28 ], [ 128, 30 ], [ 119, 33 ], [ 37, 36 ], [ 117, 42 ], [ 117, 48 ], [ 36, 49 ], [ 117, 51 ], [ 36, 53 ], [ 114, 55 ], [ 122, 57 ], [ 131, 60 ], [ 36, 62 ], [ 123, 67 ], [ 129, 67 ], [ 79, 78 ], [ 132, 82 ], [ 120, 82 ], [ 78, 85 ], [ 88, 87 ], [ 117, 93 ], [ 117, 103 ], [ 87, 104 ], [ 132, 108 ], [ 120, 108 ], [ 113, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ] ]

[ "N, L = map(int, input().split())\na = list(map(int, input().split()))\nS = sum(a)\n\nt = 0\nm = 0\nfor k in range(len(a)-1):\n if a[k]+a[k+1]>=L:\n t = 1\n m = k+1\n break\nif t == 0:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")\n for k in range(1,m):\n print(k)\n for l in range(len(a)-(k+2)):\n print(len(a)-l-1)\n print(m)", "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 = sum(a)", "S", "sum(a)", "sum", "a", "t = 0", "t", "0", "m = 0", "m", "0", "for k in range(len(a)-1):\n if a[k]+a[k+1]>=L:\n t = 1\n m = k+1\n break", "k", "range(len(a)-1)", "range", "len(a)-1", "len(a)", "len", "a", "1", "if a[k]+a[k+1]>=L:\n t = 1\n m = k+1\n break", "a[k]+a[k+1]>=L", "a[k]+a[k+1]", "a[k]", "a", "k", "a[k+1]", "a", "k+1", "k", "1", "L", "t = 1", "t", "1", "m = k+1", "m", "k+1", "k", "1", "break", "if t == 0:\n print(\"Impossible\")\n exit()\nelse:\n print(\"Possible\")\n for k in range(1,m):\n print(k)\n for l in range(len(a)-(k+2)):\n print(len(a)-l-1)\n print(m)", "t == 0", "t", "0", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for k in range(1,m):\n print(k)\n ", "k", "range(1,m)", "range", "1", "m", "print(k)", "print", "k", "for l in range(len(a)-(k+2)):\n print(len(a)-l-1)\n ", "l", "range(len(a)-(k+2))", "range", "len(a)-(k+2)", "len(a)", "len", "a", "k+2", "k", "2", "print(len(a)-l-1)", "print", "len(a)-l-1", "len(a)-l", "len(a)", "len", "a", "l", "1", "print(m)", "print", "m", "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", "m = 0", "0", "m", "t = 1", "1", "t", "S = sum(a)", "sum(a)", "S", "t = 0", "0", "t", "m = k+1", "k+1", "m" ]

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

[ [ 7, 6 ], [ 14, 13 ], [ 6, 20 ], [ 14, 22 ], [ 26, 25 ], [ 6, 29 ], [ 25, 34 ], [ 37, 36 ], [ 40, 39 ], [ 13, 43 ], [ 36, 49 ], [ 39, 50 ], [ 36, 52 ], [ 39, 54 ], [ 22, 56 ], [ 62, 61 ], [ 39, 64 ], [ 67, 66 ], [ 39, 72 ], [ 13, 75 ], [ 39, 80 ], [ 93, 90 ] ]

[ "import sys\n\ndef solve():\n input = sys.stdin.readline\n N, L = map(int, input().split())\n A = [int(a) for a in input().split()]\n for i in range(N - 1):\n if A[i] + A[i+1] >= L:\n print(\"Possible\")\n for k in range(i): print(k + 1)\n for k in reversed(range(i + 1, N - 1)): print(k + 1)\n print(i + 1)\n break\n else: print(\"Impossible\")\n\n return 0\n\nif __name__ == \"__main__\":\n solve()", "import sys", "sys", "def solve():\n input = sys.stdin.readline\n N, L = map(int, input().split())\n A = [int(a) for a in input().split()]\n for i in range(N - 1):\n if A[i] + A[i+1] >= L:\n print(\"Possible\")\n for k in range(i): print(k + 1)\n for k in reversed(range(i + 1, N - 1)): print(k + 1)\n print(i + 1)\n break\n else: print(\"Impossible\")\n\n return 0", "solve", "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", "int(a) for a in input().split()", "for a in input().split()", "a", "input().split()", "().split", "()", "input", "split", "for a in input().split()", "int(a)", "int", "a", "A = [int(a) for a in input().split()]", "A", "[int(a) for a in input().split()]", "for i in range(N - 1):\n if A[i] + A[i+1] >= L:\n print(\"Possible\")\n for k in range(i): print(k + 1)\n for k in reversed(range(i + 1, N - 1)): print(k + 1)\n print(i + 1)\n break\n else: print(\"Impossible\")\n\n ", "i", "range(N - 1)", "range", "N - 1", "N", "1", "if A[i] + A[i+1] >= L:\n print(\"Possible\")\n for k in range(i): print(k + 1)\n for k in reversed(range(i + 1, N - 1)): print(k + 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 k in range(i): print(k + 1)\n ", "k", "range(i)", "range", "i", "for k in reversed(range(i + 1, N - 1)): print(k + 1)\n ", "k", "reversed(range(i + 1, N - 1))", "reversed", "range(i + 1, N - 1)", "range", "i + 1", "i", "1", "N - 1", "N", "1", "print(i + 1)", "print", "i + 1", "i", "1", "break", "return 0", "0", "if __name__ == \"__main__\":\n solve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "solve()", "solve", "def solve():\n input = sys.stdin.readline\n N, L = map(int, input().split())\n A = [int(a) for a in input().split()]\n for i in range(N - 1):\n if A[i] + A[i+1] >= L:\n print(\"Possible\")\n for k in range(i): print(k + 1)\n for k in reversed(range(i + 1, N - 1)): print(k + 1)\n print(i + 1)\n break\n else: print(\"Impossible\")\n\n return 0", "def solve():\n input = sys.stdin.readline\n N, L = map(int, input().split())\n A = [int(a) for a in input().split()]\n for i in range(N - 1):\n if A[i] + A[i+1] >= L:\n print(\"Possible\")\n for k in range(i): print(k + 1)\n for k in reversed(range(i + 1, N - 1)): print(k + 1)\n print(i + 1)\n break\n else: print(\"Impossible\")\n\n return 0", "solve" ]

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

[ [ 95, 2 ], [ 95, 11 ], [ 86, 13 ], [ 26, 25 ], [ 96, 29 ], [ 87, 35 ], [ 25, 36 ], [ 87, 38 ], [ 25, 40 ], [ 90, 42 ], [ 92, 53 ], [ 96, 69 ], [ 81, 80 ], [ 93, 80 ], [ 80, 84 ], [ 86, 87 ], [ 95, 90 ], [ 92, 93 ], [ 95, 96 ] ]

[ "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 break\nelse:\n print(\"Impossible\")\n exit()\nli = list(range(1,i+1))+list(range(n-1,i+1,-1))+[i+1]\nfor x in li:\n print(x)", "n,l = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(n-1):\n if a[i] + a[i+1] >= l:\n print(\"Possible\")\n break\nelse:\n print(\"Impossible\")\n exit()", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i] + a[i+1] >= l:\n print(\"Possible\")\n 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\"", "break", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "li = list(range(1,i+1))+list(range(n-1,i+1,-1))+[i+1]", "li", "list(range(1,i+1))+list(range(n-1,i+1,-1))+[i+1]", "list(range(1,i+1))+list(range(n-1,i+1,-1))", "list(range(1,i+1))", "list", "range(1,i+1)", "range", "1", "i+1", "i", "1", "list(range(n-1,i+1,-1))", "list", "range(n-1,i+1,-1)", "range", "n-1", "n", "1", "i+1", "i", "1", "-1", "[i+1]", "i+1", "i", "1", "for x in li:\n print(x)", "x", "li", "print(x)", "print", "x", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "l = map(int,input().split())", "map(int,input().split())", "l", "li = list(range(1,i+1))+list(range(n-1,i+1,-1))+[i+1]", "list(range(1,i+1))+list(range(n-1,i+1,-1))+[i+1]", "li", "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, 17, 13, 14, 40, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 0, 13, 17, 3, 14, 13, 4, 13, 17, 28, 13, 4, 13, 17, 13, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 13, 17, 4, 13, 13, 4, 13, 13, 4, 13, 17, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 91, 2 ], [ 91, 11 ], [ 88, 13 ], [ 94, 25 ], [ 29, 28 ], [ 92, 32 ], [ 89, 37 ], [ 28, 39 ], [ 89, 42 ], [ 28, 43 ], [ 86, 44 ], [ 82, 46 ], [ 56, 55 ], [ 55, 62 ], [ 65, 64 ], [ 92, 68 ], [ 64, 74 ], [ 82, 83 ], [ 91, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ] ]

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

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

[ [ 102, 2 ], [ 102, 13 ], [ 96, 15 ], [ 90, 27 ], [ 31, 30 ], [ 94, 34 ], [ 97, 40 ], [ 30, 41 ], [ 97, 43 ], [ 30, 45 ], [ 103, 47 ], [ 99, 49 ], [ 30, 50 ], [ 100, 54 ], [ 91, 54 ], [ 66, 65 ], [ 100, 68 ], [ 91, 68 ], [ 65, 72 ], [ 76, 75 ], [ 100, 80 ], [ 91, 80 ], [ 94, 82 ], [ 75, 87 ], [ 90, 91 ], [ 102, 94 ], [ 96, 97 ], [ 30, 99 ], [ 99, 100 ], [ 102, 103 ] ]

[ "\nn, length = list(map(int, input().split()))\nnums = list(map(int, input().split()))\n\nidx = -1\nfor i in range(n-1):\n if nums[i] + nums[i+1] >= length:\n idx = i\n break\nif idx < 0:\n print('Impossible')\n exit()\n\nprint('Possible')\nfor i in range(idx):\n print(i+1)\nfor i in reversed(range(idx, n-1)):\n print(i+1)\n", "n, length = list(map(int, input().split()))", "n", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "length", "nums = list(map(int, input().split()))", "nums", "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 nums[i] + nums[i+1] >= length:\n idx = i\n break", "i", "range(n-1)", "range", "n-1", "n", "1", "if nums[i] + nums[i+1] >= length:\n idx = i\n break", "nums[i] + nums[i+1] >= length", "nums[i] + nums[i+1]", "nums[i]", "nums", "i", "nums[i+1]", "nums", "i+1", "i", "1", "length", "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'", "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 reversed(range(idx, n-1)):\n print(i+1)", "i", "reversed(range(idx, n-1))", "reversed", "range(idx, n-1)", "range", "idx", "n-1", "n", "1", "print(i+1)", "print", "i+1", "i", "1", "idx = -1", "-1", "idx", "n, length = list(map(int, input().split()))", "list(map(int, input().split()))", "n", "nums = list(map(int, input().split()))", "list(map(int, input().split()))", "nums", "idx = i", "i", "idx", "length = list(map(int, input().split()))", "list(map(int, input().split()))", "length" ]

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

[ [ 82, 2 ], [ 82, 11 ], [ 15, 14 ], [ 14, 23 ], [ 85, 25 ], [ 29, 28 ], [ 83, 32 ], [ 86, 37 ], [ 28, 39 ], [ 86, 42 ], [ 28, 43 ], [ 80, 44 ], [ 50, 49 ], [ 28, 54 ], [ 83, 56 ], [ 49, 61 ], [ 64, 63 ], [ 28, 68 ], [ 63, 72 ], [ 82, 80 ], [ 82, 83 ], [ 85, 86 ] ]

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

[ [ 118, 2 ], [ 118, 11 ], [ 106, 13 ], [ 109, 25 ], [ 121, 28 ], [ 119, 29 ], [ 32, 31 ], [ 119, 35 ], [ 110, 39 ], [ 113, 39 ], [ 107, 42 ], [ 31, 43 ], [ 107, 45 ], [ 31, 47 ], [ 112, 50 ], [ 107, 53 ], [ 31, 54 ], [ 107, 56 ], [ 31, 58 ], [ 115, 61 ], [ 31, 62 ], [ 113, 65 ], [ 110, 65 ], [ 104, 66 ], [ 75, 74 ], [ 116, 77 ], [ 122, 77 ], [ 74, 81 ], [ 85, 84 ], [ 119, 88 ], [ 116, 90 ], [ 122, 90 ], [ 84, 95 ], [ 116, 100 ], [ 122, 100 ], [ 118, 104 ], [ 106, 107 ], [ 109, 110 ], [ 112, 113 ], [ 31, 115 ], [ 115, 116 ], [ 118, 119 ], [ 119, 121 ], [ 121, 122 ] ]

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

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

[ [ 103, 2 ], [ 103, 11 ], [ 106, 13 ], [ 27, 26 ], [ 101, 30 ], [ 107, 35 ], [ 26, 36 ], [ 107, 38 ], [ 26, 40 ], [ 112, 43 ], [ 113, 49 ], [ 104, 50 ], [ 97, 58 ], [ 113, 63 ], [ 98, 64 ], [ 110, 64 ], [ 104, 65 ], [ 109, 67 ], [ 71, 70 ], [ 110, 73 ], [ 98, 73 ], [ 70, 77 ], [ 81, 80 ], [ 110, 83 ], [ 98, 83 ], [ 101, 85 ], [ 101, 92 ], [ 80, 93 ], [ 110, 94 ], [ 98, 94 ], [ 97, 98 ], [ 103, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ], [ 112, 113 ] ]

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

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

[ [ 120, 2 ], [ 120, 11 ], [ 102, 13 ], [ 103, 26 ], [ 108, 31 ], [ 105, 34 ], [ 38, 37 ], [ 121, 41 ], [ 103, 46 ], [ 37, 47 ], [ 103, 49 ], [ 37, 51 ], [ 109, 53 ], [ 115, 53 ], [ 114, 55 ], [ 103, 58 ], [ 37, 59 ], [ 103, 61 ], [ 37, 63 ], [ 117, 66 ], [ 37, 67 ], [ 115, 70 ], [ 109, 70 ], [ 112, 71 ], [ 77, 76 ], [ 118, 80 ], [ 106, 80 ], [ 76, 83 ], [ 86, 85 ], [ 121, 89 ], [ 118, 92 ], [ 106, 92 ], [ 85, 97 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 120, 112 ], [ 114, 115 ], [ 37, 117 ], [ 117, 118 ], [ 120, 121 ] ]

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

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

[ [ 7, 6 ], [ 10, 9 ], [ 47, 17 ], [ 47, 23 ], [ 9, 24 ], [ 6, 28 ], [ 9, 30 ], [ 9, 33 ], [ 47, 35 ], [ 9, 36 ], [ 6, 39 ], [ 47, 42 ], [ 9, 43 ], [ 6, 45 ], [ 47, 47 ], [ 173, 49 ], [ 173, 60 ], [ 176, 62 ], [ 167, 74 ], [ 158, 77 ], [ 81, 80 ], [ 174, 84 ], [ 168, 88 ], [ 165, 88 ], [ 177, 91 ], [ 80, 92 ], [ 177, 94 ], [ 80, 96 ], [ 164, 99 ], [ 177, 102 ], [ 80, 103 ], [ 177, 105 ], [ 80, 107 ], [ 179, 110 ], [ 80, 112 ], [ 165, 116 ], [ 168, 116 ], [ 162, 117 ], [ 128, 127 ], [ 180, 131 ], [ 159, 131 ], [ 127, 136 ], [ 140, 139 ], [ 174, 144 ], [ 180, 145 ], [ 159, 145 ], [ 174, 151 ], [ 139, 153 ], [ 180, 156 ], [ 159, 156 ], [ 158, 159 ], [ 173, 162 ], [ 164, 165 ], [ 167, 168 ], [ 173, 174 ], [ 176, 177 ], [ 179, 180 ] ]

[ "import math\n\ndef make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n\n # divisors.sort()\n return divisors\n\n#a = list(map(int, input().split()))\n\n#####################################\n\n\n#4:25\nn,k = list(map(int, input().split()))\na = list(map(int, input().split()))\nmaxv=0\nmaxid=-1\nfor i in range(n-1):\n if(maxv<a[i]+a[i+1]):\n maxv=a[i]+a[i+1]\n maxid=i+1\n\nif(maxv<k):\n print(\"Impossible\")\n exit()\nprint(\"Possible\")\nfor j in range(maxid-1):\n print(j+1)\n \nfor j in range(n-maxid-1):\n print(n-1-j)\n \nprint(maxid)", "import math", "math", "def make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n\n # divisors.sort()\n return divisors\n\n#a = list(map(int, input().split()))\n\n#####################################\n\n\n#4:25", "make_divisors", "divisors = []", "divisors", "[]", "for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n\n # divisors.sort()\n ", "i", "range(1, int(n**0.5)+1)", "range", "1", "int(n**0.5)+1", "int(n**0.5)", "int", "n**0.5", "n", "0.5", "1", "if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n\n # divisors.sort()\n ", "n % i == 0", "n % i", "n", "i", "0", "divisors.append(i)", "divisors.append", "divisors", "append", "i", "if i != n // i:\n divisors.append(n//i)\n\n # divisors.sort()\n ", "i != n // i", "i", "n // i", "n", "i", "divisors.append(n//i)", "divisors.append", "divisors", "append", "n//i", "n", "i", "return divisors", "divisors", "n", "n", "n,k = list(map(int, input().split()))", "n", "list(map(int, input().split()))", "list", "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", "maxv=0", "maxv", "0", "maxid=-1", "maxid", "-1", "for i in range(n-1):\n if(maxv<a[i]+a[i+1]):\n maxv=a[i]+a[i+1]\n maxid=i+1", "i", "range(n-1)", "range", "n-1", "n", "1", "if(maxv<a[i]+a[i+1]):\n maxv=a[i]+a[i+1]\n maxid=i+1", "maxv<a[i]+a[i+1]", "maxv", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "maxv=a[i]+a[i+1]", "maxv", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "maxid=i+1", "maxid", "i+1", "i", "1", "if(maxv<k):\n print(\"Impossible\")\n exit()", "maxv<k", "maxv", "k", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for j in range(maxid-1):\n print(j+1)\n ", "j", "range(maxid-1)", "range", "maxid-1", "maxid", "1", "print(j+1)", "print", "j+1", "j", "1", "for j in range(n-maxid-1):\n print(n-1-j)\n ", "j", "range(n-maxid-1)", "range", "n-maxid-1", "n-maxid", "n", "maxid", "1", "print(n-1-j)", "print", "n-1-j", "n-1", "n", "1", "j", "print(maxid)", "print", "maxid", "maxid=-1", "-1", "maxid", "k = list(map(int, input().split()))", "list(map(int, input().split()))", "k", "maxv=a[i]+a[i+1]", "a[i]+a[i+1]", "maxv", "maxv=0", "0", "maxv", "def make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n\n # divisors.sort()\n return divisors\n\n#a = list(map(int, input().split()))\n\n#####################################\n\n\n#4:25", "def make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n\n # divisors.sort()\n return divisors\n\n#a = list(map(int, input().split()))\n\n#####################################\n\n\n#4:25", "make_divisors", "n,k = list(map(int, input().split()))", "list(map(int, input().split()))", "n", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "maxid=i+1", "i+1", "maxid" ]

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 13, 3, 14, 40, 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, 4, 13, 17, 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 ], [ 95, 40 ], [ 92, 46 ], [ 36, 47 ], [ 92, 49 ], [ 36, 51 ], [ 98, 53 ], [ 103, 55 ], [ 36, 56 ], [ 104, 60 ], [ 101, 60 ], [ 67, 66 ], [ 104, 69 ], [ 101, 69 ], [ 66, 73 ], [ 77, 76 ], [ 95, 80 ], [ 104, 82 ], [ 101, 82 ], [ 76, 86 ], [ 91, 92 ], [ 97, 95 ], [ 97, 98 ], [ 100, 101 ], [ 36, 103 ], [ 103, 104 ] ]

[ "N,L=[int(i) for i in input().split()]\nA=[int(i) for i in input().split()]\n\nres=-1\nfor i in range(N-1):\n\tif A[i]+A[i+1]>=L:\n\t\tres=i\n\t\tbreak\nif res!=-1:\n\tprint(\"Possible\")\n\tfor i in range(res):\n\t\tprint(i+1)\n\tfor i in range(N-1,res,-1):\n\t\tprint(i)\nelse:\n\tprint(\"Impossible\")", "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()]", "res=-1", "res", "-1", "for i in range(N-1):\n\tif A[i]+A[i+1]>=L:\n\t\tres=i\n\t\tbreak", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i]+A[i+1]>=L:\n\t\tres=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", "res=i", "res", "i", "break", "if res!=-1:\n\tprint(\"Possible\")\n\tfor i in range(res):\n\t\tprint(i+1)\n\tfor i in range(N-1,res,-1):\n\t\tprint(i)\nelse:\n\tprint(\"Impossible\")", "res!=-1", "res", "-1", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(res):\n\t\tprint(i+1)\n\t", "i", "range(res)", "range", "res", "print(i+1)", "print", "i+1", "i", "1", "for i in range(N-1,res,-1):\n\t\tprint(i)", "i", "range(N-1,res,-1)", "range", "N-1", "N", "1", "res", "-1", "print(i)", "print", "i", "print(\"Impossible\")", "print", "\"Impossible\"", "A=[int(i) for i in input().split()]", "[int(i) for i in input().split()]", "A", "N,L=[int(i) for i in input().split()]", "[int(i) for i in input().split()]", "N", "L=[int(i) for i in input().split()]", "[int(i) for i in input().split()]", "L", "res=-1", "-1", "res", "res=i", "i", "res" ]

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

[ [ 26, 25 ], [ 140, 31 ], [ 35, 35 ], [ 151, 44 ], [ 127, 49 ], [ 148, 59 ], [ 140, 61 ], [ 148, 62 ], [ 130, 64 ], [ 155, 66 ], [ 69, 68 ], [ 137, 72 ], [ 149, 75 ], [ 131, 78 ], [ 68, 79 ], [ 131, 81 ], [ 68, 83 ], [ 124, 86 ], [ 68, 87 ], [ 99, 98 ], [ 125, 102 ], [ 98, 105 ], [ 108, 107 ], [ 137, 111 ], [ 125, 114 ], [ 107, 119 ], [ 68, 124 ], [ 124, 125 ], [ 127, 128 ], [ 130, 131 ], [ 148, 137 ], [ 148, 149 ], [ 151, 152 ] ]

[ "import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd\nfrom itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom bisect import bisect, bisect_left, insort, insort_left\nfrom heapq import heappush, heappop\nfrom functools import reduce\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef TUPLE(): return tuple(map(int, input().split()))\ndef ZIP(n): return zip(*(MAP() for _ in range(n)))\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10 ** 9 + 7 \n#mod = 998244353\nfrom decimal import *\nimport numpy as np\n#decimal.getcontext().prec = 10\n\nN, L = MAP()\na = LIST()\n\nfor i in range(1, N):\n\tif L <= a[i] + a[i-1]:\n\t\tidx = i\n\t\tbreak\nelse:\n\tprint(\"Impossible\")\n\texit()\n\nprint(\"Possible\")\n\nfor i in range(1, idx):\n\tprint(i)\n\nfor i in range(N-1, idx-1, -1):\n\tprint(i)", "import sys, re", "sys", "re", "from collections import deque, defaultdict, Counter", "from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd", "from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby", "from operator import itemgetter, mul", "from copy import deepcopy", "from string import ascii_lowercase, ascii_uppercase, digits", "from bisect import bisect, bisect_left, insort, insort_left", "from heapq import heappush, heappop", "from functools import reduce", "def input(): return sys.stdin.readline().strip()", "input", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "MAP", "def LIST(): return list(map(int, input().split()))", "LIST", "def TUPLE(): return tuple(map(int, input().split()))", "TUPLE", "MAP() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "MAP()", "MAP", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "n", "n", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "mod = 10 ** 9 + 7", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "from decimal import *", "import numpy as np", "numpy", "N, L = MAP()", "N", "MAP()", "MAP", "L", "a = LIST()", "a", "LIST()", "LIST", "for i in range(1, N):\n\tif L <= a[i] + a[i-1]:\n\t\tidx = i\n\t\tbreak\nelse:\n\tprint(\"Impossible\")\n\texit()", "i", "range(1, N)", "range", "1", "N", "if L <= a[i] + a[i-1]:\n\t\tidx = i\n\t\tbreak", "L <= a[i] + a[i-1]", "L", "a[i] + a[i-1]", "a[i]", "a", "i", "a[i-1]", "a", "i-1", "i", "1", "idx = i", "idx", "i", "break", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1, idx):\n\tprint(i)", "i", "range(1, idx)", "range", "1", "idx", "print(i)", "print", "i", "for i in range(N-1, idx-1, -1):\n\tprint(i)", "i", "range(N-1, idx-1, -1)", "range", "N-1", "N", "1", "idx-1", "idx", "1", "-1", "print(i)", "print", "i", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "idx = i", "i", "idx", "mod = 10 ** 9 + 7", "10 ** 9 + 7", "mod", "a = LIST()", "LIST()", "a", "def TUPLE(): return tuple(map(int, input().split()))", "def TUPLE(): return tuple(map(int, input().split()))", "TUPLE", "N, L = MAP()", "MAP()", "N", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP", "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", "L = MAP()", "MAP()", "L", "INF = float('inf')", "float('inf')", "INF", "def LIST(): return list(map(int, input().split()))", "def LIST(): return list(map(int, input().split()))", "LIST" ]

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

[ [ 123, 4 ], [ 21, 20 ], [ 28, 27 ], [ 130, 29 ], [ 28, 30 ], [ 33, 32 ], [ 118, 34 ], [ 37, 36 ], [ 40, 39 ], [ 27, 43 ], [ 47, 46 ], [ 32, 49 ], [ 39, 50 ], [ 32, 52 ], [ 39, 54 ], [ 46, 58 ], [ 30, 59 ], [ 62, 61 ], [ 39, 62 ], [ 61, 66 ], [ 36, 66 ], [ 76, 75 ], [ 79, 78 ], [ 61, 81 ], [ 36, 81 ], [ 75, 84 ], [ 78, 86 ], [ 89, 88 ], [ 27, 92 ], [ 61, 94 ], [ 36, 94 ], [ 75, 98 ], [ 88, 100 ], [ 75, 103 ], [ 61, 105 ], [ 36, 105 ], [ 108, 107 ], [ 75, 107 ], [ 107, 112 ], [ 127, 115 ], [ 123, 124 ] ]

[ "import sys\ninput = sys.stdin.readline\n\ndef I(): return int(input())\ndef MI(): return map(int, input().split())\ndef LI(): return list(map(int, input().split()))\n\n\"\"\"\n逆順に見る，2つで長さL以上のものが作れればOKそうでなければ不可\n\n最初dequeで解こうとしたけど，純粋に間違ってた\n\"\"\"\ndef main():\n mod=10**9+7\n N,L=MI()\n A=LI()\n t=-1 #最後に外すとこ\n for i in range(N-1):\n # 結び目iを見る\n temp=A[i]+A[i+1]\n if temp >= L:\n t=i\n break\n \n if t==-1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n ans=[]\n for i in range(t):\n ans.append(i)\n for i in range(N-2,t,-1):\n ans.append(i)\n ans.append(t)\n \n for i in ans:\n print(i+1)\n \n \n \n \n\nmain()", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def I(): return int(input())", "I", "def MI(): return map(int, input().split())", "MI", "def LI(): return list(map(int, input().split()))", "LI", "\"\"\"\n逆順に見る，2つで長さL以上のものが作れればOKそうでなければ不可\n\n最初dequeで解こうとしたけど，純粋に間違ってた\n\"\"\"", "def main():\n mod=10**9+7\n N,L=MI()\n A=LI()\n t=-1 #最後に外すとこ\n for i in range(N-1):\n # 結び目iを見る\n temp=A[i]+A[i+1]\n if temp >= L:\n t=i\n break\n \n if t==-1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n ans=[]\n for i in range(t):\n ans.append(i)\n for i in range(N-2,t,-1):\n ans.append(i)\n ans.append(t)\n \n for i in ans:\n print(i+1)\n \n \n \n ", "main", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "N,L=MI()", "N", "MI()", "MI", "L", "A=LI()", "A", "LI()", "LI", "t=-1", "t", "-1", "for i in range(N-1):\n # 結び目iを見る\n temp=A[i]+A[i+1]\n if temp >= L:\n t=i\n break\n \n ", "i", "range(N-1)", "range", "N-1", "N", "1", "temp=A[i]+A[i+1]", "temp", "A[i]+A[i+1]", "A[i]", "A", "i", "A[i+1]", "A", "i+1", "i", "1", "if temp >= L:\n t=i\n break\n \n ", "temp >= L", "temp", "L", "t=i", "t", "i", "break", "if t==-1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n ans=[]\n for i in range(t):\n ans.append(i)\n for i in range(N-2,t,-1):\n ans.append(i)\n ans.append(t)\n \n for i in ans:\n print(i+1)\n \n \n \n ", "t==-1", "t", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "ans=[]", "ans", "[]", "for i in range(t):\n ans.append(i)\n ", "i", "range(t)", "range", "t", "ans.append(i)", "ans.append", "ans", "append", "i", "for i in range(N-2,t,-1):\n ans.append(i)\n ", "i", "range(N-2,t,-1)", "range", "N-2", "N", "2", "t", "-1", "ans.append(i)", "ans.append", "ans", "append", "i", "ans.append(t)", "ans.append", "ans", "append", "t", "for i in ans:\n print(i+1)\n \n \n \n ", "i", "ans", "print(i+1)", "print", "i+1", "i", "1", "main()", "main", "def LI(): return list(map(int, input().split()))", "def LI(): return list(map(int, input().split()))", "LI", "def I(): return int(input())", "def I(): return int(input())", "I", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def main():\n mod=10**9+7\n N,L=MI()\n A=LI()\n t=-1 #最後に外すとこ\n for i in range(N-1):\n # 結び目iを見る\n temp=A[i]+A[i+1]\n if temp >= L:\n t=i\n break\n \n if t==-1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n ans=[]\n for i in range(t):\n ans.append(i)\n for i in range(N-2,t,-1):\n ans.append(i)\n ans.append(t)\n \n for i in ans:\n print(i+1)\n \n \n \n ", "def main():\n mod=10**9+7\n N,L=MI()\n A=LI()\n t=-1 #最後に外すとこ\n for i in range(N-1):\n # 結び目iを見る\n temp=A[i]+A[i+1]\n if temp >= L:\n t=i\n break\n \n if t==-1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n ans=[]\n for i in range(t):\n ans.append(i)\n for i in range(N-2,t,-1):\n ans.append(i)\n ans.append(t)\n \n for i in ans:\n print(i+1)\n \n \n \n ", "main", "def MI(): return map(int, input().split())", "def MI(): return map(int, input().split())", "MI" ]

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

[ [ 131, 2 ], [ 131, 13 ], [ 122, 15 ], [ 134, 27 ], [ 31, 30 ], [ 132, 34 ], [ 135, 38 ], [ 123, 43 ], [ 30, 44 ], [ 123, 46 ], [ 30, 48 ], [ 125, 52 ], [ 135, 55 ], [ 58, 57 ], [ 65, 64 ], [ 126, 70 ], [ 135, 70 ], [ 129, 73 ], [ 119, 75 ], [ 126, 78 ], [ 135, 78 ], [ 86, 85 ], [ 120, 88 ], [ 85, 92 ], [ 96, 95 ], [ 132, 100 ], [ 120, 102 ], [ 132, 107 ], [ 95, 109 ], [ 120, 113 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ], [ 131, 129 ], [ 131, 132 ], [ 134, 135 ] ]

[ "N,L = list(map(int,input().split()))\n\na = list(map(int,input().split()))\n\na_list = []\nfor i in range(N-1):\n a_list.append([a[i]+a[i+1],i])\n \na_list=sorted(a_list,key=lambda x:x[0],reverse=True)\n\nif a_list[0][0]>=L:\n n=a_list[0][1] \n print(\"Possible\")\n for i in range(n):\n print(i+1)\n for i in range(N-2-n):\n print(N-1-i)\n print(n+1)\nelse:\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", "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_list = []", "a_list", "[]", "for i in range(N-1):\n a_list.append([a[i]+a[i+1],i])\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "a_list.append([a[i]+a[i+1],i])", "a_list.append", "a_list", "append", "[a[i]+a[i+1],i]", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "i", "a_list=sorted(a_list,key=lambda x:x[0],reverse=True)", "a_list", "sorted(a_list,key=lambda x:x[0],reverse=True)", "sorted", "a_list", "key=lambda x:x[0]", "key", "lambda x:x[0]", "x[0]", "x", "0", "x", "reverse=True", "reverse", "True", "if a_list[0][0]>=L:\n n=a_list[0][1] \n print(\"Possible\")\n for i in range(n):\n print(i+1)\n for i in range(N-2-n):\n print(N-1-i)\n print(n+1)\nelse:\n print(\"Impossible\")", "a_list[0][0]>=L", "a_list[0][0]", "[0]", "a_list", "0", "0", "L", "n=a_list[0][1]", "n", "a_list[0][1]", "[0]", "a_list", "0", "1", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(n):\n print(i+1)\n ", "i", "range(n)", "range", "n", "print(i+1)", "print", "i+1", "i", "1", "for i in range(N-2-n):\n print(N-1-i)\n ", "i", "range(N-2-n)", "range", "N-2-n", "N-2", "N", "2", "n", "print(N-1-i)", "print", "N-1-i", "N-1", "N", "1", "i", "print(n+1)", "print", "n+1", "n", "1", "print(\"Impossible\")", "print", "\"Impossible\"", "n=a_list[0][1]", "a_list[0][1]", "n", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "a_list=sorted(a_list,key=lambda x:x[0],reverse=True)", "sorted(a_list,key=lambda x:x[0],reverse=True)", "a_list", "L = list(map(int,input().split()))", "list(map(int,input().split()))", "L", "N,L = list(map(int,input().split()))", "list(map(int,input().split()))", "N", "a_list = []", "[]", "a_list" ]

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

[ [ 108, 2 ], [ 108, 11 ], [ 102, 13 ], [ 111, 25 ], [ 29, 28 ], [ 106, 32 ], [ 112, 36 ], [ 118, 36 ], [ 103, 39 ], [ 28, 40 ], [ 103, 42 ], [ 28, 44 ], [ 117, 47 ], [ 103, 50 ], [ 28, 51 ], [ 103, 53 ], [ 28, 55 ], [ 114, 58 ], [ 28, 59 ], [ 118, 62 ], [ 112, 62 ], [ 109, 63 ], [ 74, 73 ], [ 106, 77 ], [ 73, 80 ], [ 115, 81 ], [ 73, 85 ], [ 88, 87 ], [ 106, 92 ], [ 87, 95 ], [ 115, 96 ], [ 87, 100 ], [ 102, 103 ], [ 108, 106 ], [ 108, 109 ], [ 111, 112 ], [ 28, 114 ], [ 114, 115 ], [ 117, 118 ] ]

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

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

[ [ 97, 2 ], [ 97, 11 ], [ 100, 13 ], [ 103, 25 ], [ 101, 36 ], [ 101, 38 ], [ 98, 46 ], [ 91, 48 ], [ 64, 63 ], [ 92, 67 ], [ 104, 67 ], [ 63, 69 ], [ 94, 71 ], [ 95, 77 ], [ 92, 79 ], [ 104, 79 ], [ 95, 83 ], [ 86, 85 ], [ 97, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ] ]

[ "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+1\n break\nelse:\n print('Impossible')\n exit()\n\nprint('Possible')\nans = [n for n in range(1,last)] + [n for n in range(N-1,last,-1)]\nans.append(last)\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+1\n break\nelse:\n print('Impossible')\n exit()", "i", "(a,b)", "a", "b", "enumerate(zip(A,A[1:]))", "enumerate", "zip(A,A[1:])", "zip", "A", "A[1:]", "A", "1:", "1", "if a+b >= L:\n last = i+1\n break", "a+b >= L", "a+b", "a", "b", "L", "last = i+1", "last", "i+1", "i", "1", "break", "print('Impossible')", "print", "'Impossible'", "exit()", "exit", "print('Possible')", "print", "'Possible'", "n for n in range(1,last)", "for n in range(1,last)", "n", "range(1,last)", "range", "1", "last", "for n in range(1,last)", "n", "ans = [n for n in range(1,last)] + [n for n in range(N-1,last,-1)]", "ans", "[n for n in range(1,last)] + [n for n in range(N-1,last,-1)]", "[n for n in range(1,last)]", "[n for n in range(N-1,last,-1)]", "ans.append(last)", "ans.append", "ans", "append", "last", "print(*ans, sep='\\n')", "print", "*ans", "ans", "sep='\\n'", "sep", "'\\n'", "N,L = map(int,input().split())", "map(int,input().split())", "N", "last = i+1", "i+1", "last", "ans = [n for n in range(1,last)] + [n for n in range(N-1,last,-1)]", "[n for n in range(1,last)] + [n for n in range(N-1,last,-1)]", "ans", "L = map(int,input().split())", "map(int,input().split())", "L", "A = list(map(int,input().split()))", "list(map(int,input().split()))", "A", "last = -1", "-1", "last" ]

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

[ [ 100, 2 ], [ 100, 11 ], [ 15, 14 ], [ 14, 23 ], [ 91, 25 ], [ 94, 28 ], [ 97, 31 ], [ 35, 34 ], [ 101, 38 ], [ 92, 44 ], [ 34, 45 ], [ 92, 47 ], [ 34, 49 ], [ 89, 51 ], [ 95, 54 ], [ 60, 59 ], [ 98, 59 ], [ 59, 63 ], [ 95, 65 ], [ 69, 68 ], [ 98, 75 ], [ 98, 79 ], [ 68, 80 ], [ 95, 82 ], [ 86, 85 ], [ 95, 85 ], [ 100, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ] ]

[ "N, L = map(int, input().split())\nA = [int(a) for a in input().split()]\n\nCanRemain = []\nCutFirst = []\nfor i in range(N-1):\n if A[i] + A[i+1] >= L: CanRemain.append(i+1)\n else: CutFirst.append(i+1)\n\nif not CanRemain: print(\"Impossible\")\nelse:\n print(\"Possible\")\n for num in CutFirst:\n if num < CanRemain[-1]: print(num)\n else: break\n for i in reversed(range(len(CutFirst))):\n if CutFirst[i] > CanRemain[-1]: print(CutFirst[i])\n else: break\n for num in CanRemain: print(num)", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "int(a) for a in input().split()", "for a in input().split()", "a", "input().split()", "().split", "()", "input", "split", "for a in input().split()", "int(a)", "int", "a", "A = [int(a) for a in input().split()]", "A", "[int(a) for a in input().split()]", "CanRemain = []", "CanRemain", "[]", "CutFirst = []", "CutFirst", "[]", "for i in range(N-1):\n if A[i] + A[i+1] >= L: CanRemain.append(i+1)\n else: CutFirst.append(i+1)", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i] + A[i+1] >= L: CanRemain.append(i+1)\n else: CutFirst.append(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", "if not CanRemain: print(\"Impossible\")\nelse:\n print(\"Possible\")\n for num in CutFirst:\n if num < CanRemain[-1]: print(num)\n else: break\n for i in reversed(range(len(CutFirst))):\n if CutFirst[i] > CanRemain[-1]: print(CutFirst[i])\n else: break\n for num in CanRemain: print(num)", "not CanRemain", "CanRemain", "print(\"Possible\")", "print", "\"Possible\"", "for num in CutFirst:\n if num < CanRemain[-1]: print(num)\n else: break\n ", "num", "CutFirst", "if num < CanRemain[-1]: print(num)\n else: break\n ", "num < CanRemain[-1]", "num", "CanRemain[-1]", "CanRemain", "-1", "for i in reversed(range(len(CutFirst))):\n if CutFirst[i] > CanRemain[-1]: print(CutFirst[i])\n else: break\n ", "i", "reversed(range(len(CutFirst)))", "reversed", "range(len(CutFirst))", "range", "len(CutFirst)", "len", "CutFirst", "if CutFirst[i] > CanRemain[-1]: print(CutFirst[i])\n else: break\n ", "CutFirst[i] > CanRemain[-1]", "CutFirst[i]", "CutFirst", "i", "CanRemain[-1]", "CanRemain", "-1", "for num in CanRemain: print(num)", "num", "CanRemain", "L = map(int, input().split())", "map(int, input().split())", "L", "A = [int(a) for a in input().split()]", "[int(a) for a in input().split()]", "A", "CanRemain = []", "[]", "CanRemain", "CutFirst = []", "[]", "CutFirst", "N, L = map(int, input().split())", "map(int, input().split())", "N" ]

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

[ [ 6, 5 ], [ 6, 16 ], [ 19, 18 ], [ 31, 30 ], [ 18, 38 ], [ 18, 42 ], [ 30, 47 ], [ 54, 53 ], [ 30, 56 ], [ 53, 59 ], [ 16, 60 ], [ 69, 68 ], [ 30, 72 ], [ 53, 74 ], [ 78, 77 ], [ 77, 81 ], [ 87, 81 ], [ 68, 82 ], [ 77, 85 ], [ 87, 85 ], [ 88, 87 ], [ 91, 90 ], [ 5, 92 ], [ 90, 96 ], [ 87, 96 ], [ 77, 96 ], [ 102, 96 ], [ 68, 97 ], [ 90, 100 ], [ 87, 100 ], [ 77, 100 ], [ 102, 100 ], [ 103, 102 ], [ 68, 106 ], [ 115, 112 ] ]

[ "#!/usr/bin/env python\n# -*- coding:utf-8 -*-\n\nfrom __future__ import division, print_function, absolute_import, unicode_literals\n\ndef main():\n N, L = list(map(int, input().split()))\n a = list(map(int, input().split()))\n pair_L = []\n for car, cdr in zip(a[:-1], a[1:]):\n pair_L.append(car + cdr)\n maximum = max(pair_L)\n # print(maximum)\n if maximum < L:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n index = pair_L.index(maximum) + 1\n i = 1\n while i < index:\n print(i)\n i += 1\n i = N - 1\n while i > index:\n print(i)\n i -= 1\n print(index)\n\nif __name__ == \"__main__\":\n main()", "from __future__ import division, print_function, absolute_import, unicode_literals", "def main():\n N, L = list(map(int, input().split()))\n a = list(map(int, input().split()))\n pair_L = []\n for car, cdr in zip(a[:-1], a[1:]):\n pair_L.append(car + cdr)\n maximum = max(pair_L)\n # print(maximum)\n if maximum < L:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n index = pair_L.index(maximum) + 1\n i = 1\n while i < index:\n print(i)\n i += 1\n i = N - 1\n while i > index:\n print(i)\n i -= 1\n print(index)", "main", "N, L = list(map(int, input().split()))", "N", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "pair_L = []", "pair_L", "[]", "for car, cdr in zip(a[:-1], a[1:]):\n pair_L.append(car + cdr)\n ", "car", "cdr", "zip(a[:-1], a[1:])", "zip", "a[:-1]", "a", ":-1", "-1", "a[1:]", "a", "1:", "1", "pair_L.append(car + cdr)", "pair_L.append", "pair_L", "append", "car + cdr", "car", "cdr", "maximum = max(pair_L)", "maximum", "max(pair_L)", "max", "pair_L", "if maximum < L:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n index = pair_L.index(maximum) + 1\n i = 1\n while i < index:\n print(i)\n i += 1\n i = N - 1\n while i > index:\n print(i)\n i -= 1\n print(index)", "maximum < L", "maximum", "L", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "index = pair_L.index(maximum) + 1", "index", "pair_L.index(maximum) + 1", "pair_L.index(maximum)", "pair_L.index", "pair_L", "index", "maximum", "1", "i = 1", "i", "1", "while i < index:\n print(i)\n i += 1\n ", "i < index", "i", "index", "print(i)", "print", "i", "i += 1", "i", "1", "i = N - 1", "i", "N - 1", "N", "1", "while i > index:\n print(i)\n i -= 1\n ", "i > index", "i", "index", "print(i)", "print", "i", "i -= 1", "i", "1", "print(index)", "print", "index", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n N, L = list(map(int, input().split()))\n a = list(map(int, input().split()))\n pair_L = []\n for car, cdr in zip(a[:-1], a[1:]):\n pair_L.append(car + cdr)\n maximum = max(pair_L)\n # print(maximum)\n if maximum < L:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n index = pair_L.index(maximum) + 1\n i = 1\n while i < index:\n print(i)\n i += 1\n i = N - 1\n while i > index:\n print(i)\n i -= 1\n print(index)", "def main():\n N, L = list(map(int, input().split()))\n a = list(map(int, input().split()))\n pair_L = []\n for car, cdr in zip(a[:-1], a[1:]):\n pair_L.append(car + cdr)\n maximum = max(pair_L)\n # print(maximum)\n if maximum < L:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n index = pair_L.index(maximum) + 1\n i = 1\n while i < index:\n print(i)\n i += 1\n i = N - 1\n while i > index:\n print(i)\n i -= 1\n print(index)", "main" ]

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

[ [ 17, 14 ], [ 164, 29 ], [ 179, 34 ], [ 176, 39 ], [ 191, 46 ], [ 14, 57 ], [ 191, 63 ], [ 173, 65 ], [ 14, 76 ], [ 188, 83 ], [ 174, 88 ], [ 91, 90 ], [ 167, 93 ], [ 189, 96 ], [ 174, 96 ], [ 189, 100 ], [ 174, 100 ], [ 168, 107 ], [ 186, 109 ], [ 182, 114 ], [ 168, 117 ], [ 170, 120 ], [ 192, 126 ], [ 130, 129 ], [ 183, 132 ], [ 129, 136 ], [ 140, 139 ], [ 183, 145 ], [ 192, 148 ], [ 139, 153 ], [ 183, 158 ], [ 164, 165 ], [ 167, 168 ], [ 170, 171 ], [ 173, 174 ], [ 176, 177 ], [ 179, 180 ], [ 182, 183 ], [ 191, 186 ], [ 188, 189 ], [ 191, 192 ] ]

[ "import os\nimport sys\n\nimport numpy as np\n\nif os.getenv(\"LOCAL\"):\n sys.stdin = open(\"_in.txt\", \"r\")\n\nsys.setrecursionlimit(10 ** 9)\nINF = float(\"inf\")\nIINF = 10 ** 18\nMOD = 10 ** 9 + 7\n# MOD = 998244353\n\n\nN, L = list(map(int, sys.stdin.buffer.readline().split()))\nA = list(map(int, sys.stdin.buffer.readline().split()))\n\nA = np.array(A, dtype=int)\n\ns = A[1:] + A[:-1]\n\nif s.max() >= L:\n print('Possible')\n last = s.argmax()\n ans = list(range(N - 1))\n for i in range(last):\n print(i + 1)\n for i in reversed(range(last + 1, N - 1)):\n print(i + 1)\n print(last + 1)\nelse:\n print('Impossible')", "import os", "os", "import sys", "sys", "import numpy as np", "numpy", "if os.getenv(\"LOCAL\"):\n sys.stdin = open(\"_in.txt\", \"r\")", "os.getenv(\"LOCAL\")", "os.getenv", "os", "getenv", "\"LOCAL\"", "sys.stdin = open(\"_in.txt\", \"r\")", "sys.stdin", "sys", "stdin", "open(\"_in.txt\", \"r\")", "open", "\"_in.txt\"", "\"r\"", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = float(\"inf\")", "INF", "float(\"inf\")", "float", "\"inf\"", "IINF = 10 ** 18", "IINF", "10 ** 18", "10", "18", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "N, L = list(map(int, sys.stdin.buffer.readline().split()))", "N", "list(map(int, sys.stdin.buffer.readline().split()))", "list", "map(int, sys.stdin.buffer.readline().split())", "map", "int", "sys.stdin.buffer.readline().split()", "sys.stdin.buffer.readline().split", "sys.stdin.buffer.readline()", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "split", "L", "A = list(map(int, sys.stdin.buffer.readline().split()))", "A", "list(map(int, sys.stdin.buffer.readline().split()))", "list", "map(int, sys.stdin.buffer.readline().split())", "map", "int", "sys.stdin.buffer.readline().split()", "sys.stdin.buffer.readline().split", "sys.stdin.buffer.readline()", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "split", "A = np.array(A, dtype=int)", "A", "np.array(A, dtype=int)", "np.array", "np", "array", "A", "dtype=int", "dtype", "int", "s = A[1:] + A[:-1]", "s", "A[1:] + A[:-1]", "A[1:]", "A", "1:", "1", "A[:-1]", "A", ":-1", "-1", "if s.max() >= L:\n print('Possible')\n last = s.argmax()\n ans = list(range(N - 1))\n for i in range(last):\n print(i + 1)\n for i in reversed(range(last + 1, N - 1)):\n print(i + 1)\n print(last + 1)\nelse:\n print('Impossible')", "s.max() >= L", "s.max()", "s.max", "s", "max", "L", "print('Possible')", "print", "'Possible'", "last = s.argmax()", "last", "s.argmax()", "s.argmax", "s", "argmax", "ans = list(range(N - 1))", "ans", "list(range(N - 1))", "list", "range(N - 1)", "range", "N - 1", "N", "1", "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 reversed(range(last + 1, N - 1)):\n print(i + 1)\n ", "i", "reversed(range(last + 1, N - 1))", "reversed", "range(last + 1, N - 1)", "range", "last + 1", "last", "1", "N - 1", "N", "1", "print(i + 1)", "print", "i + 1", "i", "1", "print(last + 1)", "print", "last + 1", "last", "1", "print('Impossible')", "print", "'Impossible'", "INF = float(\"inf\")", "float(\"inf\")", "INF", "s = A[1:] + A[:-1]", "A[1:] + A[:-1]", "s", "ans = list(range(N - 1))", "list(range(N - 1))", "ans", "A = list(map(int, sys.stdin.buffer.readline().split()))", "list(map(int, sys.stdin.buffer.readline().split()))", "A", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "IINF = 10 ** 18", "10 ** 18", "IINF", "last = s.argmax()", "s.argmax()", "last", "L = list(map(int, sys.stdin.buffer.readline().split()))", "list(map(int, sys.stdin.buffer.readline().split()))", "L", "A = np.array(A, dtype=int)", "np.array(A, dtype=int)", "A", "N, L = list(map(int, sys.stdin.buffer.readline().split()))", "list(map(int, sys.stdin.buffer.readline().split()))", "N" ]

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

[ [ 98, 2 ], [ 98, 11 ], [ 92, 13 ], [ 89, 28 ], [ 32, 31 ], [ 96, 35 ], [ 93, 40 ], [ 31, 41 ], [ 93, 43 ], [ 31, 45 ], [ 99, 47 ], [ 86, 49 ], [ 31, 50 ], [ 87, 54 ], [ 90, 54 ], [ 63, 62 ], [ 87, 66 ], [ 90, 66 ], [ 62, 69 ], [ 72, 71 ], [ 96, 75 ], [ 87, 77 ], [ 90, 77 ], [ 71, 81 ], [ 87, 84 ], [ 90, 84 ], [ 31, 86 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ], [ 98, 96 ], [ 98, 99 ] ]

[ "n,l = map(int,input().split())\na = [0]+list(map(int,input().split()))\nll = None\nfor i in range(1,n):\n if a[i]+a[i+1] >= l:\n ll = i\n break\n\nif not ll:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,ll):\n print(i)\n for i in range(n-1,ll,-1):\n print(i)\n print(ll)", "n,l = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "a = [0]+list(map(int,input().split()))", "a", "[0]+list(map(int,input().split()))", "[0]", "0", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ll = None", "ll", "None", "for i in range(1,n):\n if a[i]+a[i+1] >= l:\n ll = i\n break", "i", "range(1,n)", "range", "1", "n", "if a[i]+a[i+1] >= l:\n ll = 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", "ll = i", "ll", "i", "break", "if not ll:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(1,ll):\n print(i)\n for i in range(n-1,ll,-1):\n print(i)\n print(ll)", "not ll", "ll", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "for i in range(1,ll):\n print(i)\n ", "i", "range(1,ll)", "range", "1", "ll", "print(i)", "print", "i", "for i in range(n-1,ll,-1):\n print(i)\n ", "i", "range(n-1,ll,-1)", "range", "n-1", "n", "1", "ll", "-1", "print(i)", "print", "i", "print(ll)", "print", "ll", "ll = i", "i", "ll", "ll = None", "None", "ll", "a = [0]+list(map(int,input().split()))", "[0]+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, 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, 0, 13, 17, 3, 14, 2, 13, 17, 4, 13, 17, 4, 13, 17, 0, 13, 17, 0, 13, 4, 13, 4, 13, 2, 13, 17, 13, 17, 0, 13, 4, 13, 4, 13, 17, 13, 28, 13, 13, 4, 13, 13, 28, 13, 13, 4, 13, 13, 4, 13, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 110, 2 ], [ 110, 11 ], [ 116, 13 ], [ 119, 25 ], [ 29, 28 ], [ 111, 32 ], [ 117, 38 ], [ 28, 39 ], [ 117, 41 ], [ 28, 43 ], [ 108, 45 ], [ 113, 47 ], [ 28, 48 ], [ 101, 50 ], [ 102, 55 ], [ 120, 55 ], [ 122, 64 ], [ 104, 67 ], [ 111, 73 ], [ 123, 75 ], [ 114, 75 ], [ 125, 78 ], [ 123, 84 ], [ 114, 84 ], [ 87, 86 ], [ 105, 86 ], [ 86, 90 ], [ 93, 92 ], [ 126, 92 ], [ 92, 96 ], [ 123, 99 ], [ 114, 99 ], [ 101, 102 ], [ 104, 105 ], [ 110, 108 ], [ 110, 111 ], [ 28, 113 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ] ]

[ "N,L = map(int,input().split())\nA = list(map(int,input().split()))\n\nflg = 0\nfor i in range(N-1):\n if A[i] + A[i+1] >= L:\n last = i\n flg = 1\n break\n\nif flg == 0:\n print('Impossible')\nelse:\n print('Possible')\n last += 1\n # x = list(range(last+1,N))\n x = list(range(N-1,last,-1))\n y = list(range(1,last))\n for a in x:\n print(a)\n for a in y:\n print(a)\n\n print(last)", "N,L = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "A = list(map(int,input().split()))", "A", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "flg = 0", "flg", "0", "for i in range(N-1):\n if A[i] + A[i+1] >= L:\n last = i\n flg = 1\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i] + A[i+1] >= L:\n last = i\n flg = 1\n break", "A[i] + A[i+1] >= L", "A[i] + A[i+1]", "A[i]", "A", "i", "A[i+1]", "A", "i+1", "i", "1", "L", "last = i", "last", "i", "flg = 1", "flg", "1", "break", "if flg == 0:\n print('Impossible')\nelse:\n print('Possible')\n last += 1\n # x = list(range(last+1,N))\n x = list(range(N-1,last,-1))\n y = list(range(1,last))\n for a in x:\n print(a)\n for a in y:\n print(a)\n\n print(last)", "flg == 0", "flg", "0", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "last += 1", "last", "1", "x = list(range(N-1,last,-1))", "x", "list(range(N-1,last,-1))", "list", "range(N-1,last,-1)", "range", "N-1", "N", "1", "last", "-1", "y = list(range(1,last))", "y", "list(range(1,last))", "list", "range(1,last)", "range", "1", "last", "for a in x:\n print(a)\n ", "a", "x", "print(a)", "print", "a", "for a in y:\n print(a)\n\n ", "a", "y", "print(a)", "print", "a", "print(last)", "print", "last", "flg = 1", "1", "flg", "x = list(range(N-1,last,-1))", "list(range(N-1,last,-1))", "x", "L = map(int,input().split())", "map(int,input().split())", "L", "N,L = map(int,input().split())", "map(int,input().split())", "N", "last = i", "i", "last", "A = list(map(int,input().split()))", "list(map(int,input().split()))", "A", "flg = 0", "0", "flg", "last += 1", "1", "last", "y = list(range(1,last))", "list(range(1,last))", "y" ]

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

[ [ 103, 2 ], [ 103, 11 ], [ 100, 13 ], [ 26, 25 ], [ 104, 29 ], [ 35, 32 ], [ 101, 33 ], [ 25, 34 ], [ 32, 36 ], [ 101, 37 ], [ 25, 38 ], [ 101, 40 ], [ 25, 42 ], [ 101, 48 ], [ 98, 49 ], [ 94, 54 ], [ 101, 58 ], [ 101, 62 ], [ 66, 65 ], [ 95, 69 ], [ 65, 74 ], [ 78, 77 ], [ 104, 81 ], [ 95, 82 ], [ 104, 87 ], [ 77, 88 ], [ 94, 95 ], [ 103, 98 ], [ 100, 101 ], [ 103, 104 ] ]

[ "n,l = map(int,input().split())\na = list(map(int,input().split()))\nfor N in range(n - 1):\n a[N] = a[N] + a[N + 1]\nif max(a) >= l:\n print('Possible')\n ind = a.index(max(a)) + 1\n for i in range(ind - 1):\n print(i + 1)\n for i in range(n - ind):\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", "for N in range(n - 1):\n a[N] = a[N] + a[N + 1]", "N", "range(n - 1)", "range", "n - 1", "n", "1", "a[N] = a[N] + a[N + 1]", "a[N]", "a", "N", "a[N] + a[N + 1]", "a[N]", "a", "N", "a[N + 1]", "a", "N + 1", "N", "1", "if max(a) >= l:\n print('Possible')\n ind = a.index(max(a)) + 1\n for i in range(ind - 1):\n print(i + 1)\n for i in range(n - ind):\n print(n - i - 1)\nelse:\n print('Impossible')", "max(a) >= l", "max(a)", "max", "a", "l", "print('Possible')", "print", "'Possible'", "ind = a.index(max(a)) + 1", "ind", "a.index(max(a)) + 1", "a.index(max(a))", "a.index", "a", "index", "max(a)", "max", "a", "1", "for i in range(ind - 1):\n print(i + 1)\n ", "i", "range(ind - 1)", "range", "ind - 1", "ind", "1", "print(i + 1)", "print", "i + 1", "i", "1", "for i in range(n - ind):\n print(n - i - 1)", "i", "range(n - ind)", "range", "n - ind", "n", "ind", "print(n - i - 1)", "print", "n - i - 1", "n - i", "n", "i", "1", "print('Impossible')", "print", "'Impossible'", "ind = a.index(max(a)) + 1", "a.index(max(a)) + 1", "ind", "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, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 4, 13, 17, 0, 13, 2, 13, 17, 3, 14, 13, 28, 13, 4, 13, 17, 13, 4, 13, 13, 28, 13, 4, 13, 2, 2, 13, 13, 17, 4, 13, 2, 2, 13, 13, 17, 4, 13, 13, 4, 13, 17, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 17, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 103, 14 ], [ 103, 16 ], [ 20, 19 ], [ 19, 28 ], [ 109, 30 ], [ 106, 33 ], [ 37, 36 ], [ 104, 40 ], [ 110, 46 ], [ 36, 47 ], [ 110, 49 ], [ 36, 51 ], [ 98, 53 ], [ 100, 58 ], [ 36, 60 ], [ 67, 66 ], [ 101, 70 ], [ 107, 70 ], [ 66, 73 ], [ 76, 75 ], [ 104, 80 ], [ 101, 81 ], [ 107, 81 ], [ 104, 87 ], [ 75, 88 ], [ 101, 92 ], [ 107, 92 ], [ 103, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ] ]

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

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

[ [ 5, 4 ], [ 5, 15 ], [ 18, 17 ], [ 30, 29 ], [ 32, 31 ], [ 35, 34 ], [ 4, 38 ], [ 17, 44 ], [ 34, 45 ], [ 17, 47 ], [ 34, 49 ], [ 31, 51 ], [ 56, 51 ], [ 54, 53 ], [ 34, 54 ], [ 57, 56 ], [ 17, 59 ], [ 34, 60 ], [ 17, 62 ], [ 34, 64 ], [ 56, 68 ], [ 31, 68 ], [ 15, 69 ], [ 78, 77 ], [ 53, 80 ], [ 29, 80 ], [ 77, 84 ], [ 88, 87 ], [ 4, 91 ], [ 53, 93 ], [ 29, 93 ], [ 87, 98 ], [ 53, 103 ], [ 29, 103 ], [ 113, 110 ] ]

[ "def main():\n N, L = list(map(int, input().split()))\n A = list(map(int, input().split()))\n max_len_knot, max_len = - 1, 0\n for i in range(N - 1):\n if A[i] + A[i + 1] > max_len:\n max_len_knot = i\n max_len = A[i] + A[i + 1]\n if max_len < L:\n print('Impossible')\n else:\n print('Possible')\n for i in range(max_len_knot):\n print(i + 1)\n for i in range(N - 2, max_len_knot, -1):\n print(i + 1)\n print(max_len_knot + 1)\n\n\nif __name__ == '__main__':\n main()", "def main():\n N, L = list(map(int, input().split()))\n A = list(map(int, input().split()))\n max_len_knot, max_len = - 1, 0\n for i in range(N - 1):\n if A[i] + A[i + 1] > max_len:\n max_len_knot = i\n max_len = A[i] + A[i + 1]\n if max_len < L:\n print('Impossible')\n else:\n print('Possible')\n for i in range(max_len_knot):\n print(i + 1)\n for i in range(N - 2, max_len_knot, -1):\n print(i + 1)\n print(max_len_knot + 1)", "main", "N, L = list(map(int, input().split()))", "N", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "max_len_knot, max_len = - 1, 0", "max_len_knot", "- 1", "max_len", "0", "for i in range(N - 1):\n if A[i] + A[i + 1] > max_len:\n max_len_knot = i\n max_len = A[i] + A[i + 1]\n ", "i", "range(N - 1)", "range", "N - 1", "N", "1", "if A[i] + A[i + 1] > max_len:\n max_len_knot = i\n max_len = A[i] + A[i + 1]\n ", "A[i] + A[i + 1] > max_len", "A[i] + A[i + 1]", "A[i]", "A", "i", "A[i + 1]", "A", "i + 1", "i", "1", "max_len", "max_len_knot = i", "max_len_knot", "i", "max_len = A[i] + A[i + 1]", "max_len", "A[i] + A[i + 1]", "A[i]", "A", "i", "A[i + 1]", "A", "i + 1", "i", "1", "if max_len < L:\n print('Impossible')\n else:\n print('Possible')\n for i in range(max_len_knot):\n print(i + 1)\n for i in range(N - 2, max_len_knot, -1):\n print(i + 1)\n print(max_len_knot + 1)", "max_len < L", "max_len", "L", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "for i in range(max_len_knot):\n print(i + 1)\n ", "i", "range(max_len_knot)", "range", "max_len_knot", "print(i + 1)", "print", "i + 1", "i", "1", "for i in range(N - 2, max_len_knot, -1):\n print(i + 1)\n ", "i", "range(N - 2, max_len_knot, -1)", "range", "N - 2", "N", "2", "max_len_knot", "-1", "print(i + 1)", "print", "i + 1", "i", "1", "print(max_len_knot + 1)", "print", "max_len_knot + 1", "max_len_knot", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N, L = list(map(int, input().split()))\n A = list(map(int, input().split()))\n max_len_knot, max_len = - 1, 0\n for i in range(N - 1):\n if A[i] + A[i + 1] > max_len:\n max_len_knot = i\n max_len = A[i] + A[i + 1]\n if max_len < L:\n print('Impossible')\n else:\n print('Possible')\n for i in range(max_len_knot):\n print(i + 1)\n for i in range(N - 2, max_len_knot, -1):\n print(i + 1)\n print(max_len_knot + 1)", "def main():\n N, L = list(map(int, input().split()))\n A = list(map(int, input().split()))\n max_len_knot, max_len = - 1, 0\n for i in range(N - 1):\n if A[i] + A[i + 1] > max_len:\n max_len_knot = i\n max_len = A[i] + A[i + 1]\n if max_len < L:\n print('Impossible')\n else:\n print('Possible')\n for i in range(max_len_knot):\n print(i + 1)\n for i in range(N - 2, max_len_knot, -1):\n print(i + 1)\n print(max_len_knot + 1)", "main" ]

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

[ [ 143, 2 ], [ 143, 11 ], [ 140, 13 ], [ 155, 25 ], [ 29, 28 ], [ 138, 32 ], [ 141, 38 ], [ 28, 39 ], [ 141, 41 ], [ 28, 43 ], [ 144, 45 ], [ 158, 47 ], [ 159, 52 ], [ 156, 52 ], [ 146, 63 ], [ 138, 66 ], [ 76, 71 ], [ 147, 72 ], [ 138, 74 ], [ 161, 80 ], [ 138, 82 ], [ 86, 85 ], [ 97, 94 ], [ 147, 95 ], [ 162, 96 ], [ 153, 96 ], [ 85, 98 ], [ 152, 101 ], [ 105, 104 ], [ 138, 111 ], [ 117, 114 ], [ 147, 115 ], [ 153, 116 ], [ 162, 116 ], [ 150, 116 ], [ 104, 118 ], [ 149, 121 ], [ 147, 135 ], [ 143, 138 ], [ 140, 141 ], [ 143, 144 ], [ 146, 147 ], [ 149, 150 ], [ 152, 153 ], [ 155, 156 ], [ 158, 159 ], [ 161, 162 ] ]

[ "n, s = map(int, raw_input().split())\nvalues = list(map(int, raw_input().split()))\nfound = False\nfor pos in range(n - 1):\n if values[pos] + values[pos + 1] >= s:\n found = True\n break\nif not found:\n print('Impossible')\n import sys\n sys.exit()\n \nresult = (n - 1) * [ None ]\nresult[n - 2] = pos + 1\nix = n - 3\nfor i in range(pos - 1, -1, -1):\n result[ix] = i + 1\n ix -= 1\nfor i in range(pos + 1, n - 1):\n result[ix] = i + 1\n ix -= 1\nprint('Possible')\nprint('\\n'.join(map(str, result)))", "n, s = map(int, raw_input().split())", "n", "map(int, raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "s", "values = list(map(int, raw_input().split()))", "values", "list(map(int, raw_input().split()))", "list", "map(int, raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "found = False", "found", "False", "for pos in range(n - 1):\n if values[pos] + values[pos + 1] >= s:\n found = True\n break", "pos", "range(n - 1)", "range", "n - 1", "n", "1", "if values[pos] + values[pos + 1] >= s:\n found = True\n break", "values[pos] + values[pos + 1] >= s", "values[pos] + values[pos + 1]", "values[pos]", "values", "pos", "values[pos + 1]", "values", "pos + 1", "pos", "1", "s", "found = True", "found", "True", "break", "if not found:\n print('Impossible')\n import sys\n sys.exit()\n ", "not found", "found", "print('Impossible')", "print", "'Impossible'", "import sys", "sys", "sys.exit()", "sys.exit", "sys", "exit", "result = (n - 1) * [ None ]", "result", "(n - 1) * [ None ]", "n - 1", "n", "1", "[ None ]", "None", "result[n - 2] = pos + 1", "result[n - 2]", "result", "n - 2", "n", "2", "pos + 1", "pos", "1", "ix = n - 3", "ix", "n - 3", "n", "3", "for i in range(pos - 1, -1, -1):\n result[ix] = i + 1\n ix -= 1", "i", "range(pos - 1, -1, -1)", "range", "pos - 1", "pos", "1", "-1", "-1", "result[ix] = i + 1", "result[ix]", "result", "ix", "i + 1", "i", "1", "ix -= 1", "ix", "1", "for i in range(pos + 1, n - 1):\n result[ix] = i + 1\n ix -= 1", "i", "range(pos + 1, n - 1)", "range", "pos + 1", "pos", "1", "n - 1", "n", "1", "result[ix] = i + 1", "result[ix]", "result", "ix", "i + 1", "i", "1", "ix -= 1", "ix", "1", "print('Possible')", "print", "'Possible'", "print('\\n'.join(map(str, result)))", "print", "'\\n'.join(map(str, result))", "'\\n'.join", "'\\n'", "join", "map(str, result)", "map", "str", "result", "n, s = map(int, raw_input().split())", "map(int, raw_input().split())", "n", "values = list(map(int, raw_input().split()))", "list(map(int, raw_input().split()))", "values", "s = map(int, raw_input().split())", "map(int, raw_input().split())", "s", "result = (n - 1) * [ None ]", "(n - 1) * [ None ]", "result", "ix -= 1", "1", "ix", "ix -= 1", "1", "ix", "found = False", "False", "found", "found = True", "True", "found", "ix = n - 3", "n - 3", "ix" ]

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

[ [ 94, 2 ], [ 94, 11 ], [ 97, 13 ], [ 27, 26 ], [ 95, 30 ], [ 98, 34 ], [ 26, 36 ], [ 98, 39 ], [ 26, 40 ], [ 100, 42 ], [ 101, 48 ], [ 89, 49 ], [ 91, 57 ], [ 101, 60 ], [ 101, 64 ], [ 67, 66 ], [ 92, 69 ], [ 66, 73 ], [ 77, 76 ], [ 95, 80 ], [ 92, 82 ], [ 76, 86 ], [ 94, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ] ]

[ "N,L = map(int,input().split())\nA = list(map(int,input().split()))\n\nB = [A[i-1] + A[i] for i in range(1,N)]\n\nif max(B) < L :\n print(\"Impossible\")\nelse :\n print(\"Possible\")\n\n ind = B.index(max(B))\n for i in range(ind) :\n print(i+1)\n for i in range(N-1,ind,-1) :\n print(i)", "N,L = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "A = list(map(int,input().split()))", "A", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A[i-1] + A[i] for i in range(1,N)", "for i in range(1,N)", "i", "range(1,N)", "range", "1", "N", "for i in range(1,N)", "A[i-1] + A[i]", "A[i-1]", "A", "i-1", "i", "1", "A[i]", "A", "i", "B = [A[i-1] + A[i] for i in range(1,N)]", "B", "[A[i-1] + A[i] for i in range(1,N)]", "if max(B) < L :\n print(\"Impossible\")\nelse :\n print(\"Possible\")\n\n ind = B.index(max(B))\n for i in range(ind) :\n print(i+1)\n for i in range(N-1,ind,-1) :\n print(i)", "max(B) < L", "max(B)", "max", "B", "L", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "ind = B.index(max(B))", "ind", "B.index(max(B))", "B.index", "B", "index", "max(B)", "max", "B", "for i in range(ind) :\n print(i+1)\n ", "i", "range(ind)", "range", "ind", "print(i+1)", "print", "i+1", "i", "1", "for i in range(N-1,ind,-1) :\n print(i)", "i", "range(N-1,ind,-1)", "range", "N-1", "N", "1", "ind", "-1", "print(i)", "print", "i", "L = map(int,input().split())", "map(int,input().split())", "L", "ind = B.index(max(B))", "B.index(max(B))", "ind", "N,L = map(int,input().split())", "map(int,input().split())", "N", "A = list(map(int,input().split()))", "list(map(int,input().split()))", "A", "B = [A[i-1] + A[i] for i in range(1,N)]", "[A[i-1] + A[i] for i in range(1,N)]", "B" ]

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

[ [ 153, 11 ], [ 144, 18 ], [ 154, 25 ], [ 144, 27 ], [ 147, 29 ], [ 154, 38 ], [ 138, 41 ], [ 45, 44 ], [ 145, 48 ], [ 148, 54 ], [ 44, 55 ], [ 148, 57 ], [ 44, 59 ], [ 136, 61 ], [ 156, 63 ], [ 44, 64 ], [ 157, 68 ], [ 139, 68 ], [ 132, 71 ], [ 133, 75 ], [ 150, 77 ], [ 141, 80 ], [ 85, 84 ], [ 157, 89 ], [ 139, 89 ], [ 142, 92 ], [ 84, 94 ], [ 97, 96 ], [ 157, 100 ], [ 139, 100 ], [ 145, 103 ], [ 142, 107 ], [ 96, 109 ], [ 133, 112 ], [ 151, 112 ], [ 142, 130 ], [ 132, 133 ], [ 144, 136 ], [ 138, 139 ], [ 141, 142 ], [ 144, 145 ], [ 147, 148 ], [ 150, 151 ], [ 153, 154 ], [ 44, 156 ], [ 156, 157 ] ]

[ "import sys\nsys.setrecursionlimit(10**9)\ninput = sys.stdin.readline\n\nN, L = map(int, input().split())\nA = list(map(int, input().split()))\n\nlarge_pair = -1\n# 一つでもA[i]+A[i+1]>=Lとなるところが存在すれば、そこを最後まで残して、他を全部解けばいい\nfor i in range(N-1):\n if A[i]+A[i+1] >= L:\n large_pair = i\n break\n\nif large_pair == -1:\n ans = \"Impossible\"\n print(ans)\nelse:\n # 解く順を逆から辿っていく\n ans = \"Possible\"\n order = [large_pair]\n for a in reversed(range(large_pair)):\n order.append(a)\n for a in range(large_pair+1, N-1):\n order.append(a)\n\n print(ans)\n print(\"\\n\".join(map(lambda x: str(x+1), reversed(order))))", "import sys", "sys", "sys.setrecursionlimit(10**9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**9", "10", "9", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "large_pair = -1", "large_pair", "-1", "for i in range(N-1):\n if A[i]+A[i+1] >= L:\n large_pair = i\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i]+A[i+1] >= L:\n large_pair = 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", "large_pair = i", "large_pair", "i", "break", "if large_pair == -1:\n ans = \"Impossible\"\n print(ans)\nelse:\n # 解く順を逆から辿っていく\n ans = \"Possible\"\n order = [large_pair]\n for a in reversed(range(large_pair)):\n order.append(a)\n for a in range(large_pair+1, N-1):\n order.append(a)\n\n print(ans)\n print(\"\\n\".join(map(lambda x: str(x+1), reversed(order))))", "large_pair == -1", "large_pair", "-1", "ans = \"Impossible\"", "ans", "\"Impossible\"", "print(ans)", "print", "ans", "ans = \"Possible\"", "ans", "\"Possible\"", "order = [large_pair]", "order", "[large_pair]", "large_pair", "for a in reversed(range(large_pair)):\n order.append(a)\n ", "a", "reversed(range(large_pair))", "reversed", "range(large_pair)", "range", "large_pair", "order.append(a)", "order.append", "order", "append", "a", "for a in range(large_pair+1, N-1):\n order.append(a)\n\n ", "a", "range(large_pair+1, N-1)", "range", "large_pair+1", "large_pair", "1", "N-1", "N", "1", "order.append(a)", "order.append", "order", "append", "a", "print(ans)", "print", "ans", "print(\"\\n\".join(map(lambda x: str(x+1), reversed(order))))", "print", "\"\\n\".join(map(lambda x: str(x+1), reversed(order)))", "\"\\n\".join", "\"\\n\"", "join", "map(lambda x: str(x+1), reversed(order))", "map", "lambda x: str(x+1)", "str(x+1)", "str", "x+1", "x", "1", "x", "reversed(order)", "reversed", "order", "ans = \"Impossible\"", "\"Impossible\"", "ans", "L = map(int, input().split())", "map(int, input().split())", "L", "large_pair = -1", "-1", "large_pair", "order = [large_pair]", "[large_pair]", "order", "N, L = map(int, input().split())", "map(int, input().split())", "N", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "ans = \"Possible\"", "\"Possible\"", "ans", "input = sys.stdin.readline", "sys.stdin.readline", "input", "large_pair = i", "i", "large_pair" ]

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

[ [ 38, 36 ], [ 38, 38 ], [ 184, 45 ], [ 55, 54 ], [ 54, 65 ], [ 190, 67 ], [ 175, 70 ], [ 187, 85 ], [ 164, 92 ], [ 187, 94 ], [ 181, 96 ], [ 164, 105 ], [ 178, 108 ], [ 169, 110 ], [ 114, 113 ], [ 173, 117 ], [ 182, 123 ], [ 113, 124 ], [ 182, 126 ], [ 113, 128 ], [ 188, 130 ], [ 170, 133 ], [ 136, 135 ], [ 113, 138 ], [ 135, 142 ], [ 146, 145 ], [ 113, 150 ], [ 173, 152 ], [ 145, 157 ], [ 179, 161 ], [ 169, 170 ], [ 187, 173 ], [ 175, 176 ], [ 178, 179 ], [ 181, 182 ], [ 184, 185 ], [ 187, 188 ], [ 190, 191 ] ]

[ "import bisect\nimport copy\nimport heapq\nimport math\nimport sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\ndef input():\n return sys.stdin.readline()[:-1]\ndef ruiseki(lst):\n return [0]+list(accumulate(lst))\nsys.setrecursionlimit(5000000)\nmod=pow(10,9)+7\nal=[chr(ord('a') + i) for i in range(26)]\ndirection=[[1,0],[0,1],[-1,0],[0,-1]]\n\nn,l=map(int,input().split())\na=list(map(int,input().split()))\nI,P=\"Impossible\",\"Possible\"\n\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n print(P)\n for j in range(i):\n print(j+1)\n for j in range(i+1,n)[::-1]:\n print(j)\n break\nelse:\n print(I)", "import bisect", "bisect", "import copy", "copy", "import heapq", "heapq", "import math", "math", "import sys", "sys", "from collections import *", "from functools import lru_cache", "from itertools import accumulate, combinations, permutations, product", "def input():\n return sys.stdin.readline()[:-1]", "input", "return sys.stdin.readline()[:-1]", "sys.stdin.readline()[:-1]", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", ":-1", "-1", "def ruiseki(lst):\n return [0]+list(accumulate(lst))", "ruiseki", "return [0]+list(accumulate(lst))", "[0]+list(accumulate(lst))", "[0]", "0", "list(accumulate(lst))", "list", "accumulate(lst)", "accumulate", "lst", "lst", "lst", "sys.setrecursionlimit(5000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "5000000", "mod=pow(10,9)+7", "mod", "pow(10,9)+7", "pow(10,9)", "pow", "10", "9", "7", "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", "al=[chr(ord('a') + i) for i in range(26)]", "al", "[chr(ord('a') + i) for i in range(26)]", "direction=[[1,0],[0,1],[-1,0],[0,-1]]", "direction", "[[1,0],[0,1],[-1,0],[0,-1]]", "[1,0]", "1", "0", "[0,1]", "0", "1", "[-1,0]", "-1", "0", "[0,-1]", "0", "-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", "I,P=\"Impossible\",\"Possible\"", "I", "\"Impossible\"", "P", "\"Possible\"", "for i in range(n-1):\n if a[i]+a[i+1]>=l:\n print(P)\n for j in range(i):\n print(j+1)\n for j in range(i+1,n)[::-1]:\n print(j)\n break\nelse:\n print(I)", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n print(P)\n for j in range(i):\n print(j+1)\n for j in range(i+1,n)[::-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(P)", "print", "P", "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(i+1,n)[::-1]:\n print(j)\n ", "j", "range(i+1,n)[::-1]", "(i+1,n)", "range", "i+1", "i", "1", "n", "::-1", "-1", "print(j)", "print", "j", "break", "print(I)", "print", "I", "def input():\n return sys.stdin.readline()[:-1]", "def input():\n return sys.stdin.readline()[:-1]", "input", "def ruiseki(lst):\n return [0]+list(accumulate(lst))", "def ruiseki(lst):\n return [0]+list(accumulate(lst))", "ruiseki", "P=\"Impossible\",\"Possible\"", "\"Possible\"", "P", "n,l=map(int,input().split())", "map(int,input().split())", "n", "direction=[[1,0],[0,1],[-1,0],[0,-1]]", "[[1,0],[0,1],[-1,0],[0,-1]]", "direction", "I,P=\"Impossible\",\"Possible\"", "\"Impossible\"", "I", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "mod=pow(10,9)+7", "pow(10,9)+7", "mod", "l=map(int,input().split())", "map(int,input().split())", "l", "al=[chr(ord('a') + i) for i in range(26)]", "[chr(ord('a') + i) for i in range(26)]", "al" ]

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

[ [ 87, 2 ], [ 87, 11 ], [ 75, 13 ], [ 81, 25 ], [ 29, 28 ], [ 88, 32 ], [ 76, 38 ], [ 28, 39 ], [ 76, 41 ], [ 28, 43 ], [ 79, 45 ], [ 84, 47 ], [ 28, 49 ], [ 85, 54 ], [ 82, 54 ], [ 61, 60 ], [ 85, 64 ], [ 82, 64 ], [ 67, 66 ], [ 88, 70 ], [ 66, 72 ], [ 75, 76 ], [ 87, 79 ], [ 81, 82 ], [ 84, 85 ], [ 87, 88 ] ]

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

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

[ [ 125, 4 ], [ 125, 13 ], [ 17, 16 ], [ 16, 25 ], [ 131, 27 ], [ 128, 30 ], [ 36, 35 ], [ 126, 39 ], [ 132, 45 ], [ 35, 46 ], [ 132, 48 ], [ 35, 50 ], [ 123, 52 ], [ 134, 54 ], [ 35, 55 ], [ 135, 59 ], [ 129, 59 ], [ 137, 74 ], [ 78, 77 ], [ 135, 80 ], [ 129, 80 ], [ 138, 83 ], [ 123, 83 ], [ 77, 86 ], [ 90, 89 ], [ 126, 93 ], [ 135, 95 ], [ 129, 95 ], [ 138, 99 ], [ 123, 99 ], [ 89, 102 ], [ 138, 106 ], [ 123, 106 ], [ 135, 109 ], [ 129, 109 ], [ 138, 120 ], [ 123, 120 ], [ 125, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ], [ 35, 134 ], [ 134, 135 ], [ 137, 138 ] ]

[ "import sys\nN,L=map(int,input().split())\nA=[int(i) for i in input().split()]\ns=10**23\nfor i in range(N-1):\n if A[i]+A[i+1]>=L:\n s=i\n break\nif s==10**23:\n print('Impossible')\n sys.exit()\nprint('Possible')\nL=[]\nfor i in range(s):\n L.append(i+1)\nfor i in range(N-2,s,-1):\n L.append(i+1)\nL.append(s+1)\n#print(L,s)\nprint('\\n'.join(map(str,L)))", "import sys", "sys", "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()]", "s=10**23", "s", "10**23", "10", "23", "for i in range(N-1):\n if A[i]+A[i+1]>=L:\n s=i\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i]+A[i+1]>=L:\n s=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", "s=i", "s", "i", "break", "if s==10**23:\n print('Impossible')\n sys.exit()", "s==10**23", "s", "10**23", "10", "23", "print('Impossible')", "print", "'Impossible'", "sys.exit()", "sys.exit", "sys", "exit", "print('Possible')", "print", "'Possible'", "L=[]", "L", "[]", "for i in range(s):\n L.append(i+1)", "i", "range(s)", "range", "s", "L.append(i+1)", "L.append", "L", "append", "i+1", "i", "1", "for i in range(N-2,s,-1):\n L.append(i+1)", "i", "range(N-2,s,-1)", "range", "N-2", "N", "2", "s", "-1", "L.append(i+1)", "L.append", "L", "append", "i+1", "i", "1", "L.append(s+1)", "L.append", "L", "append", "s+1", "s", "1", "print('\\n'.join(map(str,L)))", "print", "'\\n'.join(map(str,L))", "'\\n'.join", "'\\n'", "join", "map(str,L)", "map", "str", "L", "L=map(int,input().split())", "map(int,input().split())", "L", "N,L=map(int,input().split())", "map(int,input().split())", "N", "s=10**23", "10**23", "s", "A=[int(i) for i in input().split()]", "[int(i) for i in input().split()]", "A", "s=i", "i", "s", "L=[]", "[]", "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, 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, 3, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 77, 2 ], [ 77, 11 ], [ 80, 13 ], [ 26, 25 ], [ 75, 29 ], [ 81, 34 ], [ 25, 35 ], [ 81, 37 ], [ 25, 39 ], [ 78, 41 ], [ 47, 46 ], [ 25, 50 ], [ 46, 53 ], [ 56, 55 ], [ 75, 59 ], [ 25, 61 ], [ 55, 65 ], [ 25, 68 ], [ 77, 75 ], [ 77, 78 ], [ 80, 81 ] ]

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

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

[ [ 87, 2 ], [ 87, 11 ], [ 81, 13 ], [ 26, 25 ], [ 79, 29 ], [ 82, 34 ], [ 25, 36 ], [ 82, 39 ], [ 25, 40 ], [ 88, 41 ], [ 84, 43 ], [ 25, 44 ], [ 56, 55 ], [ 85, 59 ], [ 55, 62 ], [ 65, 64 ], [ 79, 68 ], [ 85, 71 ], [ 64, 76 ], [ 87, 79 ], [ 81, 82 ], [ 25, 84 ], [ 84, 85 ], [ 87, 88 ] ]

[ "N, L = map(int, input().split())\nA = list(map(int, input().split()))\n\nfor i in range(1, N):\n if A[i-1] + A[i] >= L:\n X = i\n break\nelse:\n print(\"Impossible\")\n exit()\n\nprint(\"Possible\")\nfor i in range(1, X):\n print(i)\nfor i in range(N-1, X-1, -1):\n print(i)", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(1, N):\n if A[i-1] + A[i] >= L:\n X = i\n break\nelse:\n print(\"Impossible\")\n exit()", "i", "range(1, N)", "range", "1", "N", "if A[i-1] + A[i] >= L:\n X = i\n break", "A[i-1] + A[i] >= L", "A[i-1] + A[i]", "A[i-1]", "A", "i-1", "i", "1", "A[i]", "A", "i", "L", "X = i", "X", "i", "break", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1, X):\n print(i)", "i", "range(1, X)", "range", "1", "X", "print(i)", "print", "i", "for i in range(N-1, X-1, -1):\n print(i)", "i", "range(N-1, X-1, -1)", "range", "N-1", "N", "1", "X-1", "X", "1", "-1", "print(i)", "print", "i", "N, L = map(int, input().split())", "map(int, input().split())", "N", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "X = i", "i", "X", "L = map(int, input().split())", "map(int, input().split())", "L" ]

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

[ [ 144, 11 ], [ 159, 18 ], [ 145, 25 ], [ 159, 27 ], [ 174, 29 ], [ 145, 38 ], [ 171, 41 ], [ 153, 44 ], [ 48, 47 ], [ 160, 51 ], [ 175, 57 ], [ 47, 58 ], [ 175, 60 ], [ 47, 62 ], [ 148, 64 ], [ 156, 66 ], [ 47, 67 ], [ 157, 71 ], [ 154, 71 ], [ 180, 74 ], [ 181, 78 ], [ 172, 78 ], [ 177, 80 ], [ 168, 84 ], [ 157, 85 ], [ 154, 85 ], [ 162, 87 ], [ 169, 89 ], [ 183, 92 ], [ 169, 94 ], [ 163, 98 ], [ 151, 98 ], [ 178, 102 ], [ 163, 104 ], [ 151, 104 ], [ 150, 106 ], [ 184, 110 ], [ 166, 110 ], [ 160, 112 ], [ 178, 116 ], [ 184, 118 ], [ 166, 118 ], [ 165, 120 ], [ 181, 124 ], [ 172, 124 ], [ 178, 142 ], [ 144, 145 ], [ 159, 148 ], [ 150, 151 ], [ 153, 154 ], [ 47, 156 ], [ 156, 157 ], [ 159, 160 ], [ 162, 163 ], [ 165, 166 ], [ 157, 168 ], [ 154, 168 ], [ 168, 169 ], [ 171, 172 ], [ 174, 175 ], [ 177, 178 ], [ 180, 181 ], [ 183, 184 ] ]

[ "import sys\nsys.setrecursionlimit(10**9)\ninput = sys.stdin.readline\n\nN, L = map(int, input().split())\nA = list(map(int, input().split()))\n\nans = \"Possible\"\nlarge_pair = -1\nfor i in range(N-1):\n if A[i]+A[i+1] >= L:\n large_pair = i\n break\nif large_pair == -1:\n ans = \"Impossible\"\n print(ans)\nelse:\n order = [large_pair]\n start = large_pair\n left = start-1\n right = start+1\n\n while left >= 0:\n order.append(left)\n left -= 1\n\n while right < N-1:\n order.append(right)\n right += 1\n\n print(ans)\n print(\"\\n\".join(map(lambda x: str(x+1), reversed(order))))", "import sys", "sys", "sys.setrecursionlimit(10**9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**9", "10", "9", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = \"Possible\"", "ans", "\"Possible\"", "large_pair = -1", "large_pair", "-1", "for i in range(N-1):\n if A[i]+A[i+1] >= L:\n large_pair = i\n break", "i", "range(N-1)", "range", "N-1", "N", "1", "if A[i]+A[i+1] >= L:\n large_pair = 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", "large_pair = i", "large_pair", "i", "break", "if large_pair == -1:\n ans = \"Impossible\"\n print(ans)\nelse:\n order = [large_pair]\n start = large_pair\n left = start-1\n right = start+1\n\n while left >= 0:\n order.append(left)\n left -= 1\n\n while right < N-1:\n order.append(right)\n right += 1\n\n print(ans)\n print(\"\\n\".join(map(lambda x: str(x+1), reversed(order))))", "large_pair == -1", "large_pair", "-1", "ans = \"Impossible\"", "ans", "\"Impossible\"", "print(ans)", "print", "ans", "order = [large_pair]", "order", "[large_pair]", "large_pair", "start = large_pair", "start", "large_pair", "left = start-1", "left", "start-1", "start", "1", "right = start+1", "right", "start+1", "start", "1", "while left >= 0:\n order.append(left)\n left -= 1\n\n ", "left >= 0", "left", "0", "order.append(left)", "order.append", "order", "append", "left", "left -= 1", "left", "1", "while right < N-1:\n order.append(right)\n right += 1\n\n ", "right < N-1", "right", "N-1", "N", "1", "order.append(right)", "order.append", "order", "append", "right", "right += 1", "right", "1", "print(ans)", "print", "ans", "print(\"\\n\".join(map(lambda x: str(x+1), reversed(order))))", "print", "\"\\n\".join(map(lambda x: str(x+1), reversed(order)))", "\"\\n\".join", "\"\\n\"", "join", "map(lambda x: str(x+1), reversed(order))", "map", "lambda x: str(x+1)", "str(x+1)", "str", "x+1", "x", "1", "x", "reversed(order)", "reversed", "order", "input = sys.stdin.readline", "sys.stdin.readline", "input", "L = map(int, input().split())", "map(int, input().split())", "L", "left -= 1", "1", "left", "large_pair = -1", "-1", "large_pair", "large_pair = i", "i", "large_pair", "N, L = map(int, input().split())", "map(int, input().split())", "N", "left = start-1", "start-1", "left", "right += 1", "1", "right", "start = large_pair", "large_pair", "start", "ans = \"Possible\"", "\"Possible\"", "ans", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "order = [large_pair]", "[large_pair]", "order", "ans = \"Impossible\"", "\"Impossible\"", "ans", "right = start+1", "start+1", "right" ]

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

[ [ 97, 2 ], [ 97, 11 ], [ 100, 13 ], [ 103, 23 ], [ 91, 26 ], [ 104, 30 ], [ 89, 30 ], [ 101, 34 ], [ 101, 40 ], [ 104, 41 ], [ 89, 41 ], [ 101, 43 ], [ 104, 45 ], [ 89, 45 ], [ 95, 47 ], [ 85, 49 ], [ 88, 53 ], [ 86, 57 ], [ 92, 57 ], [ 65, 64 ], [ 98, 68 ], [ 89, 71 ], [ 104, 71 ], [ 77, 76 ], [ 89, 81 ], [ 104, 81 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ], [ 97, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ] ]

[ "n, l = map(int, raw_input().split())\na = map(int, raw_input().split())\n# print a\ni = 0\nuntied = False\nwhile i < (len(a)-1):\n if a[i] + a[i+1] >= l:\n # print i, a[i]\n untied = True\n break\n i += 1\nif untied == False:\n print \"Impossible\"\n exit()\nprint \"Possible\"\nfor k in xrange(n-1, i+1, -1):\n print k\nfor k in xrange(1, i+2):\n print k", "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", "i = 0", "i", "0", "untied = False", "untied", "False", "while i < (len(a)-1):\n if a[i] + a[i+1] >= l:\n # print i, a[i]\n untied = True\n break\n i += 1", "i < (len(a)-1)", "i", "len(a)-1", "len(a)", "len", "a", "1", "if a[i] + a[i+1] >= l:\n # print i, a[i]\n untied = 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", "untied = True", "untied", "True", "break", "i += 1", "i", "1", "if untied == False:\n print \"Impossible\"\n exit()", "untied == False", "untied", "False", "print", "exit()", "exit", "print", "for k in xrange(n-1, i+1, -1):\n print k", "k", "xrange(n-1, i+1, -1)", "xrange", "n-1", "n", "1", "i+1", "i", "1", "-1", "print", "for k in xrange(1, i+2):\n print k", "k", "xrange(1, i+2)", "xrange", "1", "i+2", "i", "2", "print", "untied = True", "True", "untied", "i += 1", "1", "i", "untied = False", "False", "untied", "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", "a = map(int, raw_input().split())", "map(int, raw_input().split())", "a", "i = 0", "0", "i" ]

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

[ [ 112, 2 ], [ 112, 11 ], [ 94, 13 ], [ 103, 25 ], [ 29, 28 ], [ 113, 32 ], [ 106, 35 ], [ 95, 38 ], [ 28, 39 ], [ 95, 41 ], [ 28, 43 ], [ 107, 47 ], [ 98, 48 ], [ 109, 50 ], [ 100, 53 ], [ 28, 55 ], [ 110, 60 ], [ 104, 60 ], [ 72, 71 ], [ 101, 75 ], [ 71, 78 ], [ 81, 80 ], [ 113, 84 ], [ 101, 87 ], [ 80, 92 ], [ 94, 95 ], [ 112, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ], [ 112, 113 ] ]

[ "N,L=map(int, input().split())\nA=list(map(int, input().split()))\nx=0\nfor i in range(N-1):\n d=A[i]+A[i+1]\n if d>=L:\n x=1\n knot=i+1\n break\n \nif x==0:\n print('Impossible')\n exit()\n\nprint('Possible')\nfor i in range(1,knot):\n print(i)\nfor i in range(N-1,knot-1,-1):\n print(i)", "N,L=map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "A=list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "x=0", "x", "0", "for i in range(N-1):\n d=A[i]+A[i+1]\n if d>=L:\n x=1\n knot=i+1\n break\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "d=A[i]+A[i+1]", "d", "A[i]+A[i+1]", "A[i]", "A", "i", "A[i+1]", "A", "i+1", "i", "1", "if d>=L:\n x=1\n knot=i+1\n break\n ", "d>=L", "d", "L", "x=1", "x", "1", "knot=i+1", "knot", "i+1", "i", "1", "break", "if x==0:\n print('Impossible')\n exit()", "x==0", "x", "0", "print('Impossible')", "print", "'Impossible'", "exit()", "exit", "print('Possible')", "print", "'Possible'", "for i in range(1,knot):\n print(i)", "i", "range(1,knot)", "range", "1", "knot", "print(i)", "print", "i", "for i in range(N-1,knot-1,-1):\n print(i)", "i", "range(N-1,knot-1,-1)", "range", "N-1", "N", "1", "knot-1", "knot", "1", "-1", "print(i)", "print", "i", "A=list(map(int, input().split()))", "list(map(int, input().split()))", "A", "L=map(int, input().split())", "map(int, input().split())", "L", "knot=i+1", "i+1", "knot", "x=0", "0", "x", "d=A[i]+A[i+1]", "A[i]+A[i+1]", "d", "x=1", "1", "x", "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, 28, 13, 39, 13, 13, 4, 13, 4, 13, 13, 18, 13, 39, 17, 14, 40, 2, 13, 13, 13, 4, 13, 17, 0, 13, 4, 13, 4, 13, 13, 4, 13, 4, 18, 17, 13, 4, 13, 13, 2, 18, 13, 39, 17, 2, 13, 17, 18, 13, 39, 13, 13, 17, 3, 4, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 17 ], [ 5, 18 ], [ 17, 39 ], [ 45, 44 ], [ 4, 49 ], [ 44, 61 ], [ 44, 68 ], [ 85, 82 ] ]

[ "def s():\n\tn, l, *a = map(int, open(0).read().split())\n\tfor i, (x, y) in enumerate(zip(a, a[1:])):\n\t\tif x + y >= l:\n\t\t\tprint(\"Possible\")\n\t\t\tr = list(range(n))\n\t\t\tprint(\"\\n\".join(map(str, r[1:i + 1] + r[n:i:-1])))\n\t\t\tbreak\n\telse:\n\t\tprint(\"Impossible\")\nif __name__==\"__main__\":\n\ts()", "def s():\n\tn, l, *a = map(int, open(0).read().split())\n\tfor i, (x, y) in enumerate(zip(a, a[1:])):\n\t\tif x + y >= l:\n\t\t\tprint(\"Possible\")\n\t\t\tr = list(range(n))\n\t\t\tprint(\"\\n\".join(map(str, r[1:i + 1] + r[n:i:-1])))\n\t\t\tbreak\n\telse:\n\t\tprint(\"Impossible\")", "s", "n, l, *a = map(int, open(0).read().split())", "n", "map(int, open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "l", "*a", "a", "for i, (x, y) in enumerate(zip(a, a[1:])):\n\t\tif x + y >= l:\n\t\t\tprint(\"Possible\")\n\t\t\tr = list(range(n))\n\t\t\tprint(\"\\n\".join(map(str, r[1:i + 1] + r[n:i:-1])))\n\t\t\tbreak\n\telse:\n\t\tprint(\"Impossible\")", "i", "(x, y)", "x", "y", "enumerate(zip(a, a[1:]))", "enumerate", "zip(a, a[1:])", "zip", "a", "a[1:]", "a", "1:", "1", "if x + y >= l:\n\t\t\tprint(\"Possible\")\n\t\t\tr = list(range(n))\n\t\t\tprint(\"\\n\".join(map(str, r[1:i + 1] + r[n:i:-1])))\n\t\t\tbreak\n\t", "x + y >= l", "x + y", "x", "y", "l", "print(\"Possible\")", "print", "\"Possible\"", "r = list(range(n))", "r", "list(range(n))", "list", "range(n)", "range", "n", "print(\"\\n\".join(map(str, r[1:i + 1] + r[n:i:-1])))", "print", "\"\\n\".join(map(str, r[1:i + 1] + r[n:i:-1]))", "\"\\n\".join", "\"\\n\"", "join", "map(str, r[1:i + 1] + r[n:i:-1])", "map", "str", "r[1:i + 1] + r[n:i:-1]", "r[1:i + 1]", "r", "1:i + 1", "1", "i + 1", "i", "1", "r[n:i:-1]", "r", "n:i:-1", "n", "i", "-1", "break", "print(\"Impossible\")", "print", "\"Impossible\"", "if __name__==\"__main__\":\n\ts()", "__name__==\"__main__\"", "__name__", "\"__main__\"", "s()", "s", "def s():\n\tn, l, *a = map(int, open(0).read().split())\n\tfor i, (x, y) in enumerate(zip(a, a[1:])):\n\t\tif x + y >= l:\n\t\t\tprint(\"Possible\")\n\t\t\tr = list(range(n))\n\t\t\tprint(\"\\n\".join(map(str, r[1:i + 1] + r[n:i:-1])))\n\t\t\tbreak\n\telse:\n\t\tprint(\"Impossible\")", "def s():\n\tn, l, *a = map(int, open(0).read().split())\n\tfor i, (x, y) in enumerate(zip(a, a[1:])):\n\t\tif x + y >= l:\n\t\t\tprint(\"Possible\")\n\t\t\tr = list(range(n))\n\t\t\tprint(\"\\n\".join(map(str, r[1:i + 1] + r[n:i:-1])))\n\t\t\tbreak\n\telse:\n\t\tprint(\"Impossible\")", "s" ]

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

[ [ 88, 2 ], [ 88, 11 ], [ 91, 13 ], [ 26, 25 ], [ 86, 29 ], [ 92, 35 ], [ 25, 36 ], [ 92, 38 ], [ 25, 40 ], [ 89, 42 ], [ 82, 47 ], [ 25, 49 ], [ 59, 58 ], [ 83, 62 ], [ 58, 65 ], [ 68, 67 ], [ 86, 71 ], [ 83, 73 ], [ 67, 77 ], [ 83, 80 ], [ 82, 83 ], [ 88, 86 ], [ 88, 89 ], [ 91, 92 ] ]

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

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

[ [ 209, 27 ], [ 42, 41 ], [ 222, 47 ], [ 51, 51 ], [ 55, 54 ], [ 264, 60 ], [ 64, 64 ], [ 68, 67 ], [ 252, 73 ], [ 77, 77 ], [ 81, 80 ], [ 219, 86 ], [ 90, 90 ], [ 94, 93 ], [ 252, 101 ], [ 105, 105 ], [ 109, 108 ], [ 117, 117 ], [ 215, 119 ], [ 248, 122 ], [ 264, 124 ], [ 248, 125 ], [ 239, 127 ], [ 264, 129 ], [ 245, 131 ], [ 224, 134 ], [ 138, 137 ], [ 237, 141 ], [ 240, 147 ], [ 137, 148 ], [ 240, 150 ], [ 137, 152 ], [ 246, 154 ], [ 255, 154 ], [ 254, 156 ], [ 240, 159 ], [ 137, 160 ], [ 240, 162 ], [ 137, 164 ], [ 212, 167 ], [ 137, 168 ], [ 255, 171 ], [ 246, 171 ], [ 249, 172 ], [ 178, 177 ], [ 213, 180 ], [ 225, 180 ], [ 177, 184 ], [ 188, 187 ], [ 237, 191 ], [ 213, 194 ], [ 225, 194 ], [ 187, 199 ], [ 213, 203 ], [ 225, 203 ], [ 209, 210 ], [ 137, 212 ], [ 212, 213 ], [ 215, 216 ], [ 224, 225 ], [ 248, 237 ], [ 239, 240 ], [ 245, 246 ], [ 248, 249 ], [ 254, 255 ] ]

[ "from collections import defaultdict, deque, Counter\nfrom heapq import heappush, heappop, heapify\nimport math\nimport bisect\nimport random\nfrom itertools import permutations, accumulate, combinations, product\nimport sys\nfrom pprint import pprint\nfrom copy import deepcopy\nimport string\nfrom bisect import bisect_left, bisect_right\nfrom math import factorial, ceil, floor\nfrom operator import mul\nfrom functools import reduce\nfrom pprint import pprint\n\n\nsys.setrecursionlimit(2147483647)\nINF = 10 ** 15\ndef LI(): return list(map(int, sys.stdin.buffer.readline().split()))\ndef I(): return int(sys.stdin.buffer.readline())\ndef LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()\ndef S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')\ndef IR(n): return [I() for i in range(n)]\ndef LIR(n): return [LI() for i in range(n)]\ndef SR(n): return [S() for i in range(n)]\ndef LSR(n): return [LS() for i in range(n)]\ndef SRL(n): return [list(S()) for i in range(n)]\ndef MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]\nmod = 1000000007\n\n\nn, l = LI()\nA = LI()\nret = 0\nj = 0\nfor i in range(n - 1):\n if A[i] + A[i + 1] > ret:\n ret = A[i] + A[i + 1]\n j = i\n\nif ret >= l:\n print('Possible')\n for k in range(j):\n print(k + 1)\n for m in range(n - 1, j + 1, -1):\n print(m)\n print(j + 1)\nelse:\n print('Impossible')", "from collections import defaultdict, deque, Counter", "from heapq import heappush, heappop, heapify", "import math", "math", "import bisect", "bisect", "import random", "random", "from itertools import permutations, accumulate, combinations, product", "import sys", "sys", "from pprint import pprint", "from copy import deepcopy", "import string", "string", "from bisect import bisect_left, bisect_right", "from math import factorial, ceil, floor", "from operator import mul", "from functools import reduce", "from pprint import pprint", "sys.setrecursionlimit(2147483647)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "2147483647", "INF = 10 ** 15", "INF", "10 ** 15", "10", "15", "def LI(): return list(map(int, sys.stdin.buffer.readline().split()))", "LI", "def I(): return int(sys.stdin.buffer.readline())", "I", "def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()", "LS", "def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')", "S", "I() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "I()", "I", "def IR(n): return [I() for i in range(n)]", "IR", "n", "n", "LI() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "LI()", "LI", "def LIR(n): return [LI() for i in range(n)]", "LIR", "n", "n", "S() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "S()", "S", "def SR(n): return [S() for i in range(n)]", "SR", "n", "n", "LS() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "LS()", "LS", "def LSR(n): return [LS() for i in range(n)]", "LSR", "n", "n", "list(S()) for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "list(S())", "list", "S()", "S", "def SRL(n): return [list(S()) for i in range(n)]", "SRL", "n", "n", "[int(j) for j in list(S())] for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "[int(j) for j in list(S())]", "def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]", "MSRL", "n", "n", "mod = 1000000007", "mod", "1000000007", "n, l = LI()", "n", "LI()", "LI", "l", "A = LI()", "A", "LI()", "LI", "ret = 0", "ret", "0", "j = 0", "j", "0", "for i in range(n - 1):\n if A[i] + A[i + 1] > ret:\n ret = A[i] + A[i + 1]\n j = i", "i", "range(n - 1)", "range", "n - 1", "n", "1", "if A[i] + A[i + 1] > ret:\n ret = A[i] + A[i + 1]\n j = i", "A[i] + A[i + 1] > ret", "A[i] + A[i + 1]", "A[i]", "A", "i", "A[i + 1]", "A", "i + 1", "i", "1", "ret", "ret = A[i] + A[i + 1]", "ret", "A[i] + A[i + 1]", "A[i]", "A", "i", "A[i + 1]", "A", "i + 1", "i", "1", "j = i", "j", "i", "if ret >= l:\n print('Possible')\n for k in range(j):\n print(k + 1)\n for m in range(n - 1, j + 1, -1):\n print(m)\n print(j + 1)\nelse:\n print('Impossible')", "ret >= l", "ret", "l", "print('Possible')", "print", "'Possible'", "for k in range(j):\n print(k + 1)\n ", "k", "range(j)", "range", "j", "print(k + 1)", "print", "k + 1", "k", "1", "for m in range(n - 1, j + 1, -1):\n print(m)\n ", "m", "range(n - 1, j + 1, -1)", "range", "n - 1", "n", "1", "j + 1", "j", "1", "-1", "print(m)", "print", "m", "print(j + 1)", "print", "j + 1", "j", "1", "print('Impossible')", "print", "'Impossible'", "INF = 10 ** 15", "10 ** 15", "INF", "j = i", "i", "j", "mod = 1000000007", "1000000007", "mod", "def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()", "def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()", "LS", "def I(): return int(sys.stdin.buffer.readline())", "def I(): return int(sys.stdin.buffer.readline())", "I", "j = 0", "0", "j", "def LSR(n): return [LS() for i in range(n)]", "def LSR(n): return [LS() for i in range(n)]", "LSR", "def LIR(n): return [LI() for i in range(n)]", "def LIR(n): return [LI() for i in range(n)]", "LIR", "def SR(n): return [S() for i in range(n)]", "def SR(n): return [S() for i in range(n)]", "SR", "n, l = LI()", "LI()", "n", "A = LI()", "LI()", "A", "def IR(n): return [I() for i in range(n)]", "def IR(n): return [I() for i in range(n)]", "IR", "ret = 0", "0", "ret", "l = LI()", "LI()", "l", "def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')", "def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')", "S", "ret = A[i] + A[i + 1]", "A[i] + A[i + 1]", "ret", "def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]", "def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]", "MSRL", "def SRL(n): return [list(S()) for i in range(n)]", "def SRL(n): return [list(S()) for i in range(n)]", "SRL", "def LI(): return list(map(int, sys.stdin.buffer.readline().split()))", "def LI(): return list(map(int, sys.stdin.buffer.readline().split()))", "LI" ]

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

[ [ 229, 17 ], [ 232, 24 ], [ 238, 35 ], [ 226, 48 ], [ 247, 51 ], [ 57, 56 ], [ 233, 58 ], [ 57, 59 ], [ 57, 60 ], [ 60, 65 ], [ 56, 66 ], [ 59, 67 ], [ 248, 71 ], [ 60, 79 ], [ 56, 80 ], [ 59, 81 ], [ 56, 86 ], [ 59, 87 ], [ 227, 90 ], [ 256, 107 ], [ 244, 114 ], [ 250, 125 ], [ 253, 138 ], [ 259, 141 ], [ 147, 146 ], [ 245, 148 ], [ 233, 148 ], [ 147, 149 ], [ 152, 151 ], [ 251, 153 ], [ 239, 153 ], [ 156, 155 ], [ 159, 158 ], [ 162, 161 ], [ 146, 165 ], [ 151, 171 ], [ 161, 172 ], [ 151, 174 ], [ 161, 176 ], [ 149, 178 ], [ 184, 183 ], [ 187, 186 ], [ 161, 188 ], [ 183, 193 ], [ 155, 193 ], [ 201, 200 ], [ 186, 204 ], [ 158, 204 ], [ 200, 207 ], [ 210, 209 ], [ 146, 213 ], [ 186, 215 ], [ 158, 215 ], [ 209, 219 ], [ 186, 222 ], [ 158, 222 ], [ 236, 224 ], [ 226, 227 ], [ 229, 230 ], [ 232, 233 ], [ 238, 239 ], [ 244, 245 ], [ 247, 248 ], [ 250, 251 ], [ 253, 254 ], [ 256, 257 ], [ 259, 260 ] ]

[ "#gcdは3.4.3だとfractionsにある\nfrom fractions import gcd\nimport math\n\nfrom math import factorial as f\n\nfrom math import ceil,floor,sqrt\n\n\nimport bisect\nimport re\nimport heapq\n\n\nfrom copy import deepcopy\nimport itertools\n\nfrom sys import exit\n\nii = lambda : int(input())\nmi = lambda : map(int,input().split())\nli = lambda : list(map(int,input().split()))\n\nyes = \"Yes\"\nno = \"No\"\n\n\n\n\ndef main():\n a,b,c = mi()\n if c-a-b<=0:\n print(no)\n exit()\n else:\n if (c-a-b)**2 > 4*a*b:\n print(yes)#gcdは3.4.3だとfractionsにある\nfrom fractions import gcd\nimport math\n\nfrom math import factorial as f\n\nfrom math import ceil,floor,sqrt\n\n\nimport bisect\nimport re\nimport heapq\n\n\nfrom copy import deepcopy\nimport itertools\n\nfrom sys import exit\n\nii = lambda : int(input())\nmi = lambda : map(int,input().split())\nli = lambda : list(map(int,input().split()))\n\nyes = \"YES\"\nno = \"NO\"\n\n\ndef main():\n n,l = mi()\n a = li()\n\n flag = False\n lp = 0\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n print(\"Possible\")\n flag = True\n lp = i+1\n break\n \n if not flag:\n print(\"Impossible\")\n exit()\n\n for i in range(1,lp):\n print(i)\n for i in range(n-1,lp,-1):\n print(i)\n print(lp)\n \n \n\n \n\n\nmain()\n", "from fractions import gcd", "import math", "math", "from math import factorial as f", "from math import ceil,floor,sqrt", "import bisect", "bisect", "import re", "re", "import heapq", "heapq", "from copy import deepcopy", "import itertools", "itertools", "from sys import exit", "ii = lambda : int(input())", "ii", "lambda : int(input())", "int(input())", "int", "input()", "input", "mi = lambda : map(int,input().split())", "mi", "lambda : map(int,input().split())", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "li = lambda : list(map(int,input().split()))", "li", "lambda : list(map(int,input().split()))", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "yes = \"Yes\"", "yes", "\"Yes\"", "no = \"No\"", "no", "\"No\"", "def main():\n a,b,c = mi()\n if c-a-b<=0:\n print(no)\n exit()\n else:\n if (c-a-b)**2 > 4*a*b:\n print(yes)#gcdは3.4.3だとfractionsにある", "main", "a,b,c = mi()", "a", "mi()", "mi", "b", "c", "if c-a-b<=0:\n print(no)\n exit()\n else:\n if (c-a-b)**2 > 4*a*b:\n print(yes)#gcdは3.4.3だとfractionsにある", "c-a-b<=0", "c-a-b", "c-a", "c", "a", "b", "0", "print(no)", "print", "no", "exit()", "exit", "if (c-a-b)**2 > 4*a*b:\n print(yes)#gcdは3.4.3だとfractionsにある", "(c-a-b)**2 > 4*a*b", "(c-a-b)**2", "c-a-b", "c-a", "c", "a", "b", "2", "4*a*b", "4*a", "4", "a", "b", "print(yes)", "print", "yes", "from fractions import gcd", "import math", "math", "from math import factorial as f", "from math import ceil,floor,sqrt", "import bisect", "bisect", "import re", "re", "import heapq", "heapq", "from copy import deepcopy", "import itertools", "itertools", "from sys import exit", "ii = lambda : int(input())", "ii", "lambda : int(input())", "int(input())", "int", "input()", "input", "mi = lambda : map(int,input().split())", "mi", "lambda : map(int,input().split())", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "li = lambda : list(map(int,input().split()))", "li", "lambda : list(map(int,input().split()))", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "yes = \"YES\"", "yes", "\"YES\"", "no = \"NO\"", "no", "\"NO\"", "def main():\n n,l = mi()\n a = li()\n\n flag = False\n lp = 0\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n print(\"Possible\")\n flag = True\n lp = i+1\n break\n \n if not flag:\n print(\"Impossible\")\n exit()\n\n for i in range(1,lp):\n print(i)\n for i in range(n-1,lp,-1):\n print(i)\n print(lp)\n \n \n\n ", "main", "n,l = mi()", "n", "mi()", "mi", "l", "a = li()", "a", "li()", "li", "flag = False", "flag", "False", "lp = 0", "lp", "0", "for i in range(n-1):\n if a[i]+a[i+1] >= l:\n print(\"Possible\")\n flag = True\n lp = i+1\n break\n \n ", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1] >= l:\n print(\"Possible\")\n flag = True\n lp = 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", "print(\"Possible\")", "print", "\"Possible\"", "flag = True", "flag", "True", "lp = i+1", "lp", "i+1", "i", "1", "break", "if not flag:\n print(\"Impossible\")\n exit()\n\n ", "not flag", "flag", "print(\"Impossible\")", "print", "\"Impossible\"", "exit()", "exit", "for i in range(1,lp):\n print(i)\n ", "i", "range(1,lp)", "range", "1", "lp", "print(i)", "print", "i", "for i in range(n-1,lp,-1):\n print(i)\n ", "i", "range(n-1,lp,-1)", "range", "n-1", "n", "1", "lp", "-1", "print(i)", "print", "i", "print(lp)", "print", "lp", "main()", "main", "yes = \"Yes\"", "\"Yes\"", "yes", "ii = lambda : int(input())", "lambda : int(input())", "ii", "mi = lambda : map(int,input().split())", "lambda : map(int,input().split())", "mi", "def main():\n n,l = mi()\n a = li()\n\n flag = False\n lp = 0\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n print(\"Possible\")\n flag = True\n lp = i+1\n break\n \n if not flag:\n print(\"Impossible\")\n exit()\n\n for i in range(1,lp):\n print(i)\n for i in range(n-1,lp,-1):\n print(i)\n print(lp)\n \n \n\n ", "def main():\n n,l = mi()\n a = li()\n\n flag = False\n lp = 0\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n print(\"Possible\")\n flag = True\n lp = i+1\n break\n \n if not flag:\n print(\"Impossible\")\n exit()\n\n for i in range(1,lp):\n print(i)\n for i in range(n-1,lp,-1):\n print(i)\n print(lp)\n \n \n\n ", "main", "li = lambda : list(map(int,input().split()))", "lambda : list(map(int,input().split()))", "li", "def main():\n a,b,c = mi()\n if c-a-b<=0:\n print(no)\n exit()\n else:\n if (c-a-b)**2 > 4*a*b:\n print(yes)#gcdは3.4.3だとfractionsにある", "def main():\n a,b,c = mi()\n if c-a-b<=0:\n print(no)\n exit()\n else:\n if (c-a-b)**2 > 4*a*b:\n print(yes)#gcdは3.4.3だとfractionsにある", "main", "mi = lambda : map(int,input().split())", "lambda : map(int,input().split())", "mi", "no = \"No\"", "\"No\"", "no", "li = lambda : list(map(int,input().split()))", "lambda : list(map(int,input().split()))", "li", "yes = \"YES\"", "\"YES\"", "yes", "ii = lambda : int(input())", "lambda : int(input())", "ii", "no = \"NO\"", "\"NO\"", "no" ]

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

[ [ 125, 2 ], [ 155, 9 ], [ 129, 11 ], [ 155, 12 ], [ 131, 14 ], [ 129, 16 ], [ 140, 18 ], [ 149, 21 ], [ 134, 24 ], [ 28, 27 ], [ 147, 30 ], [ 132, 34 ], [ 27, 35 ], [ 156, 36 ], [ 137, 38 ], [ 27, 39 ], [ 135, 43 ], [ 47, 46 ], [ 147, 50 ], [ 132, 57 ], [ 46, 61 ], [ 156, 63 ], [ 143, 65 ], [ 46, 66 ], [ 152, 68 ], [ 144, 73 ], [ 135, 73 ], [ 83, 82 ], [ 147, 86 ], [ 82, 90 ], [ 144, 91 ], [ 135, 91 ], [ 82, 96 ], [ 100, 99 ], [ 147, 103 ], [ 99, 109 ], [ 144, 110 ], [ 135, 110 ], [ 99, 115 ], [ 144, 122 ], [ 135, 122 ], [ 125, 126 ], [ 131, 132 ], [ 134, 135 ], [ 27, 137 ], [ 137, 138 ], [ 140, 141 ], [ 46, 143 ], [ 143, 144 ], [ 155, 147 ], [ 149, 150 ], [ 152, 153 ], [ 155, 156 ] ]

[ "# coding:utf-8\n\nINF = float('inf')\n\n\ndef inpl(): return list(map(int, input().split()))\n\n\nN, L = inpl()\nA = inpl()\n\ntmp = 0\nconnect = False\nknot = None\nfor i in range(N):\n if A[i] >= L:\n knots = i\n break\n\nif knot is None:\n for i in range(N - 1):\n if sum(A[i:i + 2]) >= L:\n knot = i\n connect = True\n break\n\nif knot is None:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(N - 1):\n if i == knot:\n break\n else:\n print(i + 1)\n\n for i in range(N - 2, -1, -1):\n if i == knot:\n break\n else:\n print(i + 1)\n if connect:\n print(knot + 1)", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "def inpl(): return list(map(int, input().split()))", "inpl", "N, L = inpl()", "N", "inpl()", "inpl", "L", "A = inpl()", "A", "inpl()", "inpl", "tmp = 0", "tmp", "0", "connect = False", "connect", "False", "knot = None", "knot", "None", "for i in range(N):\n if A[i] >= L:\n knots = i\n break", "i", "range(N)", "range", "N", "if A[i] >= L:\n knots = i\n break", "A[i] >= L", "A[i]", "A", "i", "L", "knots = i", "knots", "i", "break", "if knot is None:\n for i in range(N - 1):\n if sum(A[i:i + 2]) >= L:\n knot = i\n connect = True\n break", "knot is None", "knot", "None", "for i in range(N - 1):\n if sum(A[i:i + 2]) >= L:\n knot = i\n connect = True\n break", "i", "range(N - 1)", "range", "N - 1", "N", "1", "if sum(A[i:i + 2]) >= L:\n knot = i\n connect = True\n break", "sum(A[i:i + 2]) >= L", "sum(A[i:i + 2])", "sum", "A[i:i + 2]", "A", "i:i + 2", "i", "i + 2", "i", "2", "L", "knot = i", "knot", "i", "connect = True", "connect", "True", "break", "if knot is None:\n print('Impossible')\nelse:\n print('Possible')\n for i in range(N - 1):\n if i == knot:\n break\n else:\n print(i + 1)\n\n for i in range(N - 2, -1, -1):\n if i == knot:\n break\n else:\n print(i + 1)\n if connect:\n print(knot + 1)", "knot is None", "knot", "None", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "for i in range(N - 1):\n if i == knot:\n break\n else:\n print(i + 1)\n\n ", "i", "range(N - 1)", "range", "N - 1", "N", "1", "if i == knot:\n break\n else:\n print(i + 1)\n\n ", "i == knot", "i", "knot", "break", "print(i + 1)", "print", "i + 1", "i", "1", "for i in range(N - 2, -1, -1):\n if i == knot:\n break\n else:\n print(i + 1)\n ", "i", "range(N - 2, -1, -1)", "range", "N - 2", "N", "2", "-1", "-1", "if i == knot:\n break\n else:\n print(i + 1)\n ", "i == knot", "i", "knot", "break", "print(i + 1)", "print", "i + 1", "i", "1", "if connect:\n print(knot + 1)", "connect", "print(knot + 1)", "print", "knot + 1", "knot", "1", "INF = float('inf')", "float('inf')", "INF", "def inpl(): return list(map(int, input().split()))", "def inpl(): return list(map(int, input().split()))", "inpl", "A = inpl()", "inpl()", "A", "knot = None", "None", "knot", "knots = i", "i", "knots", "tmp = 0", "0", "tmp", "knot = i", "i", "knot", "N, L = inpl()", "inpl()", "N", "connect = False", "False", "connect", "connect = True", "True", "connect", "L = inpl()", "inpl()", "L" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 102, 14 ], [ 102, 16 ], [ 20, 19 ], [ 19, 28 ], [ 105, 30 ], [ 93, 33 ], [ 37, 36 ], [ 97, 40 ], [ 106, 46 ], [ 36, 47 ], [ 106, 49 ], [ 36, 51 ], [ 103, 53 ], [ 99, 55 ], [ 36, 56 ], [ 100, 60 ], [ 94, 60 ], [ 70, 69 ], [ 100, 74 ], [ 94, 74 ], [ 69, 78 ], [ 81, 80 ], [ 97, 85 ], [ 100, 86 ], [ 94, 86 ], [ 97, 90 ], [ 80, 91 ], [ 93, 94 ], [ 102, 97 ], [ 36, 99 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ] ]

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

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

[ [ 124, 20 ], [ 139, 27 ], [ 142, 36 ], [ 137, 38 ], [ 142, 39 ], [ 127, 41 ], [ 137, 43 ], [ 148, 45 ], [ 151, 48 ], [ 52, 51 ], [ 143, 55 ], [ 149, 58 ], [ 131, 58 ], [ 128, 61 ], [ 51, 62 ], [ 128, 64 ], [ 51, 66 ], [ 130, 69 ], [ 128, 72 ], [ 51, 73 ], [ 128, 75 ], [ 51, 77 ], [ 133, 80 ], [ 51, 81 ], [ 131, 84 ], [ 149, 84 ], [ 122, 85 ], [ 96, 95 ], [ 134, 99 ], [ 152, 99 ], [ 95, 102 ], [ 105, 104 ], [ 134, 109 ], [ 152, 109 ], [ 143, 111 ], [ 104, 116 ], [ 134, 119 ], [ 152, 119 ], [ 142, 122 ], [ 124, 125 ], [ 127, 128 ], [ 130, 131 ], [ 51, 133 ], [ 133, 134 ], [ 139, 140 ], [ 142, 143 ], [ 148, 149 ], [ 151, 152 ] ]

[ "#!/usr/bin/env python3\n#AGC2 C\n\nimport sys\nimport math\nfrom bisect import bisect_right as br\nfrom bisect import bisect_left as bl\nsys.setrecursionlimit(1000000000)\nfrom heapq import heappush, heappop,heappushpop\nfrom collections import defaultdict\nfrom itertools import accumulate\nfrom collections import Counter\nfrom collections import deque\nfrom operator import itemgetter\nfrom itertools import permutations\nmod = 10**9 + 7\ninf = float('inf')\ndef I(): return int(sys.stdin.readline())\ndef LI(): return list(map(int,sys.stdin.readline().split()))\n\nn,l = LI()\na = LI()\ntmp = 0\ninde = 0\nfor i in range(1,n):\n if tmp < a[i] + a[i-1]:\n tmp = a[i]+a[i-1]\n inde = i\nif tmp < l:\n print('Impossible')\n quit()\nprint('Possible')\nfor i in range(1,inde):\n print(i)\nfor i in range(inde+1,n)[::-1]:\n print(i)\nprint(inde)", "import sys", "sys", "import math", "math", "from bisect import bisect_right as br", "from bisect import bisect_left as bl", "sys.setrecursionlimit(1000000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "1000000000", "from heapq import heappush, heappop,heappushpop", "from collections import defaultdict", "from itertools import accumulate", "from collections import Counter", "from collections import deque", "from operator import itemgetter", "from itertools import permutations", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "inf = float('inf')", "inf", "float('inf')", "float", "'inf'", "def I(): return int(sys.stdin.readline())", "I", "def LI(): return list(map(int,sys.stdin.readline().split()))", "LI", "n,l = LI()", "n", "LI()", "LI", "l", "a = LI()", "a", "LI()", "LI", "tmp = 0", "tmp", "0", "inde = 0", "inde", "0", "for i in range(1,n):\n if tmp < a[i] + a[i-1]:\n tmp = a[i]+a[i-1]\n inde = i", "i", "range(1,n)", "range", "1", "n", "if tmp < a[i] + a[i-1]:\n tmp = a[i]+a[i-1]\n inde = i", "tmp < a[i] + a[i-1]", "tmp", "a[i] + a[i-1]", "a[i]", "a", "i", "a[i-1]", "a", "i-1", "i", "1", "tmp = a[i]+a[i-1]", "tmp", "a[i]+a[i-1]", "a[i]", "a", "i", "a[i-1]", "a", "i-1", "i", "1", "inde = i", "inde", "i", "if tmp < l:\n print('Impossible')\n quit()", "tmp < l", "tmp", "l", "print('Impossible')", "print", "'Impossible'", "quit()", "quit", "print('Possible')", "print", "'Possible'", "for i in range(1,inde):\n print(i)", "i", "range(1,inde)", "range", "1", "inde", "print(i)", "print", "i", "for i in range(inde+1,n)[::-1]:\n print(i)", "i", "range(inde+1,n)[::-1]", "(inde+1,n)", "range", "inde+1", "inde", "1", "n", "::-1", "-1", "print(i)", "print", "i", "print(inde)", "print", "inde", "l = LI()", "LI()", "l", "mod = 10**9 + 7", "10**9 + 7", "mod", "a = LI()", "LI()", "a", "tmp = a[i]+a[i-1]", "a[i]+a[i-1]", "tmp", "inde = i", "i", "inde", "def LI(): return list(map(int,sys.stdin.readline().split()))", "def LI(): return list(map(int,sys.stdin.readline().split()))", "LI", "inf = float('inf')", "float('inf')", "inf", "n,l = LI()", "LI()", "n", "def I(): return int(sys.stdin.readline())", "def I(): return int(sys.stdin.readline())", "I", "tmp = 0", "0", "tmp", "inde = 0", "0", "inde" ]

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

[ [ 99, 2 ], [ 99, 11 ], [ 96, 13 ], [ 93, 25 ], [ 29, 28 ], [ 100, 32 ], [ 97, 38 ], [ 28, 39 ], [ 97, 41 ], [ 28, 43 ], [ 88, 45 ], [ 90, 47 ], [ 28, 49 ], [ 91, 53 ], [ 94, 53 ], [ 63, 62 ], [ 91, 66 ], [ 94, 66 ], [ 62, 69 ], [ 72, 71 ], [ 97, 77 ], [ 91, 80 ], [ 94, 80 ], [ 71, 85 ], [ 99, 88 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ] ]

[ "n,l=map(int,input().split())\na=list(map(int,input().split()))\nlast=-1\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n last=i+1\nif last==-1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,last):\n print(i)\n for i in range(len(a)-1,last-1,-1):\n print(i)", "n,l=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "last=-1", "last", "-1", "for i in range(n-1):\n if a[i]+a[i+1]>=l:\n last=i+1", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n last=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", "last=i+1", "last", "i+1", "i", "1", "if last==-1:\n print(\"Impossible\")\nelse:\n print(\"Possible\")\n for i in range(1,last):\n print(i)\n for i in range(len(a)-1,last-1,-1):\n print(i)", "last==-1", "last", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,last):\n print(i)\n ", "i", "range(1,last)", "range", "1", "last", "print(i)", "print", "i", "for i in range(len(a)-1,last-1,-1):\n print(i)", "i", "range(len(a)-1,last-1,-1)", "range", "len(a)-1", "len(a)", "len", "a", "1", "last-1", "last", "1", "-1", "print(i)", "print", "i", "l=map(int,input().split())", "map(int,input().split())", "l", "last=i+1", "i+1", "last", "last=-1", "-1", "last", "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, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 4, 13, 17, 0, 13, 39, 28, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 13, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 17, 4, 18, 13, 13, 13, 4, 18, 13, 13, 2, 13, 17, 28, 13, 13, 4, 13, 13, 3, 4, 13, 17, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 105, 2 ], [ 105, 11 ], [ 102, 13 ], [ 26, 25 ], [ 100, 29 ], [ 103, 35 ], [ 25, 36 ], [ 103, 38 ], [ 25, 40 ], [ 106, 42 ], [ 96, 47 ], [ 51, 50 ], [ 25, 55 ], [ 97, 59 ], [ 50, 61 ], [ 64, 63 ], [ 100, 67 ], [ 25, 70 ], [ 97, 75 ], [ 63, 77 ], [ 97, 80 ], [ 25, 83 ], [ 87, 86 ], [ 97, 86 ], [ 86, 90 ], [ 96, 97 ], [ 105, 100 ], [ 102, 103 ], [ 105, 106 ] ]

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

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

[ [ 253, 13 ], [ 229, 27 ], [ 44, 44 ], [ 48, 47 ], [ 254, 55 ], [ 59, 59 ], [ 63, 62 ], [ 254, 70 ], [ 74, 74 ], [ 78, 77 ], [ 254, 90 ], [ 95, 95 ], [ 99, 98 ], [ 254, 111 ], [ 116, 116 ], [ 121, 120 ], [ 242, 122 ], [ 121, 123 ], [ 126, 125 ], [ 224, 127 ], [ 130, 129 ], [ 133, 132 ], [ 120, 136 ], [ 125, 142 ], [ 132, 143 ], [ 125, 145 ], [ 132, 147 ], [ 123, 149 ], [ 152, 151 ], [ 132, 153 ], [ 129, 157 ], [ 132, 160 ], [ 129, 165 ], [ 175, 174 ], [ 151, 178 ], [ 120, 180 ], [ 129, 183 ], [ 174, 185 ], [ 188, 187 ], [ 151, 191 ], [ 129, 197 ], [ 187, 199 ], [ 129, 202 ], [ 206, 205 ], [ 129, 210 ], [ 129, 214 ], [ 205, 215 ], [ 257, 221 ], [ 229, 230 ], [ 253, 254 ] ]

[ "import sys, bisect, math, itertools, string, queue, copy\n# import numpy as np\n# import scipy\nfrom collections import Counter,defaultdict,deque\nfrom itertools import permutations, combinations\nfrom heapq import heappop, heappush\ninput = sys.stdin.readline\nsys.setrecursionlimit(10**8)\nmod = 10**9+7\ndef inp(): return int(input()) # n=1\ndef inpm(): return map(int,input().split()) # x=1,y=2\ndef inpl(): return list(map(int, input().split())) # a=[1,2,3,4,5,...,n]\ndef inpls(): return list(input().split()) # a=['1','2','3',...,'n']\ndef inplm(n): return list(int(input()) for _ in range(n)) # x=[] 複数行\ndef inplL(n): return [list(input()) for _ in range(n)]\ndef inplT(n): return [tuple(input()) for _ in range(n)]\ndef inpll(n): return [list(map(int, input().split())) for _ in range(n)] # [[2,2,2,2],[1,1,1,1],[3,3,3,3]] \ndef inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)]) # [[1,1,1,1],[2,2,2,2],[3,3,3,3]] \n \ndef main():\n n,l = inpm()\n a = inpl()\n ans = []\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n x = i+1\n ans.append(i+1)\n break\n if ans == []:\n print('Impossible')\n else:\n print('Possible')\n for i in range(x+1,n):\n ans.append(i)\n for i in range(x-1,0,-1):\n ans.append(i)\n ans.reverse()\n for i in range(len(ans)):\n print(ans[i])\n \nif __name__ == \"__main__\":\n main()", "import sys, bisect, math, itertools, string, queue, copy", "sys", "bisect", "math", "itertools", "string", "queue", "copy", "from collections import Counter,defaultdict,deque", "from itertools import permutations, combinations", "from heapq import heappop, heappush", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "sys.setrecursionlimit(10**8)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**8", "10", "8", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "def inp(): return int(input()) # n=1", "inp", "def inpm(): return map(int,input().split()) # x=1,y=2", "inpm", "def inpl(): return list(map(int, input().split())) # a=[1,2,3,4,5,...,n]", "inpl", "def inpls(): return list(input().split()) # a=['1','2','3',...,'n']", "inpls", "def inplm(n): return list(int(input()) for _ in range(n)) # x=[] 複数行", "inplm", "n", "n", "list(input()) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "list(input())", "list", "input()", "input", "def inplL(n): return [list(input()) for _ in range(n)]", "inplL", "n", "n", "tuple(input()) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "tuple(input())", "tuple", "input()", "input", "def inplT(n): return [tuple(input()) for _ in range(n)]", "inplT", "n", "n", "list(map(int, input().split())) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def inpll(n): return [list(map(int, input().split())) for _ in range(n)] # [[2,2,2,2],[1,1,1,1],[3,3,3,3]] ", "inpll", "n", "n", "list(map(int, input().split())) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)]) # [[1,1,1,1],[2,2,2,2],[3,3,3,3]] \n ", "inplls", "n", "n", "def main():\n n,l = inpm()\n a = inpl()\n ans = []\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n x = i+1\n ans.append(i+1)\n break\n if ans == []:\n print('Impossible')\n else:\n print('Possible')\n for i in range(x+1,n):\n ans.append(i)\n for i in range(x-1,0,-1):\n ans.append(i)\n ans.reverse()\n for i in range(len(ans)):\n print(ans[i])\n ", "main", "n,l = inpm()", "n", "inpm()", "inpm", "l", "a = inpl()", "a", "inpl()", "inpl", "ans = []", "ans", "[]", "for i in range(n-1):\n if a[i]+a[i+1] >= l:\n x = i+1\n ans.append(i+1)\n break\n ", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1] >= l:\n x = i+1\n ans.append(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", "x = i+1", "x", "i+1", "i", "1", "ans.append(i+1)", "ans.append", "ans", "append", "i+1", "i", "1", "break", "if ans == []:\n print('Impossible')\n else:\n print('Possible')\n for i in range(x+1,n):\n ans.append(i)\n for i in range(x-1,0,-1):\n ans.append(i)\n ans.reverse()\n for i in range(len(ans)):\n print(ans[i])\n ", "ans == []", "ans", "[]", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "for i in range(x+1,n):\n ans.append(i)\n ", "i", "range(x+1,n)", "range", "x+1", "x", "1", "n", "ans.append(i)", "ans.append", "ans", "append", "i", "for i in range(x-1,0,-1):\n ans.append(i)\n ", "i", "range(x-1,0,-1)", "range", "x-1", "x", "1", "0", "-1", "ans.append(i)", "ans.append", "ans", "append", "i", "ans.reverse()", "ans.reverse", "ans", "reverse", "for i in range(len(ans)):\n print(ans[i])\n ", "i", "range(len(ans))", "range", "len(ans)", "len", "ans", "print(ans[i])", "print", "ans[i]", "ans", "i", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def inpl(): return list(map(int, input().split())) # a=[1,2,3,4,5,...,n]", "def inpl(): return list(map(int, input().split())) # a=[1,2,3,4,5,...,n]", "inpl", "def inplT(n): return [tuple(input()) for _ in range(n)]", "def inplT(n): return [tuple(input()) for _ in range(n)]", "inplT", "mod = 10**9+7", "10**9+7", "mod", "def inpls(): return list(input().split()) # a=['1','2','3',...,'n']", "def inpls(): return list(input().split()) # a=['1','2','3',...,'n']", "inpls", "def inplm(n): return list(int(input()) for _ in range(n)) # x=[] 複数行", "def inplm(n): return list(int(input()) for _ in range(n)) # x=[] 複数行", "inplm", "def inp(): return int(input()) # n=1", "def inp(): return int(input()) # n=1", "inp", "def inpm(): return map(int,input().split()) # x=1,y=2", "def inpm(): return map(int,input().split()) # x=1,y=2", "inpm", "def inpll(n): return [list(map(int, input().split())) for _ in range(n)] # [[2,2,2,2],[1,1,1,1],[3,3,3,3]] ", "def inpll(n): return [list(map(int, input().split())) for _ in range(n)] # [[2,2,2,2],[1,1,1,1],[3,3,3,3]] ", "inpll", "def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)]) # [[1,1,1,1],[2,2,2,2],[3,3,3,3]] \n ", "def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)]) # [[1,1,1,1],[2,2,2,2],[3,3,3,3]] \n ", "inplls", "def inplL(n): return [list(input()) for _ in range(n)]", "def inplL(n): return [list(input()) for _ in range(n)]", "inplL", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def main():\n n,l = inpm()\n a = inpl()\n ans = []\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n x = i+1\n ans.append(i+1)\n break\n if ans == []:\n print('Impossible')\n else:\n print('Possible')\n for i in range(x+1,n):\n ans.append(i)\n for i in range(x-1,0,-1):\n ans.append(i)\n ans.reverse()\n for i in range(len(ans)):\n print(ans[i])\n ", "def main():\n n,l = inpm()\n a = inpl()\n ans = []\n for i in range(n-1):\n if a[i]+a[i+1] >= l:\n x = i+1\n ans.append(i+1)\n break\n if ans == []:\n print('Impossible')\n else:\n print('Possible')\n for i in range(x+1,n):\n ans.append(i)\n for i in range(x-1,0,-1):\n ans.append(i)\n ans.reverse()\n for i in range(len(ans)):\n print(ans[i])\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, 42, 2, 13, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 17, 3, 0, 13, 17, 14, 40, 13, 4, 13, 17, 4, 13, 17, 28, 13, 4, 13, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 17, 13, 17, 4, 13, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13 ]

[ [ 96, 2 ], [ 96, 11 ], [ 99, 13 ], [ 105, 25 ], [ 102, 28 ], [ 106, 32 ], [ 88, 32 ], [ 97, 34 ], [ 100, 40 ], [ 106, 41 ], [ 88, 41 ], [ 100, 43 ], [ 106, 45 ], [ 88, 45 ], [ 94, 47 ], [ 90, 49 ], [ 87, 53 ], [ 91, 57 ], [ 103, 57 ], [ 66, 65 ], [ 88, 68 ], [ 106, 68 ], [ 65, 72 ], [ 76, 75 ], [ 97, 79 ], [ 88, 81 ], [ 106, 81 ], [ 75, 85 ], [ 87, 88 ], [ 90, 91 ], [ 96, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ] ]

[ "N, L = map(int, input().split())\na = list(map(int, input().split()))\n\n#最後に切るものを決める\ni = 0\nflag = False\nwhile i < N - 1:\n if a[i] + a[i + 1] >= L:\n flag = True\n break\n i += 1\n\nif not flag:\n print ('Impossible')\nelse:\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, 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 = 0", "i", "0", "flag = False", "flag", "False", "while i < N - 1:\n if a[i] + a[i + 1] >= L:\n flag = True\n break\n i += 1", "i < N - 1", "i", "N - 1", "N", "1", "if a[i] + a[i + 1] >= L:\n flag = 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", "flag = True", "flag", "True", "break", "i += 1", "i", "1", "if not flag:\n print ('Impossible')\nelse:\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)", "not flag", "flag", "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", "i += 1", "1", "i", "flag = True", "True", "flag", "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", "flag = False", "False", "flag", "i = 0", "0", "i" ]

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

[ [ 89, 4 ], [ 89, 13 ], [ 92, 15 ], [ 28, 27 ], [ 90, 31 ], [ 93, 37 ], [ 27, 38 ], [ 93, 40 ], [ 27, 42 ], [ 84, 44 ], [ 86, 46 ], [ 27, 47 ], [ 61, 60 ], [ 60, 65 ], [ 60, 69 ], [ 72, 71 ], [ 90, 75 ], [ 71, 77 ], [ 71, 81 ], [ 89, 84 ], [ 27, 86 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ] ]

[ "import sys\n\nN, L = map(int, input().split())\na = list(map(int, input().split()))\n\nfor i in range(N-1):\n if(a[i]+a[i+1] >= L):\n idx = i\n break\nelse:\n print(\"Impossible\")\n sys.exit()\n \nprint(\"Possible\")\n\nfor i in range(1, i+1):\n print(i)\n \nfor i in range(N-1, i, -1):\n print(i)", "import sys", "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", "for i in range(N-1):\n if(a[i]+a[i+1] >= L):\n idx = i\n break\nelse:\n print(\"Impossible\")\n sys.exit()\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if(a[i]+a[i+1] >= L):\n idx = i\n break", "a[i]+a[i+1] >= L", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "L", "idx = i", "idx", "i", "break", "print(\"Impossible\")", "print", "\"Impossible\"", "sys.exit()", "sys.exit", "sys", "exit", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1, i+1):\n print(i)\n ", "i", "range(1, i+1)", "range", "1", "i+1", "i", "1", "print(i)", "print", "i", "for i in range(N-1, i, -1):\n print(i)", "i", "range(N-1, i, -1)", "range", "N-1", "N", "1", "i", "-1", "print(i)", "print", "i", "L = map(int, input().split())", "map(int, input().split())", "L", "idx = i", "i", "idx", "N, L = map(int, input().split())", "map(int, input().split())", "N", "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, 17, 0, 13, 13, 14, 13, 4, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 4, 13, 13, 28, 13, 4, 13, 4, 13, 2, 13, 17, 13, 4, 13, 13, 4, 13, 2, 13, 17, 4, 13, 17, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 105, 2 ], [ 105, 11 ], [ 93, 13 ], [ 96, 25 ], [ 29, 28 ], [ 106, 32 ], [ 94, 38 ], [ 28, 39 ], [ 94, 41 ], [ 28, 43 ], [ 100, 45 ], [ 90, 47 ], [ 102, 50 ], [ 28, 51 ], [ 59, 58 ], [ 103, 63 ], [ 58, 67 ], [ 70, 69 ], [ 103, 75 ], [ 106, 77 ], [ 69, 80 ], [ 103, 84 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 105, 100 ], [ 28, 102 ], [ 102, 103 ], [ 105, 106 ] ]

[ "n,l=map(int,input().split())\na=list(map(int,input().split()))\nok=False\nfor i in range(n-1):\n if a[i]+a[i+1]>=l:\n ok=True\n idx=i\nif ok:\n print(\"Possible\")\n for i in range(1,idx+1):\n print(i)\n for i in reversed(range(idx+2,n)):\n print(i)\n print(idx+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", "ok=False", "ok", "False", "for i in range(n-1):\n if a[i]+a[i+1]>=l:\n ok=True\n idx=i", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n ok=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", "ok=True", "ok", "True", "idx=i", "idx", "i", "if ok:\n print(\"Possible\")\n for i in range(1,idx+1):\n print(i)\n for i in reversed(range(idx+2,n)):\n print(i)\n print(idx+1)\nelse:\n print(\"Impossible\")", "ok", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1,idx+1):\n print(i)\n ", "i", "range(1,idx+1)", "range", "1", "idx+1", "idx", "1", "print(i)", "print", "i", "for i in reversed(range(idx+2,n)):\n print(i)\n ", "i", "reversed(range(idx+2,n))", "reversed", "range(idx+2,n)", "range", "idx+2", "idx", "2", "n", "print(i)", "print", "i", "print(idx+1)", "print", "idx+1", "idx", "1", "print(\"Impossible\")", "print", "\"Impossible\"", "ok=True", "True", "ok", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "ok=False", "False", "ok", "l=map(int,input().split())", "map(int,input().split())", "l", "idx=i", "i", "idx", "n,l=map(int,input().split())", "map(int,input().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, 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, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 89, 2 ], [ 89, 11 ], [ 15, 14 ], [ 14, 23 ], [ 86, 25 ], [ 29, 28 ], [ 84, 32 ], [ 87, 38 ], [ 28, 39 ], [ 87, 41 ], [ 28, 43 ], [ 90, 45 ], [ 51, 50 ], [ 28, 53 ], [ 50, 57 ], [ 61, 60 ], [ 84, 64 ], [ 28, 66 ], [ 60, 71 ], [ 28, 76 ], [ 89, 84 ], [ 86, 87 ], [ 89, 90 ] ]

[ "N, L = map(int, input().split())\na = [int(i) for i in 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, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "a = [int(i) for i in input().split()]", "a", "[int(i) for i in input().split()]", "for i in range(N - 1) :\n if a[i] + a[i+1] >= L :\n print('Possible')\n for j in range(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('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'", "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", "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, 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, 28, 13, 4, 13, 2, 13, 17, 13, 17, 4, 13, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 69, 2 ], [ 69, 11 ], [ 72, 13 ], [ 26, 25 ], [ 70, 29 ], [ 73, 35 ], [ 25, 36 ], [ 73, 38 ], [ 25, 40 ], [ 67, 42 ], [ 48, 47 ], [ 25, 50 ], [ 53, 52 ], [ 70, 56 ], [ 25, 58 ], [ 69, 67 ], [ 69, 70 ], [ 72, 73 ] ]

[ "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 for j in range(i):print(j+1)\n for j in range(n-1,i,-1):print(j)\n exit()\nprint(\"Impossible\")", "n,l=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "a=list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(n-1):\n if a[i]+a[i+1]>=l:\n print(\"Possible\")\n for j in range(i):print(j+1)\n for j in range(n-1,i,-1):print(j)\n exit()", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i]+a[i+1]>=l:\n print(\"Possible\")\n for j in range(i):print(j+1)\n for j in range(n-1,i,-1):print(j)\n exit()", "a[i]+a[i+1]>=l", "a[i]+a[i+1]", "a[i]", "a", "i", "a[i+1]", "a", "i+1", "i", "1", "l", "print(\"Possible\")", "print", "\"Possible\"", "for j in range(i):print(j+1)\n ", "j", "range(i)", "range", "i", "for j in range(n-1,i,-1):print(j)\n ", "j", "range(n-1,i,-1)", "range", "n-1", "n", "1", "i", "-1", "exit()", "exit", "print(\"Impossible\")", "print", "\"Impossible\"", "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, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 18, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 17, 0, 13, 2, 13, 17, 3, 14, 13, 4, 13, 17, 28, 13, 4, 13, 17, 13, 4, 13, 13, 28, 13, 4, 13, 4, 13, 2, 13, 17, 13, 4, 13, 13, 4, 13, 13, 4, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 28, 27 ], [ 31, 30 ], [ 34, 33 ], [ 4, 37 ], [ 15, 43 ], [ 33, 44 ], [ 15, 46 ], [ 33, 48 ], [ 13, 50 ], [ 53, 52 ], [ 56, 55 ], [ 33, 57 ], [ 67, 66 ], [ 55, 70 ], [ 30, 70 ], [ 66, 73 ], [ 76, 75 ], [ 55, 81 ], [ 30, 81 ], [ 4, 83 ], [ 75, 86 ], [ 55, 89 ], [ 30, 89 ], [ 101, 98 ] ]

[ "def main():\n n, l = map(int, input().split())\n a = list(map(int, input().split()))\n f = False\n idx = -1\n for i in range(n-1):\n if a[i] + a[i+1] >= l:\n f = True\n idx = i+1\n break\n if f:\n print(\"Possible\")\n for i in range(1, idx):\n print(i)\n for i in reversed(range(idx+1, n)):\n print(i)\n print(idx)\n else:\n print(\"Impossible\")\n\nif __name__ == \"__main__\":\n main()", "def main():\n n, l = map(int, input().split())\n a = list(map(int, input().split()))\n f = False\n idx = -1\n for i in range(n-1):\n if a[i] + a[i+1] >= l:\n f = True\n idx = i+1\n break\n if f:\n print(\"Possible\")\n for i in range(1, idx):\n print(i)\n for i in reversed(range(idx+1, n)):\n print(i)\n print(idx)\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 = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "f = False", "f", "False", "idx = -1", "idx", "-1", "for i in range(n-1):\n if a[i] + a[i+1] >= l:\n f = True\n idx = i+1\n break\n ", "i", "range(n-1)", "range", "n-1", "n", "1", "if a[i] + a[i+1] >= l:\n f = True\n idx = 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", "f = True", "f", "True", "idx = i+1", "idx", "i+1", "i", "1", "break", "if f:\n print(\"Possible\")\n for i in range(1, idx):\n print(i)\n for i in reversed(range(idx+1, n)):\n print(i)\n print(idx)\n else:\n print(\"Impossible\")", "f", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1, idx):\n print(i)\n ", "i", "range(1, idx)", "range", "1", "idx", "print(i)", "print", "i", "for i in reversed(range(idx+1, n)):\n print(i)\n ", "i", "reversed(range(idx+1, n))", "reversed", "range(idx+1, n)", "range", "idx+1", "idx", "1", "n", "print(i)", "print", "i", "print(idx)", "print", "idx", "print(\"Impossible\")", "print", "\"Impossible\"", "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 f = False\n idx = -1\n for i in range(n-1):\n if a[i] + a[i+1] >= l:\n f = True\n idx = i+1\n break\n if f:\n print(\"Possible\")\n for i in range(1, idx):\n print(i)\n for i in reversed(range(idx+1, n)):\n print(i)\n print(idx)\n else:\n print(\"Impossible\")", "def main():\n n, l = map(int, input().split())\n a = list(map(int, input().split()))\n f = False\n idx = -1\n for i in range(n-1):\n if a[i] + a[i+1] >= l:\n f = True\n idx = i+1\n break\n if f:\n print(\"Possible\")\n for i in range(1, idx):\n print(i)\n for i in reversed(range(idx+1, n)):\n print(i)\n print(idx)\n else:\n print(\"Impossible\")", "main" ]

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

[ [ 108, 2 ], [ 108, 13 ], [ 114, 15 ], [ 111, 27 ], [ 31, 30 ], [ 103, 34 ], [ 117, 37 ], [ 115, 40 ], [ 30, 41 ], [ 115, 43 ], [ 30, 45 ], [ 118, 49 ], [ 109, 50 ], [ 105, 52 ], [ 99, 55 ], [ 30, 57 ], [ 106, 62 ], [ 112, 62 ], [ 106, 66 ], [ 112, 66 ], [ 106, 69 ], [ 112, 69 ], [ 72, 71 ], [ 100, 75 ], [ 71, 78 ], [ 81, 80 ], [ 103, 85 ], [ 100, 86 ], [ 103, 92 ], [ 80, 94 ], [ 100, 97 ], [ 99, 100 ], [ 108, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ] ]

[ "N, L = list(map(int, input().split()))\na = list(map(int, input().split()))\n\njudge = \"Impossible\"\nfor i in range(N - 1):\n\tx = a[i] + a[i + 1]\n\tif x >= L:\n\t\tjudge = \"Possible\"\n\t\tc = i + 1\n\t\tbreak\n\n\nif judge == \"Impossible\":\n\tprint(judge)\nelse:\n\tprint(judge)\n\tfor i in range(1, c):\n\t\tprint(i)\n\tfor i in range(N - c - 1):\n\t\tprint(N - 1 - i)\n\tprint(c)", "N, L = list(map(int, input().split()))", "N", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "judge = \"Impossible\"", "judge", "\"Impossible\"", "for i in range(N - 1):\n\tx = a[i] + a[i + 1]\n\tif x >= L:\n\t\tjudge = \"Possible\"\n\t\tc = i + 1\n\t\tbreak", "i", "range(N - 1)", "range", "N - 1", "N", "1", "x = a[i] + a[i + 1]", "x", "a[i] + a[i + 1]", "a[i]", "a", "i", "a[i + 1]", "a", "i + 1", "i", "1", "if x >= L:\n\t\tjudge = \"Possible\"\n\t\tc = i + 1\n\t\tbreak", "x >= L", "x", "L", "judge = \"Possible\"", "judge", "\"Possible\"", "c = i + 1", "c", "i + 1", "i", "1", "break", "if judge == \"Impossible\":\n\tprint(judge)\nelse:\n\tprint(judge)\n\tfor i in range(1, c):\n\t\tprint(i)\n\tfor i in range(N - c - 1):\n\t\tprint(N - 1 - i)\n\tprint(c)", "judge == \"Impossible\"", "judge", "\"Impossible\"", "print(judge)", "print", "judge", "print(judge)", "print", "judge", "for i in range(1, c):\n\t\tprint(i)\n\t", "i", "range(1, c)", "range", "1", "c", "print(i)", "print", "i", "for i in range(N - c - 1):\n\t\tprint(N - 1 - i)\n\t", "i", "range(N - c - 1)", "range", "N - c - 1", "N - c", "N", "c", "1", "print(N - 1 - i)", "print", "N - 1 - i", "N - 1", "N", "1", "i", "print(c)", "print", "c", "c = i + 1", "i + 1", "c", "N, L = list(map(int, input().split()))", "list(map(int, input().split()))", "N", "judge = \"Possible\"", "\"Possible\"", "judge", "L = list(map(int, input().split()))", "list(map(int, input().split()))", "L", "judge = \"Impossible\"", "\"Impossible\"", "judge", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "x = a[i] + a[i + 1]", "a[i] + a[i + 1]", "x" ]

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

[ [ 145, 2 ], [ 145, 11 ], [ 136, 13 ], [ 142, 25 ], [ 133, 28 ], [ 32, 31 ], [ 131, 35 ], [ 137, 41 ], [ 31, 42 ], [ 137, 44 ], [ 31, 46 ], [ 134, 48 ], [ 125, 48 ], [ 139, 50 ], [ 31, 51 ], [ 124, 53 ], [ 137, 56 ], [ 31, 57 ], [ 137, 59 ], [ 31, 61 ], [ 125, 65 ], [ 134, 65 ], [ 146, 66 ], [ 127, 74 ], [ 78, 77 ], [ 140, 80 ], [ 143, 80 ], [ 128, 83 ], [ 77, 86 ], [ 90, 89 ], [ 131, 93 ], [ 140, 96 ], [ 143, 96 ], [ 128, 101 ], [ 89, 103 ], [ 128, 106 ], [ 140, 109 ], [ 143, 109 ], [ 113, 112 ], [ 131, 116 ], [ 128, 121 ], [ 112, 122 ], [ 124, 125 ], [ 127, 128 ], [ 145, 131 ], [ 133, 134 ], [ 136, 137 ], [ 31, 139 ], [ 139, 140 ], [ 142, 143 ], [ 145, 146 ] ]

[ "n,l=map(int,input().split())\narr=list(map(int,input().split()))\npos=0\ntmp=0\nfor i in range(n-1):\n if (arr[i]+arr[i+1])>tmp:\n pos=i\n tmp=(arr[i]+arr[i+1])\nif tmp<l:\n print('Impossible')\nelse:\n print('Possible')\n ans=[]\n for i in range(pos):\n ans.append(i+1)\n for i in range(n-1,pos+1,-1):\n ans.append(i)\n ans.append(pos+1)\n for i in range(n-1):\n print(ans[i])", "n,l=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "arr=list(map(int,input().split()))", "arr", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "pos=0", "pos", "0", "tmp=0", "tmp", "0", "for i in range(n-1):\n if (arr[i]+arr[i+1])>tmp:\n pos=i\n tmp=(arr[i]+arr[i+1])", "i", "range(n-1)", "range", "n-1", "n", "1", "if (arr[i]+arr[i+1])>tmp:\n pos=i\n tmp=(arr[i]+arr[i+1])", "(arr[i]+arr[i+1])>tmp", "arr[i]+arr[i+1]", "arr[i]", "arr", "i", "arr[i+1]", "arr", "i+1", "i", "1", "tmp", "pos=i", "pos", "i", "tmp=(arr[i]+arr[i+1])", "tmp", "arr[i]+arr[i+1]", "arr[i]", "arr", "i", "arr[i+1]", "arr", "i+1", "i", "1", "if tmp<l:\n print('Impossible')\nelse:\n print('Possible')\n ans=[]\n for i in range(pos):\n ans.append(i+1)\n for i in range(n-1,pos+1,-1):\n ans.append(i)\n ans.append(pos+1)\n for i in range(n-1):\n print(ans[i])", "tmp<l", "tmp", "l", "print('Impossible')", "print", "'Impossible'", "print('Possible')", "print", "'Possible'", "ans=[]", "ans", "[]", "for i in range(pos):\n ans.append(i+1)\n ", "i", "range(pos)", "range", "pos", "ans.append(i+1)", "ans.append", "ans", "append", "i+1", "i", "1", "for i in range(n-1,pos+1,-1):\n ans.append(i)\n ", "i", "range(n-1,pos+1,-1)", "range", "n-1", "n", "1", "pos+1", "pos", "1", "-1", "ans.append(i)", "ans.append", "ans", "append", "i", "ans.append(pos+1)", "ans.append", "ans", "append", "pos+1", "pos", "1", "for i in range(n-1):\n print(ans[i])", "i", "range(n-1)", "range", "n-1", "n", "1", "print(ans[i])", "print", "ans[i]", "ans", "i", "tmp=(arr[i]+arr[i+1])", "arr[i]+arr[i+1]", "tmp", "ans=[]", "[]", "ans", "n,l=map(int,input().split())", "map(int,input().split())", "n", "tmp=0", "0", "tmp", "arr=list(map(int,input().split()))", "list(map(int,input().split()))", "arr", "pos=i", "i", "pos", "pos=0", "0", "pos", "l=map(int,input().split())", "map(int,input().split())", "l" ]

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

[ [ 57, 2 ], [ 57, 15 ], [ 57, 16 ], [ 55, 38 ], [ 57, 55 ], [ 57, 58 ] ]

[ "N, L, *a = map(int, open(0).read().split())\nfor i, (n, m) in enumerate(zip(a, a[1:]), 1):\n if n + m >= L:\n print('Possible')\n print('\\n'.join(c for it in (range(1,i), range(N-1,i,-1), [i]) for c in map(str, it)))\n break\nelse:\n print('Impossible')", "N, L, *a = map(int, open(0).read().split())", "N", "map(int, open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "L", "*a", "a", "for i, (n, m) in enumerate(zip(a, a[1:]), 1):\n if n + m >= L:\n print('Possible')\n print('\\n'.join(c for it in (range(1,i), range(N-1,i,-1), [i]) for c in map(str, it)))\n break\nelse:\n print('Impossible')", "i", "(n, m)", "n", "m", "enumerate(zip(a, a[1:]), 1)", "enumerate", "zip(a, a[1:])", "zip", "a", "a[1:]", "a", "1:", "1", "1", "if n + m >= L:\n print('Possible')\n print('\\n'.join(c for it in (range(1,i), range(N-1,i,-1), [i]) for c in map(str, it)))\n break", "n + m >= L", "n + m", "n", "m", "L", "print('Possible')", "print", "'Possible'", "print('\\n'.join(c for it in (range(1,i), range(N-1,i,-1), [i]) for c in map(str, it)))", "print", "'\\n'.join(c for it in (range(1,i), range(N-1,i,-1), [i]) for c in map(str, it))", "'\\n'.join", "'\\n'", "join", "c", "break", "print('Impossible')", "print", "'Impossible'", "L, *a = map(int, open(0).read().split())", "map(int, open(0).read().split())", "L", "N, L, *a = map(int, open(0).read().split())", "map(int, open(0).read().split())", "N" ]

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

[ [ 134, 4 ], [ 140, 11 ], [ 143, 18 ], [ 33, 32 ], [ 135, 39 ], [ 33, 41 ], [ 44, 43 ], [ 135, 52 ], [ 57, 56 ], [ 32, 60 ], [ 43, 65 ], [ 56, 66 ], [ 43, 68 ], [ 56, 70 ], [ 74, 73 ], [ 77, 76 ], [ 73, 83 ], [ 41, 88 ], [ 91, 90 ], [ 90, 95 ], [ 76, 95 ], [ 105, 104 ], [ 90, 108 ], [ 76, 108 ], [ 104, 111 ], [ 114, 113 ], [ 32, 117 ], [ 90, 119 ], [ 76, 119 ], [ 113, 123 ], [ 90, 126 ], [ 76, 126 ], [ 138, 132 ], [ 134, 135 ], [ 140, 141 ], [ 143, 144 ] ]

[ "import sys\n\nreadline = sys.stdin.readline\nMOD = 10 ** 9 + 7\nINF = float('INF')\nsys.setrecursionlimit(10 ** 5)\n\n\ndef main():\n n, l = map(int, readline().split())\n a = list(map(int, readline().split()))\n b = [a[i] + a[i + 1] for i in range(n - 1)]\n\n last = -1\n for i, x in enumerate(b, 1):\n if x >= l:\n last = i\n break\n\n if last == -1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n for i in range(1, last):\n print(i)\n for i in range(n - 1, last, -1):\n print(i)\n print(last)\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "INF = float('INF')", "INF", "float('INF')", "float", "'INF'", "sys.setrecursionlimit(10 ** 5)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 5", "10", "5", "def main():\n n, l = map(int, readline().split())\n a = list(map(int, readline().split()))\n b = [a[i] + a[i + 1] for i in range(n - 1)]\n\n last = -1\n for i, x in enumerate(b, 1):\n if x >= l:\n last = i\n break\n\n if last == -1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n for i in range(1, last):\n print(i)\n for i in range(n - 1, last, -1):\n print(i)\n print(last)", "main", "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", "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)]", "last = -1", "last", "-1", "for i, x in enumerate(b, 1):\n if x >= l:\n last = i\n break\n\n ", "i", "x", "enumerate(b, 1)", "enumerate", "b", "1", "if x >= l:\n last = i\n break\n\n ", "x >= l", "x", "l", "last = i", "last", "i", "break", "if last == -1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n for i in range(1, last):\n print(i)\n for i in range(n - 1, last, -1):\n print(i)\n print(last)", "last == -1", "last", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "for i in range(1, last):\n print(i)\n ", "i", "range(1, last)", "range", "1", "last", "print(i)", "print", "i", "for i in range(n - 1, last, -1):\n print(i)\n ", "i", "range(n - 1, last, -1)", "range", "n - 1", "n", "1", "last", "-1", "print(i)", "print", "i", "print(last)", "print", "last", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "readline = sys.stdin.readline", "sys.stdin.readline", "readline", "def main():\n n, l = map(int, readline().split())\n a = list(map(int, readline().split()))\n b = [a[i] + a[i + 1] for i in range(n - 1)]\n\n last = -1\n for i, x in enumerate(b, 1):\n if x >= l:\n last = i\n break\n\n if last == -1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n for i in range(1, last):\n print(i)\n for i in range(n - 1, last, -1):\n print(i)\n print(last)", "def main():\n n, l = map(int, readline().split())\n a = list(map(int, readline().split()))\n b = [a[i] + a[i + 1] for i in range(n - 1)]\n\n last = -1\n for i, x in enumerate(b, 1):\n if x >= l:\n last = i\n break\n\n if last == -1:\n print(\"Impossible\")\n else:\n print(\"Possible\")\n for i in range(1, last):\n print(i)\n for i in range(n - 1, last, -1):\n print(i)\n print(last)", "main", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "INF = float('INF')", "float('INF')", "INF" ]

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

[ [ 5, 4 ], [ 10, 9 ], [ 4, 12 ], [ 16, 15 ], [ 19, 18 ], [ 15, 24 ], [ 9, 29 ], [ 18, 30 ], [ 33, 32 ], [ 38, 37 ], [ 32, 40 ], [ 4, 40 ], [ 44, 43 ], [ 47, 46 ], [ 15, 50 ], [ 43, 54 ], [ 37, 59 ], [ 9, 59 ], [ 46, 60 ], [ 15, 64 ], [ 43, 71 ], [ 43, 74 ], [ 15, 77 ], [ 90, 89 ], [ 93, 92 ], [ 15, 97 ], [ 43, 104 ], [ 92, 105 ], [ 43, 107 ], [ 92, 109 ], [ 15, 112 ], [ 116, 115 ], [ 92, 117 ], [ 115, 122 ], [ 89, 122 ], [ 115, 132 ], [ 89, 132 ], [ 136, 135 ], [ 115, 139 ], [ 89, 139 ], [ 135, 144 ], [ 115, 148 ], [ 89, 148 ], [ 15, 151 ], [ 156, 155 ], [ 15, 160 ], [ 115, 163 ], [ 89, 163 ], [ 155, 167 ], [ 115, 170 ], [ 89, 170 ], [ 179, 176 ] ]

[ "def main22():\n strbuf = input(\"\");\n strbufs = strbuf.split();\n buf = [];\n for i in range(2):\n buf.append(int(strbufs[i]));\n strbuf = input(\"\");\n strbufs = strbuf.split();\n buf2 = [];\n for i in range(buf[0]):\n buf2.append(int(strbufs[i]));\n if buf[0] == 2:\n if buf2[0] + buf2[1] >= buf[1]:\n print(\"Possible\");\n print(1);\n else:\n print(\"Impossible\");\n else:\n point = -1;\n for i in range((buf[0] - 1)):\n if buf2[i] + buf2[i+1] >= buf[1]:\n point = i+1;\n break;\n if point == -1:\n print(\"Impossible\");\n else:\n print(\"Possible\");\n if point != 1:\n for i in range(point-1):\n print(i+1);\n if point != buf[0] - 1:\n for i in range(buf[0]-1,point,-1):\n print(i);\n print(point);\n\nif __name__ == '__main__':\n main22()", "def main22():\n strbuf = input(\"\");\n strbufs = strbuf.split();\n buf = [];\n for i in range(2):\n buf.append(int(strbufs[i]));\n strbuf = input(\"\");\n strbufs = strbuf.split();\n buf2 = [];\n for i in range(buf[0]):\n buf2.append(int(strbufs[i]));\n if buf[0] == 2:\n if buf2[0] + buf2[1] >= buf[1]:\n print(\"Possible\");\n print(1);\n else:\n print(\"Impossible\");\n else:\n point = -1;\n for i in range((buf[0] - 1)):\n if buf2[i] + buf2[i+1] >= buf[1]:\n point = i+1;\n break;\n if point == -1:\n print(\"Impossible\");\n else:\n print(\"Possible\");\n if point != 1:\n for i in range(point-1):\n print(i+1);\n if point != buf[0] - 1:\n for i in range(buf[0]-1,point,-1):\n print(i);\n print(point);", "main22", "strbuf = input(\"\")", "strbuf", "input(\"\")", "input", "\"\"", "strbufs = strbuf.split()", "strbufs", "strbuf.split()", "strbuf.split", "strbuf", "split", "buf = []", "buf", "[]", "for i in range(2):\n buf.append(int(strbufs[i]));\n ", "i", "range(2)", "range", "2", "buf.append(int(strbufs[i]))", "buf.append", "buf", "append", "int(strbufs[i])", "int", "strbufs[i]", "strbufs", "i", "strbuf = input(\"\")", "strbuf", "input(\"\")", "input", "\"\"", "strbufs = strbuf.split()", "strbufs", "strbuf.split()", "strbuf.split", "strbuf", "split", "buf2 = []", "buf2", "[]", "for i in range(buf[0]):\n buf2.append(int(strbufs[i]));\n ", "i", "range(buf[0])", "range", "buf[0]", "buf", "0", "buf2.append(int(strbufs[i]))", "buf2.append", "buf2", "append", "int(strbufs[i])", "int", "strbufs[i]", "strbufs", "i", "if buf[0] == 2:\n if buf2[0] + buf2[1] >= buf[1]:\n print(\"Possible\");\n print(1);\n else:\n print(\"Impossible\");\n else:\n point = -1;\n for i in range((buf[0] - 1)):\n if buf2[i] + buf2[i+1] >= buf[1]:\n point = i+1;\n break;\n if point == -1:\n print(\"Impossible\");\n else:\n print(\"Possible\");\n if point != 1:\n for i in range(point-1):\n print(i+1);\n if point != buf[0] - 1:\n for i in range(buf[0]-1,point,-1):\n print(i);\n print(point);", "buf[0] == 2", "buf[0]", "buf", "0", "2", "if buf2[0] + buf2[1] >= buf[1]:\n print(\"Possible\");\n print(1);\n else:\n print(\"Impossible\");\n ", "buf2[0] + buf2[1] >= buf[1]", "buf2[0] + buf2[1]", "buf2[0]", "buf2", "0", "buf2[1]", "buf2", "1", "buf[1]", "buf", "1", "print(\"Possible\")", "print", "\"Possible\"", "print(1)", "print", "1", "print(\"Impossible\")", "print", "\"Impossible\"", "point = -1", "point", "-1", "for i in range((buf[0] - 1)):\n if buf2[i] + buf2[i+1] >= buf[1]:\n point = i+1;\n break;\n ", "i", "range((buf[0] - 1))", "range", "buf[0] - 1", "buf[0]", "buf", "0", "1", "if buf2[i] + buf2[i+1] >= buf[1]:\n point = i+1;\n break;\n ", "buf2[i] + buf2[i+1] >= buf[1]", "buf2[i] + buf2[i+1]", "buf2[i]", "buf2", "i", "buf2[i+1]", "buf2", "i+1", "i", "1", "buf[1]", "buf", "1", "point = i+1", "point", "i+1", "i", "1", "break", "if point == -1:\n print(\"Impossible\");\n else:\n print(\"Possible\");\n if point != 1:\n for i in range(point-1):\n print(i+1);\n if point != buf[0] - 1:\n for i in range(buf[0]-1,point,-1):\n print(i);\n print(point);", "point == -1", "point", "-1", "print(\"Impossible\")", "print", "\"Impossible\"", "print(\"Possible\")", "print", "\"Possible\"", "if point != 1:\n for i in range(point-1):\n print(i+1);\n ", "point != 1", "point", "1", "for i in range(point-1):\n print(i+1);\n ", "i", "range(point-1)", "range", "point-1", "point", "1", "print(i+1)", "print", "i+1", "i", "1", "if point != buf[0] - 1:\n for i in range(buf[0]-1,point,-1):\n print(i);\n ", "point != buf[0] - 1", "point", "buf[0] - 1", "buf[0]", "buf", "0", "1", "for i in range(buf[0]-1,point,-1):\n print(i);\n ", "i", "range(buf[0]-1,point,-1)", "range", "buf[0]-1", "buf[0]", "buf", "0", "1", "point", "-1", "print(i)", "print", "i", "print(point)", "print", "point", "if __name__ == '__main__':\n main22()", "__name__ == '__main__'", "__name__", "'__main__'", "main22()", "main22", "def main22():\n strbuf = input(\"\");\n strbufs = strbuf.split();\n buf = [];\n for i in range(2):\n buf.append(int(strbufs[i]));\n strbuf = input(\"\");\n strbufs = strbuf.split();\n buf2 = [];\n for i in range(buf[0]):\n buf2.append(int(strbufs[i]));\n if buf[0] == 2:\n if buf2[0] + buf2[1] >= buf[1]:\n print(\"Possible\");\n print(1);\n else:\n print(\"Impossible\");\n else:\n point = -1;\n for i in range((buf[0] - 1)):\n if buf2[i] + buf2[i+1] >= buf[1]:\n point = i+1;\n break;\n if point == -1:\n print(\"Impossible\");\n else:\n print(\"Possible\");\n if point != 1:\n for i in range(point-1):\n print(i+1);\n if point != buf[0] - 1:\n for i in range(buf[0]-1,point,-1):\n print(i);\n print(point);", "def main22():\n strbuf = input(\"\");\n strbufs = strbuf.split();\n buf = [];\n for i in range(2):\n buf.append(int(strbufs[i]));\n strbuf = input(\"\");\n strbufs = strbuf.split();\n buf2 = [];\n for i in range(buf[0]):\n buf2.append(int(strbufs[i]));\n if buf[0] == 2:\n if buf2[0] + buf2[1] >= buf[1]:\n print(\"Possible\");\n print(1);\n else:\n print(\"Impossible\");\n else:\n point = -1;\n for i in range((buf[0] - 1)):\n if buf2[i] + buf2[i+1] >= buf[1]:\n point = i+1;\n break;\n if point == -1:\n print(\"Impossible\");\n else:\n print(\"Possible\");\n if point != 1:\n for i in range(point-1):\n print(i+1);\n if point != buf[0] - 1:\n for i in range(buf[0]-1,point,-1):\n print(i);\n print(point);", "main22" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 32, 14 ], [ 33, 24 ], [ 32, 33 ] ]

[ "lst = [int(a) for a in input().split()]\nif [5,5,7] == sorted(lst):\n print(\"YES\")\nelse:\n print(\"NO\")", "int(a) for a in input().split()", "for a in input().split()", "a", "input().split()", "().split", "()", "input", "split", "for a in input().split()", "int(a)", "int", "a", "lst = [int(a) for a in input().split()]", "lst", "[int(a) for a in input().split()]", "if [5,5,7] == sorted(lst):\n print(\"YES\")\nelse:\n print(\"NO\")", "[5,5,7] == sorted(lst)", "[5,5,7]", "5", "5", "7", "sorted(lst)", "sorted", "lst", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "lst = [int(a) for a in input().split()]", "[int(a) for a in input().split()]", "lst" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 39, 14 ], [ 40, 21 ], [ 40, 28 ], [ 39, 40 ] ]

[ "s_list=[int(i) for i in input().split()]\n\nif s_list.count(5)==2 and s_list.count(7)==1:\n print(\"YES\")\n \nelse:\n print(\"NO\")", "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", "s_list=[int(i) for i in input().split()]", "s_list", "[int(i) for i in input().split()]", "if s_list.count(5)==2 and s_list.count(7)==1:\n print(\"YES\")\n \nelse:\n print(\"NO\")", "s_list.count(5)==2 and s_list.count(7)==1", "s_list.count(5)==2", "s_list.count(5)", "s_list.count", "s_list", "count", "5", "2", "s_list.count(7)==1", "s_list.count(7)", "s_list.count", "s_list", "count", "7", "1", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "s_list=[int(i) for i in input().split()]", "[int(i) for i in input().split()]", "s_list" ]

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

[ [ 33, 2 ], [ 34, 15 ], [ 34, 22 ], [ 33, 34 ] ]

[ "s=list(input().split())\nif s.count(\"5\")==2 and s.count(\"7\")==1:\n print(\"YES\")\nelse:\n print(\"NO\")", "s=list(input().split())", "s", "list(input().split())", "list", "input().split()", "().split", "()", "input", "split", "if s.count(\"5\")==2 and s.count(\"7\")==1:\n print(\"YES\")\nelse:\n print(\"NO\")", "s.count(\"5\")==2 and s.count(\"7\")==1", "s.count(\"5\")==2", "s.count(\"5\")", "s.count", "s", "count", "\"5\"", "2", "s.count(\"7\")==1", "s.count(\"7\")", "s.count", "s", "count", "\"7\"", "1", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "s=list(input().split())", "list(input().split())", "s" ]

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

[ [ 29, 2 ], [ 32, 6 ], [ 30, 9 ], [ 33, 13 ], [ 30, 13 ], [ 33, 17 ], [ 30, 17 ], [ 29, 30 ], [ 32, 33 ] ]

[ "form = input()\nform = form.split()\nform.sort()\n\nif form == [\"5\",\"5\",\"7\"]:\n print(\"YES\")\nelse:\n print(\"NO\")", "form = input()", "form", "input()", "input", "form = form.split()", "form", "form.split()", "form.split", "form", "split", "form.sort()", "form.sort", "form", "sort", "if form == [\"5\",\"5\",\"7\"]:\n print(\"YES\")\nelse:\n print(\"NO\")", "form == [\"5\",\"5\",\"7\"]", "form", "[\"5\",\"5\",\"7\"]", "\"5\"", "\"5\"", "\"7\"", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "form = input()", "input()", "form", "form = form.split()", "form.split()", "form" ]

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

[ [ 35, 2 ], [ 32, 14 ], [ 36, 17 ], [ 33, 20 ], [ 36, 20 ], [ 32, 33 ], [ 35, 36 ] ]

[ "L=list(map(int,input().split()))\nL=sorted(L)\nif L==[5,5,7]:\n print(\"YES\")\nelse:\n print(\"NO\")", "L=list(map(int,input().split()))", "L", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L=sorted(L)", "L", "sorted(L)", "sorted", "L", "if L==[5,5,7]:\n print(\"YES\")\nelse:\n print(\"NO\")", "L==[5,5,7]", "L", "[5,5,7]", "5", "5", "7", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "L=sorted(L)", "sorted(L)", "L", "L=list(map(int,input().split()))", "list(map(int,input().split()))", "L" ]

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 15, 15, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 23, 13, 23, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 4, 18, 13, 13, 14, 2, 13, 39, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 27, 27 ], [ 29, 29 ], [ 87, 38 ], [ 66, 45 ], [ 76, 47 ], [ 67, 50 ], [ 67, 54 ], [ 66, 67 ], [ 87, 88 ] ]

[ "import sys\nimport math\nimport itertools\nimport bisect\nfrom copy import copy\nfrom collections import deque,Counter\nfrom decimal import Decimal\ndef s(): return input()\ndef i(): return int(input())\ndef S(): return input().split()\ndef I(): return map(int,input().split())\ndef L(): return list(input().split())\ndef l(): return list(map(int,input().split()))\ndef lcm(a,b): return a*b//math.gcd(a,b)\nsys.setrecursionlimit(10**9)\nmod = 10**9+7\n\nA = l()\nA.sort()\nif A == [5,5,7]:\n print('YES')\nelse:\n print('NO')", "import sys", "sys", "import math", "math", "import itertools", "itertools", "import bisect", "bisect", "from copy import copy", "from collections import deque,Counter", "from decimal import Decimal", "def s(): return input()", "s", "def i(): return int(input())", "i", "def S(): return input().split()", "S", "def I(): return map(int,input().split())", "I", "def L(): return list(input().split())", "L", "def l(): return list(map(int,input().split()))", "l", "def lcm(a,b): return a*b//math.gcd(a,b)", "lcm", "a", "a", "b", "b", "sys.setrecursionlimit(10**9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**9", "10", "9", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "A = l()", "A", "l()", "l", "A.sort()", "A.sort", "A", "sort", "if A == [5,5,7]:\n print('YES')\nelse:\n print('NO')", "A == [5,5,7]", "A", "[5,5,7]", "5", "5", "7", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "A = l()", "l()", "A", "def S(): return input().split()", "def S(): return input().split()", "S", "def lcm(a,b): return a*b//math.gcd(a,b)", "def lcm(a,b): return a*b//math.gcd(a,b)", "lcm", "def l(): return list(map(int,input().split()))", "def l(): return list(map(int,input().split()))", "l", "def i(): return int(input())", "def i(): return int(input())", "i", "def I(): return map(int,input().split())", "def I(): return map(int,input().split())", "I", "def L(): return list(input().split())", "def L(): return list(input().split())", "L", "mod = 10**9+7", "10**9+7", "mod", "def s(): return input()", "def s(): return input()", "s" ]

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

[ [ 49, 2 ], [ 49, 11 ], [ 49, 12 ], [ 44, 17 ], [ 50, 18 ], [ 47, 19 ], [ 44, 28 ], [ 50, 29 ], [ 47, 30 ], [ 49, 44 ], [ 49, 47 ], [ 49, 50 ] ]

[ "a,b,c=map(int,input().split())\nif a*b*c==256:\n print(\"YES\")\n\nif a*b*c==5*5*7:\n print(\"YES\")\nelse:\n print(\"NO\")", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a*b*c==256:\n print(\"YES\")", "a*b*c==256", "a*b*c", "a*b", "a", "b", "c", "256", "print(\"YES\")", "print", "\"YES\"", "if a*b*c==5*5*7:\n print(\"YES\")\nelse:\n print(\"NO\")", "a*b*c==5*5*7", "a*b*c", "a*b", "a", "b", "c", "5*5*7", "5*5", "5", "5", "7", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "a,b,c=map(int,input().split())", "map(int,input().split())", "a", "c=map(int,input().split())", "map(int,input().split())", "c", "b,c=map(int,input().split())", "map(int,input().split())", "b" ]

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

[ [ 63, 2 ], [ 63, 11 ], [ 63, 12 ], [ 58, 15 ], [ 64, 20 ], [ 61, 23 ], [ 64, 31 ], [ 61, 34 ], [ 64, 45 ], [ 61, 48 ], [ 63, 58 ], [ 63, 61 ], [ 63, 64 ] ]

[ "a, b, c = map(int, input().split())\nif a == 5:\n if b == 5 and c == 7:\n print('YES')\n elif b == 7 and c == 5:\n print('YES')\n else:\n print('NO')\nelse:\n if b == 5 and c == 5:\n print('YES')\n else:\n print('NO')", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a == 5:\n if b == 5 and c == 7:\n print('YES')\n elif b == 7 and c == 5:\n print('YES')\n else:\n print('NO')\nelse:\n if b == 5 and c == 5:\n print('YES')\n else:\n print('NO')", "a == 5", "a", "5", "if b == 5 and c == 7:\n print('YES')\n elif b == 7 and c == 5:\n print('YES')\n else:\n print('NO')", "b == 5 and c == 7", "b == 5", "b", "5", "c == 7", "c", "7", "print('YES')", "print", "'YES'", "elif b == 7 and c == 5:\n print('YES')\n ", "b == 7 and c == 5", "b == 7", "b", "7", "c == 5", "c", "5", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "if b == 5 and c == 5:\n print('YES')\n else:\n print('NO')", "b == 5 and c == 5", "b == 5", "b", "5", "c == 5", "c", "5", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "c = map(int, input().split())", "map(int, input().split())", "c", "b, c = map(int, input().split())", "map(int, input().split())", "b" ]

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

[ [ 43, 2 ], [ 46, 14 ], [ 44, 17 ], [ 47, 23 ], [ 47, 28 ], [ 47, 33 ], [ 43, 44 ], [ 46, 47 ] ]

[ "ward = list(map(int, input().split()))\n\nward_sorted = sorted(ward)\n\nif (ward_sorted[0]==5) & (ward_sorted[1]==5) & (ward_sorted[2]==7):\n print('YES')\nelse:\n print('NO')", "ward = list(map(int, input().split()))", "ward", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ward_sorted = sorted(ward)", "ward_sorted", "sorted(ward)", "sorted", "ward", "if (ward_sorted[0]==5) & (ward_sorted[1]==5) & (ward_sorted[2]==7):\n print('YES')\nelse:\n print('NO')", "(ward_sorted[0]==5) & (ward_sorted[1]==5) & (ward_sorted[2]==7)", "(ward_sorted[0]==5) & (ward_sorted[1]==5)", "ward_sorted[0]==5", "ward_sorted[0]", "ward_sorted", "0", "5", "ward_sorted[1]==5", "ward_sorted[1]", "ward_sorted", "1", "5", "ward_sorted[2]==7", "ward_sorted[2]", "ward_sorted", "2", "7", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "ward = list(map(int, input().split()))", "list(map(int, input().split()))", "ward", "ward_sorted = sorted(ward)", "sorted(ward)", "ward_sorted" ]

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

[ [ 53, 2 ], [ 54, 15 ], [ 54, 27 ], [ 54, 39 ], [ 53, 54 ] ]

[ "abc = list(map(int,input().split()))\n\nif abc == [5,5,7]:\n print('YES')\n exit()\nif abc == [7,5,5]:\n print('YES')\n exit()\nif abc == [5,7,5]:\n print('YES')\n exit()\nprint('NO')", "abc = list(map(int,input().split()))", "abc", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if abc == [5,5,7]:\n print('YES')\n exit()", "abc == [5,5,7]", "abc", "[5,5,7]", "5", "5", "7", "print('YES')", "print", "'YES'", "exit()", "exit", "if abc == [7,5,5]:\n print('YES')\n exit()", "abc == [7,5,5]", "abc", "[7,5,5]", "7", "5", "5", "print('YES')", "print", "'YES'", "exit()", "exit", "if abc == [5,7,5]:\n print('YES')\n exit()", "abc == [5,7,5]", "abc", "[5,7,5]", "5", "7", "5", "print('YES')", "print", "'YES'", "exit()", "exit", "print('NO')", "print", "'NO'", "abc = list(map(int,input().split()))", "list(map(int,input().split()))", "abc" ]

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

[ [ 106, 2 ], [ 106, 11 ], [ 106, 12 ], [ 79, 14 ], [ 91, 17 ], [ 107, 21 ], [ 97, 24 ], [ 107, 28 ], [ 103, 31 ], [ 77, 35 ], [ 85, 38 ], [ 77, 42 ], [ 82, 45 ], [ 101, 49 ], [ 88, 52 ], [ 101, 56 ], [ 94, 59 ], [ 89, 64 ], [ 86, 64 ], [ 98, 64 ], [ 80, 64 ], [ 95, 67 ], [ 83, 67 ], [ 104, 67 ], [ 92, 67 ], [ 106, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 106, 101 ], [ 103, 104 ], [ 106, 107 ] ]

[ "A,B,C = map(int,input().split())\nsev = 0\nfiv = 0\n\nif A == 7 :\n sev += 1\nelif A == 5:\n fiv += 1\nif B == 7:\n sev += 1\nelif B == 5:\n fiv += 1\nif C == 7:\n sev += 1\nelif C == 5:\n fiv += 1\nif sev == 1 and fiv == 2:\n print(\"YES\")\nelse:\n print(\"NO\")\n\n", "A,B,C = map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "sev = 0", "sev", "0", "fiv = 0", "fiv", "0", "if A == 7 :\n sev += 1\nelif A == 5:\n fiv += 1", "A == 7", "A", "7", "sev += 1", "sev", "1", "elif A == 5:\n fiv += 1", "A == 5", "A", "5", "fiv += 1", "fiv", "1", "if B == 7:\n sev += 1\nelif B == 5:\n fiv += 1", "B == 7", "B", "7", "sev += 1", "sev", "1", "elif B == 5:\n fiv += 1", "B == 5", "B", "5", "fiv += 1", "fiv", "1", "if C == 7:\n sev += 1\nelif C == 5:\n fiv += 1", "C == 7", "C", "7", "sev += 1", "sev", "1", "elif C == 5:\n fiv += 1", "C == 5", "C", "5", "fiv += 1", "fiv", "1", "if sev == 1 and fiv == 2:\n print(\"YES\")\nelse:\n print(\"NO\")", "sev == 1 and fiv == 2", "sev == 1", "sev", "1", "fiv == 2", "fiv", "2", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "B,C = map(int,input().split())", "map(int,input().split())", "B", "sev = 0", "0", "sev", "fiv += 1", "1", "fiv", "sev += 1", "1", "sev", "sev += 1", "1", "sev", "fiv = 0", "0", "fiv", "fiv += 1", "1", "fiv", "sev += 1", "1", "sev", "C = map(int,input().split())", "map(int,input().split())", "C", "fiv += 1", "1", "fiv", "A,B,C = map(int,input().split())", "map(int,input().split())", "A" ]

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

[ [ 81, 2 ], [ 78, 6 ], [ 82, 9 ], [ 79, 16 ], [ 79, 21 ], [ 79, 26 ], [ 79, 37 ], [ 79, 42 ], [ 79, 47 ], [ 79, 58 ], [ 79, 63 ], [ 79, 68 ], [ 78, 79 ], [ 81, 82 ] ]

[ "a = input()\nb = a.split()\n\nif b[0]==\"5\" and b[1]==\"5\" and b[2]==\"7\":\n print(\"YES\")\nelif b[0]==\"5\" and b[1]==\"7\" and b[2]==\"5\":\n print(\"YES\")\nelif b[0]==\"7\" and b[1]==\"5\" and b[2]==\"5\":\n print(\"YES\")\nelse:\n print(\"NO\")", "a = input()", "a", "input()", "input", "b = a.split()", "b", "a.split()", "a.split", "a", "split", "if b[0]==\"5\" and b[1]==\"5\" and b[2]==\"7\":\n print(\"YES\")\nelif b[0]==\"5\" and b[1]==\"7\" and b[2]==\"5\":\n print(\"YES\")\nelif b[0]==\"7\" and b[1]==\"5\" and b[2]==\"5\":\n print(\"YES\")\nelse:\n print(\"NO\")", "b[0]==\"5\" and b[1]==\"5\" and b[2]==\"7\"", "b[0]==\"5\" and b[1]==\"5\"", "b[0]==\"5\"", "b[0]", "b", "0", "\"5\"", "b[1]==\"5\"", "b[1]", "b", "1", "\"5\"", "b[2]==\"7\"", "b[2]", "b", "2", "\"7\"", "print(\"YES\")", "print", "\"YES\"", "elif b[0]==\"5\" and b[1]==\"7\" and b[2]==\"5\":\n print(\"YES\")", "b[0]==\"5\" and b[1]==\"7\" and b[2]==\"5\"", "b[0]==\"5\" and b[1]==\"7\"", "b[0]==\"5\"", "b[0]", "b", "0", "\"5\"", "b[1]==\"7\"", "b[1]", "b", "1", "\"7\"", "b[2]==\"5\"", "b[2]", "b", "2", "\"5\"", "print(\"YES\")", "print", "\"YES\"", "elif b[0]==\"7\" and b[1]==\"5\" and b[2]==\"5\":\n print(\"YES\")", "b[0]==\"7\" and b[1]==\"5\" and b[2]==\"5\"", "b[0]==\"7\" and b[1]==\"5\"", "b[0]==\"7\"", "b[0]", "b", "0", "\"7\"", "b[1]==\"5\"", "b[1]", "b", "1", "\"5\"", "b[2]==\"5\"", "b[2]", "b", "2", "\"5\"", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "b = a.split()", "a.split()", "b", "a = input()", "input()", "a" ]

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

[ [ 37, 2 ], [ 40, 9 ], [ 38, 12 ], [ 43, 16 ], [ 38, 19 ], [ 41, 25 ], [ 44, 28 ], [ 37, 38 ], [ 40, 41 ], [ 43, 44 ] ]

[ "MM = input().split()\na = MM.count('5')\nb = MM.count('7')\nif a ==2 and b ==1:\n print('YES')\nelse:\n print('NO')", "MM = input().split()", "MM", "input().split()", "().split", "()", "input", "split", "a = MM.count('5')", "a", "MM.count('5')", "MM.count", "MM", "count", "'5'", "b = MM.count('7')", "b", "MM.count('7')", "MM.count", "MM", "count", "'7'", "if a ==2 and b ==1:\n print('YES')\nelse:\n print('NO')", "a ==2 and b ==1", "a ==2", "a", "2", "b ==1", "b", "1", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "MM = input().split()", "input().split()", "MM", "a = MM.count('5')", "MM.count('5')", "a", "b = MM.count('7')", "MM.count('7')", "b" ]

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

[ [ 34, 2 ], [ 34, 11 ], [ 34, 12 ], [ 32, 17 ], [ 29, 18 ], [ 35, 19 ], [ 34, 29 ], [ 34, 32 ], [ 34, 35 ] ]

[ "A,B,C=map(int,input().split())\n\nif A+B+C==17:\n print('YES')\nelse:\n print('NO')", "A,B,C=map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "if A+B+C==17:\n print('YES')\nelse:\n print('NO')", "A+B+C==17", "A+B+C", "A+B", "A", "B", "C", "17", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "B,C=map(int,input().split())", "map(int,input().split())", "B", "A,B,C=map(int,input().split())", "map(int,input().split())", "A", "C=map(int,input().split())", "map(int,input().split())", "C" ]

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

[ [ 103, 2 ], [ 103, 11 ], [ 103, 12 ], [ 76, 14 ], [ 85, 17 ], [ 89, 21 ], [ 79, 24 ], [ 89, 28 ], [ 97, 31 ], [ 104, 35 ], [ 82, 38 ], [ 104, 42 ], [ 100, 45 ], [ 95, 49 ], [ 106, 52 ], [ 95, 56 ], [ 91, 59 ], [ 107, 64 ], [ 83, 64 ], [ 80, 64 ], [ 77, 64 ], [ 92, 67 ], [ 101, 67 ], [ 98, 67 ], [ 86, 67 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 103, 89 ], [ 91, 92 ], [ 103, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ] ]

[ "a, b, c = map(int, input().split())\n\nn_5 = 0\nn_7 = 0\n\nif a == 5:\n n_5 +=1\nelif a == 7:\n n_7 +=1\n\nif b == 5:\n n_5 +=1\nelif b == 7:\n n_7 +=1\n\nif c == 5:\n n_5 +=1\nelif c == 7:\n n_7 +=1\n\nif n_5 == 2 and n_7 == 1:\n print(\"YES\")\nelse:\n print(\"NO\")", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "n_5 = 0", "n_5", "0", "n_7 = 0", "n_7", "0", "if a == 5:\n n_5 +=1\nelif a == 7:\n n_7 +=1", "a == 5", "a", "5", "n_5 +=1", "n_5", "1", "elif a == 7:\n n_7 +=1", "a == 7", "a", "7", "n_7 +=1", "n_7", "1", "if b == 5:\n n_5 +=1\nelif b == 7:\n n_7 +=1", "b == 5", "b", "5", "n_5 +=1", "n_5", "1", "elif b == 7:\n n_7 +=1", "b == 7", "b", "7", "n_7 +=1", "n_7", "1", "if c == 5:\n n_5 +=1\nelif c == 7:\n n_7 +=1", "c == 5", "c", "5", "n_5 +=1", "n_5", "1", "elif c == 7:\n n_7 +=1", "c == 7", "c", "7", "n_7 +=1", "n_7", "1", "if n_5 == 2 and n_7 == 1:\n print(\"YES\")\nelse:\n print(\"NO\")", "n_5 == 2 and n_7 == 1", "n_5 == 2", "n_5", "2", "n_7 == 1", "n_7", "1", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "n_5 = 0", "0", "n_5", "n_5 +=1", "1", "n_5", "n_5 +=1", "1", "n_5", "n_7 = 0", "0", "n_7", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "n_7 +=1", "1", "n_7", "c = map(int, input().split())", "map(int, input().split())", "c", "n_7 +=1", "1", "n_7", "n_7 +=1", "1", "n_7", "b, c = map(int, input().split())", "map(int, input().split())", "b", "n_5 +=1", "1", "n_5" ]

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

[ [ 5, 4 ], [ 5, 13 ], [ 5, 14 ], [ 17, 16 ], [ 16, 25 ], [ 44, 41 ] ]

[ "def main():\n a,b,c=map(int,input().split())\n li=[a,b,c]\n if sorted(li)==[5,5,7]:\n print('YES')\n else:\n print('NO')\n \nif __name__==\"__main__\":\n main()", "def main():\n a,b,c=map(int,input().split())\n li=[a,b,c]\n if sorted(li)==[5,5,7]:\n print('YES')\n else:\n print('NO')\n ", "main", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "li=[a,b,c]", "li", "[a,b,c]", "a", "b", "c", "if sorted(li)==[5,5,7]:\n print('YES')\n else:\n print('NO')\n ", "sorted(li)==[5,5,7]", "sorted(li)", "sorted", "li", "[5,5,7]", "5", "5", "7", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "if __name__==\"__main__\":\n main()", "__name__==\"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n a,b,c=map(int,input().split())\n li=[a,b,c]\n if sorted(li)==[5,5,7]:\n print('YES')\n else:\n print('NO')\n ", "def main():\n a,b,c=map(int,input().split())\n li=[a,b,c]\n if sorted(li)==[5,5,7]:\n print('YES')\n else:\n print('NO')\n ", "main" ]

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

[ [ 40, 2 ], [ 40, 11 ], [ 40, 12 ], [ 37, 14 ], [ 41, 17 ], [ 32, 18 ], [ 35, 19 ], [ 38, 22 ], [ 40, 32 ], [ 40, 35 ], [ 37, 38 ], [ 40, 41 ] ]

[ "a, b, c = map(int, input().split())\n\nd = a + b + c\n\nif d == 17:\n print('YES')\nelse:\n print('NO')", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "d = a + b + c", "d", "a + b + c", "a + b", "a", "b", "c", "if d == 17:\n print('YES')\nelse:\n print('NO')", "d == 17", "d", "17", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "b, c = map(int, input().split())", "map(int, input().split())", "b", "c = map(int, input().split())", "map(int, input().split())", "c", "d = a + b + c", "a + b + c", "d", "a, b, c = map(int, input().split())", "map(int, input().split())", "a" ]

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

[ [ 62, 2 ], [ 62, 11 ], [ 62, 12 ], [ 68, 14 ], [ 63, 19 ], [ 63, 22 ], [ 74, 25 ], [ 63, 26 ], [ 57, 30 ], [ 71, 34 ], [ 57, 35 ], [ 60, 39 ], [ 65, 43 ], [ 60, 44 ], [ 66, 47 ], [ 72, 47 ], [ 75, 47 ], [ 69, 47 ], [ 62, 57 ], [ 62, 60 ], [ 62, 63 ], [ 60, 65 ], [ 65, 66 ], [ 68, 69 ], [ 57, 71 ], [ 71, 72 ], [ 63, 74 ], [ 74, 75 ] ]

[ "A,B,C=map(int,input().split())\nsum = 0\nif A == 5 or A ==7:\n sum += A\n if B ==5 or 7:\n sum += B\n if C ==5 or 7:\n sum += C\n if sum == 17:\n print(\"YES\")\n else:\n print(\"NO\")", "A,B,C=map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "sum = 0", "sum", "0", "if A == 5 or A ==7:\n sum += A\n if B ==5 or 7:\n sum += B\n if C ==5 or 7:\n sum += C\n if sum == 17:\n print(\"YES\")\n else:\n print(\"NO\")", "A == 5 or A ==7", "A == 5", "A", "5", "A ==7", "A", "7", "sum += A", "sum", "A", "if B ==5 or 7:\n sum += B\n if C ==5 or 7:\n sum += C\n if sum == 17:\n print(\"YES\")\n else:\n print(\"NO\")", "B ==5 or 7", "B ==5", "B", "5", "7", "sum += B", "sum", "B", "if C ==5 or 7:\n sum += C\n if sum == 17:\n print(\"YES\")\n else:\n print(\"NO\")", "C ==5 or 7", "C ==5", "C", "5", "7", "sum += C", "sum", "C", "if sum == 17:\n print(\"YES\")\n else:\n print(\"NO\")", "sum == 17", "sum", "17", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "B,C=map(int,input().split())", "map(int,input().split())", "B", "C=map(int,input().split())", "map(int,input().split())", "C", "A,B,C=map(int,input().split())", "map(int,input().split())", "A", "sum += C", "C", "sum", "sum = 0", "0", "sum", "sum += B", "B", "sum", "sum += A", "A", "sum" ]

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

[ [ 42, 2 ], [ 48, 14 ], [ 43, 17 ], [ 45, 21 ], [ 43, 24 ], [ 49, 30 ], [ 46, 33 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "ABC=list(map(int,input().split()))\nfive=ABC.count(5)\nseven=ABC.count(7)\nif (five==2)&(seven==1):\n print(\"YES\")\nelse:\n print(\"NO\")", "ABC=list(map(int,input().split()))", "ABC", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "five=ABC.count(5)", "five", "ABC.count(5)", "ABC.count", "ABC", "count", "5", "seven=ABC.count(7)", "seven", "ABC.count(7)", "ABC.count", "ABC", "count", "7", "if (five==2)&(seven==1):\n print(\"YES\")\nelse:\n print(\"NO\")", "(five==2)&(seven==1)", "five==2", "five", "2", "seven==1", "seven", "1", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "ABC=list(map(int,input().split()))", "list(map(int,input().split()))", "ABC", "seven=ABC.count(7)", "ABC.count(7)", "seven", "five=ABC.count(5)", "ABC.count(5)", "five" ]

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 28, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 18, 13, 13, 13, 3, 28, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 18, 13, 13, 13, 3, 28, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 18, 13, 13, 13, 3, 4, 13, 8, 2, 4, 13, 13, 17, 17, 17, 10, 4, 13 ]

[ [ 72, 2 ], [ 73, 18 ], [ 73, 25 ], [ 73, 34 ], [ 73, 41 ], [ 73, 50 ], [ 73, 57 ], [ 73, 67 ], [ 72, 73 ] ]

[ "clause_list = list(map(int, input().split()))\n\nfor index, clause in enumerate(clause_list):\n if clause == 5:\n clause_list.pop(index)\n break\n\nfor index, clause in enumerate(clause_list):\n if clause == 7:\n clause_list.pop(index)\n break\n\nfor index, clause in enumerate(clause_list):\n if clause == 5:\n clause_list.pop(index)\n break\n\nprint('YES' if len(clause_list) == 0 else 'NO')", "clause_list = list(map(int, input().split()))", "clause_list", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for index, clause in enumerate(clause_list):\n if clause == 5:\n clause_list.pop(index)\n break", "index", "clause", "enumerate(clause_list)", "enumerate", "clause_list", "if clause == 5:\n clause_list.pop(index)\n break", "clause == 5", "clause", "5", "clause_list.pop(index)", "clause_list.pop", "clause_list", "pop", "index", "break", "for index, clause in enumerate(clause_list):\n if clause == 7:\n clause_list.pop(index)\n break", "index", "clause", "enumerate(clause_list)", "enumerate", "clause_list", "if clause == 7:\n clause_list.pop(index)\n break", "clause == 7", "clause", "7", "clause_list.pop(index)", "clause_list.pop", "clause_list", "pop", "index", "break", "for index, clause in enumerate(clause_list):\n if clause == 5:\n clause_list.pop(index)\n break", "index", "clause", "enumerate(clause_list)", "enumerate", "clause_list", "if clause == 5:\n clause_list.pop(index)\n break", "clause == 5", "clause", "5", "clause_list.pop(index)", "clause_list.pop", "clause_list", "pop", "index", "break", "print('YES' if len(clause_list) == 0 else 'NO')", "print", "'YES' if len(clause_list) == 0 else 'NO'", "len(clause_list) == 0", "len(clause_list)", "len", "clause_list", "0", "'YES'", "'NO'", "clause_list = list(map(int, input().split()))", "list(map(int, input().split()))", "clause_list" ]

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

[ [ 28, 2 ], [ 29, 10 ], [ 29, 17 ], [ 28, 29 ] ]

[ "# coding: utf-8\n# Your code here!\n\nl = input()\nif l.count(\"5\") == 2 and l.count(\"7\") == 1:\n print(\"YES\")\nelse:\n print(\"NO\")", "l = input()", "l", "input()", "input", "if l.count(\"5\") == 2 and l.count(\"7\") == 1:\n print(\"YES\")\nelse:\n print(\"NO\")", "l.count(\"5\") == 2 and l.count(\"7\") == 1", "l.count(\"5\") == 2", "l.count(\"5\")", "l.count", "l", "count", "\"5\"", "2", "l.count(\"7\") == 1", "l.count(\"7\")", "l.count", "l", "count", "\"7\"", "1", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "l = input()", "input()", "l" ]

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

[ [ 42, 2 ], [ 43, 15 ], [ 43, 22 ], [ 43, 27 ], [ 43, 32 ], [ 42, 43 ] ]

[ "arr = list(map(int, input().split()))\narr.sort()\nif (arr[0] == 5) and (arr[1] == 5) and (arr[2] == 7):\n print(\"YES\")\nelse:\n print(\"NO\")", "arr = list(map(int, input().split()))", "arr", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "arr.sort()", "arr.sort", "arr", "sort", "if (arr[0] == 5) and (arr[1] == 5) and (arr[2] == 7):\n print(\"YES\")\nelse:\n print(\"NO\")", "(arr[0] == 5) and (arr[1] == 5) and (arr[2] == 7)", "(arr[0] == 5) and (arr[1] == 5)", "arr[0] == 5", "arr[0]", "arr", "0", "5", "arr[1] == 5", "arr[1]", "arr", "1", "5", "arr[2] == 7", "arr[2]", "arr", "2", "7", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "arr = list(map(int, input().split()))", "list(map(int, input().split()))", "arr" ]

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

[ [ 59, 2 ], [ 62, 8 ], [ 60, 11 ], [ 65, 13 ], [ 56, 16 ], [ 20, 19 ], [ 63, 19 ], [ 19, 23 ], [ 50, 26 ], [ 19, 30 ], [ 53, 33 ], [ 51, 38 ], [ 66, 38 ], [ 54, 41 ], [ 57, 41 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ] ]

[ "a=str(input())\nalist=list(a)\ncount7=0\ncount5=0\nfor x in alist:\n if x==\"7\":\n count7+=1\n if x==\"5\":\n count5+=1\n else:\n pass\nif count7==1 and count5==2:\n print(\"YES\")\nelse:\n print(\"NO\")", "a=str(input())", "a", "str(input())", "str", "input()", "input", "alist=list(a)", "alist", "list(a)", "list", "a", "count7=0", "count7", "0", "count5=0", "count5", "0", "for x in alist:\n if x==\"7\":\n count7+=1\n if x==\"5\":\n count5+=1\n else:\n pass", "x", "alist", "if x==\"7\":\n count7+=1\n ", "x==\"7\"", "x", "\"7\"", "count7+=1", "count7", "1", "if x==\"5\":\n count5+=1\n else:\n pass", "x==\"5\"", "x", "\"5\"", "count5+=1", "count5", "1", "if count7==1 and count5==2:\n print(\"YES\")\nelse:\n print(\"NO\")", "count7==1 and count5==2", "count7==1", "count7", "1", "count5==2", "count5", "2", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "count7+=1", "1", "count7", "count5+=1", "1", "count5", "count5=0", "0", "count5", "a=str(input())", "str(input())", "a", "alist=list(a)", "list(a)", "alist", "count7=0", "0", "count7" ]

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

[ [ 5, 4 ], [ 5, 13 ], [ 5, 14 ], [ 17, 16 ], [ 16, 20 ], [ 4, 22 ], [ 16, 25 ], [ 13, 27 ], [ 16, 30 ], [ 14, 32 ], [ 16, 38 ], [ 16, 45 ], [ 63, 60 ] ]

[ "def main():\n a, b, c = map(int, input().split())\n list = []\n list.append(a)\n list.append(b)\n list.append(c)\n\n if list.count(5) == 2 and list.count(7) == 1 :\n print(\"YES\")\n else :\n print(\"NO\")\n\nif __name__ == '__main__':\n main()", "def main():\n a, b, c = map(int, input().split())\n list = []\n list.append(a)\n list.append(b)\n list.append(c)\n\n if list.count(5) == 2 and list.count(7) == 1 :\n print(\"YES\")\n else :\n print(\"NO\")", "main", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "list = []", "list", "[]", "list.append(a)", "list.append", "list", "append", "a", "list.append(b)", "list.append", "list", "append", "b", "list.append(c)", "list.append", "list", "append", "c", "if list.count(5) == 2 and list.count(7) == 1 :\n print(\"YES\")\n else :\n print(\"NO\")", "list.count(5) == 2 and list.count(7) == 1", "list.count(5) == 2", "list.count(5)", "list.count", "list", "count", "5", "2", "list.count(7) == 1", "list.count(7)", "list.count", "list", "count", "7", "1", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n a, b, c = map(int, input().split())\n list = []\n list.append(a)\n list.append(b)\n list.append(c)\n\n if list.count(5) == 2 and list.count(7) == 1 :\n print(\"YES\")\n else :\n print(\"NO\")", "def main():\n a, b, c = map(int, input().split())\n list = []\n list.append(a)\n list.append(b)\n list.append(c)\n\n if list.count(5) == 2 and list.count(7) == 1 :\n print(\"YES\")\n else :\n print(\"NO\")", "main" ]

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

[ [ 64, 2 ], [ 67, 14 ], [ 20, 19 ], [ 65, 26 ], [ 19, 27 ], [ 33, 30 ], [ 68, 31 ], [ 65, 37 ], [ 19, 38 ], [ 44, 41 ], [ 68, 42 ], [ 68, 49 ], [ 68, 54 ], [ 64, 65 ], [ 67, 68 ] ]

[ "a=list(map(int,input().split()))\nlst=[0,0]\nfor i in range(3):\n if a[i]==5:\n lst[0]+=1\n elif a[i]==7:\n lst[1]+=1\nif lst[0]==2 and lst[1]==1:\n print(\"YES\")\nelse:\n print(\"NO\")", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "lst=[0,0]", "lst", "[0,0]", "0", "0", "for i in range(3):\n if a[i]==5:\n lst[0]+=1\n elif a[i]==7:\n lst[1]+=1", "i", "range(3)", "range", "3", "if a[i]==5:\n lst[0]+=1\n elif a[i]==7:\n lst[1]+=1", "a[i]==5", "a[i]", "a", "i", "5", "lst[0]+=1", "lst[0]", "lst", "0", "1", "elif a[i]==7:\n lst[1]+=1", "a[i]==7", "a[i]", "a", "i", "7", "lst[1]+=1", "lst[1]", "lst", "1", "1", "if lst[0]==2 and lst[1]==1:\n print(\"YES\")\nelse:\n print(\"NO\")", "lst[0]==2 and lst[1]==1", "lst[0]==2", "lst[0]", "lst", "0", "2", "lst[1]==1", "lst[1]", "lst", "1", "1", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "lst=[0,0]", "[0,0]", "lst" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 115, 14 ], [ 103, 17 ], [ 97, 20 ], [ 116, 25 ], [ 109, 29 ], [ 116, 34 ], [ 100, 38 ], [ 116, 43 ], [ 91, 47 ], [ 116, 52 ], [ 106, 56 ], [ 116, 61 ], [ 94, 65 ], [ 116, 70 ], [ 112, 74 ], [ 95, 79 ], [ 92, 79 ], [ 110, 79 ], [ 98, 79 ], [ 113, 82 ], [ 107, 82 ], [ 101, 82 ], [ 104, 82 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ], [ 112, 113 ], [ 115, 116 ] ]

[ "n = [int(i) for i in input().split()]\nseven = 0\nfive = 0\nif n[0] == 5:\n five += 1\nif n[0] == 7:\n seven += 1\nif n[1] == 5:\n five += 1\nif n[1] == 7:\n seven += 1\nif n[2] == 5:\n five += 1\nif n[2] == 7:\n seven += 1\nif five == 2 and seven == 1:\n print(\"YES\")\nelse:\n print(\"NO\")", "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 = [int(i) for i in input().split()]", "n", "[int(i) for i in input().split()]", "seven = 0", "seven", "0", "five = 0", "five", "0", "if n[0] == 5:\n five += 1", "n[0] == 5", "n[0]", "n", "0", "5", "five += 1", "five", "1", "if n[0] == 7:\n seven += 1", "n[0] == 7", "n[0]", "n", "0", "7", "seven += 1", "seven", "1", "if n[1] == 5:\n five += 1", "n[1] == 5", "n[1]", "n", "1", "5", "five += 1", "five", "1", "if n[1] == 7:\n seven += 1", "n[1] == 7", "n[1]", "n", "1", "7", "seven += 1", "seven", "1", "if n[2] == 5:\n five += 1", "n[2] == 5", "n[2]", "n", "2", "5", "five += 1", "five", "1", "if n[2] == 7:\n seven += 1", "n[2] == 7", "n[2]", "n", "2", "7", "seven += 1", "seven", "1", "if five == 2 and seven == 1:\n print(\"YES\")\nelse:\n print(\"NO\")", "five == 2 and seven == 1", "five == 2", "five", "2", "seven == 1", "seven", "1", "print(\"YES\")", "print", "\"YES\"", "print(\"NO\")", "print", "\"NO\"", "five += 1", "1", "five", "five += 1", "1", "five", "five = 0", "0", "five", "seven += 1", "1", "seven", "seven = 0", "0", "seven", "seven += 1", "1", "seven", "five += 1", "1", "five", "seven += 1", "1", "seven", "n = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "n" ]