Problem:
Problem Statement

We have N pieces of ropes, numbered 1 through N. The length of piece i is a_i.

At first, for each i (1≤i≤N-1), piece i and piece i+1 are tied at the ends, forming one long rope with N-1 knots. Snuke will try to untie all of the knots by performing the following operation repeatedly:

Choose a (connected) rope with a total length of at least L, then untie one of its knots.

Is it possible to untie all of the N-1 knots by properly applying this operation? If the answer is positive, find one possible order to untie the knots.

Constraints

2≤N≤10^5

1≤L≤10^9

1≤a_i≤10^9

All input values are integers.

Input

The input is given from Standard Input in the following format:

N L
a_1 a_2 ... a_n

Output

If it is not possible to untie all of the N-1 knots, print Impossible.

If it is possible to untie all of the knots, print Possible, then print another N-1 lines that describe a possible order to untie the knots. The j-th of those N-1 lines should contain the index of the knot that is untied in the j-th operation. Here, the index of the knot connecting piece i and piece i+1 is i.

If there is more than one solution, output any.

Sample Input 1

3 50
30 20 10

Sample Output 1

Possible
2
1

If the knot 1 is untied first, the knot 2 will become impossible to untie.

Sample Input 2

2 21
10 10

Sample Output 2

Impossible

Sample Input 3

5 50
10 20 30 40 50

Sample Output 3

Possible
1
2
3
4

Another example of a possible solution is 3, 4, 1, 2.

Solution in C (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#define MIN(x,y) ((x)<(y)?(x):(y))
#define MAX(x,y) ((x)<(y)?(y):(x))
#define MOD 1000000007LL
#define STR_EQ(s1,s2)       strcmp(s1,s2)==0
#define rep(i,l,n) for(int (i)=(l);(i)<(n);(i)++)
#define invrep(i,l,n) for(int (i)=(l);(i)>=(n);(i)--)
//#define MOD 998244353LL
//#define MOD 1000000009LL
const long long INF = 1LL << 60;
typedef long long ll;
ll llabs(ll a){if(a<0)return -a;return a;}//abs
void swap(ll *a,ll *b){ll tmp=*a;*a=*b;*b=tmp;}//swap
int fact(int a){int r=1;for(int i = 1;i<=a;i++)r*=i;return r;}//factral
ll addm(ll a, ll b){ll x = (a%MOD+b%MOD)%MOD;if (x < 0) x+=MOD;return x;}//addmod,submod
ll mulm(ll a, ll b){return(a%MOD*b%MOD)%MOD;}//mulmod
ll lpow(ll x,ll n){ll ans = 1;while(n){if(n&1) ans*=x;x*=x;n>>=1;}return ans;} //power
ll powm(ll x,ll n){x%=MOD;ll ans = 1;while(n){if(n&1) ans=mulm(ans,x);x=mulm(x,x);n>>=1;}return ans;} //power mod
ll lgcd(ll a, ll b){if(a==b) return a;if(a<b) swap(&a,&b);if (b == 0) return a;return lgcd(b, a%b);}//gcd
ll llcm(ll a, ll b){return a*b/lgcd(a,b);};//lcm
ll legcd(ll a,ll b,ll *x,ll *y){if(b==0){*x=1;y=0;return a;}ll q = a/b;ll g = legcd(b,a-q*b,x,y);ll z = *x-q*(*y);*x=*y;*y=z;return g;}//extra_gdd
ll divm(ll a,ll b){ll x,y;a%=MOD;b%=MOD;legcd(b,MOD,&x,&y);x%=MOD;if(x<0) x+=MOD;return x;}//divmod_with_extra_gdd
ll permutation(ll n, ll m){if(n<m) return 0;if(n-m < m) m = n-m;int ans = 1;for(int i = 0;i<m;i++) ans*=(n-i);return ans;}//nPm
ll combination(ll n, ll m){return permutation(n,m)/m;}//nCm
int acmpinum(const void * left, const void * right){
	if (*(int *)left > *(int *)right) return 1;
	else if (*(int *)left < *(int *)right) return -1;
	else return 0;
}//qsort(int配列,配列の長さ,sizeof(int),acmpinum);
int dcmpinum(const void * left, const void * right){
	if (*(int *)left > *(int *)right) return -1;
	else if (*(int *)left < *(int *)right) return 1;
	else return 0;
}//qsort(int配列,配列の長さ,sizeof(int),dcmpinum);
int acmpllnum(const void * left, const void * right){
	if (*(ll *)left > *(ll *)right) return 1;
	else if (*(ll *)left < *(ll *)right) return -1;
	else return 0;
}//qsort(ll配列,配列の長さ,sizeof(ll),acmpllnum);
int dcmpllnum(const void * left, const void * right){
	if (*(ll *)left > *(ll *)right) return -1;
	else if (*(ll *)left < *(ll *)right) return 1;
	else return 0;
}//qsort(ll配列,配列の長さ,sizeof(ll),dcmpllnum);
int cmpchar(const void* left, const void* right) {
    char *left_char = (char *)left;
    char *right_char = (char *)right;
    return strcmp( left_char, right_char );
}//qsort(文字列配列,1,文字列の長さ,cmpchar);

int main(){
    ll N,L,left,right;
  	left=0,right=-1;
    scanf("%lld %lld",&N,&L);
  	ll a[N];
  	for(ll i = 0;i<N;i++) scanf("%lld",&a[i]);
  	for(ll i = 0;i<N;i++){
      if(a[i]>=L){
        left=i+1;
        right=left;
        break;
      }else if(i!=N-1){
          if(a[i]+a[i+1]>=L){
          	left=i+1;
          	right=i+2;
          	break;
          }
      }
    }
  	if(left == 0){
      printf("Negative\n");
      return 0;
    }
  	printf("Positive\n");
  	for(ll i = 1;i<left;i++) printf("%lld\n",i);
  	for(ll i = N-1;i>=right;i--) printf("%lld\n",i);
    if(left != right) printf("%lld\n",left);
    return 0;
}