#include<iostream>
#include<stdio.h>
#include<vector>
#include<math.h>
#include<string>
#include<algorithm>
#include<iterator>
#include<iomanip>
#include<limits.h>
using namespace std;

#define Pi 3.14159265358979323846264338327950288419716939937510582;
typedef long long int lld;
#define MOD 1000000007;
#define pb push_back
#define mp make_pair
#define pf push_front
#define ppb pop_back
lld modpow(lld a,lld n,lld temp){lld res=1;while(n>0){res=(res*res)%temp;if(n&1)res=(res*a)%temp;n/=2;}return res;}
lld gcd(lld a,lld b){if(a==0)return(b);else return(gcd(b%a,a));}

int main()
{
	lld n,k,a[200001],d[200001],del[200001]={0};
	cin>>n>>k;
	for(int i=1;i<=n;i++)
		cin>>a[i];
	lld dum=0;
	for(int i=1;i<=n;i++)
	{
		if(i==1)
		{
			d[i]=0;
			continue;
		}
		d[i]=dum-(i-1)*(n-i)*a[i];
		dum+=a[i]*(i-1);
	}
	int tot=n;
	while(1)
	{
		int done=1;
		for(int i=1;i<=n;i++)
		{
			if(d[i]<k&&del[i]==0)
			{
				cout<<i<<endl;
				del[i]=1;
				tot--;
				done=0;
				break;
			}
		}
		if(done==1)
			break;
		int cur=1;
		dum=0;
		for(int i=1;i<=n;i++)
		{
			if(del[i]==0)
			{
				if(cur==1)
				{
					d[i]=0;
					cur++;
					continue;
				}
				d[i]=dum-(cur-1)*(tot-cur)*a[i];
				dum+=a[i]*(cur-1);
				cur++;
			}
		}
	}
	return 0;

}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<math.h>
#include<string>
#include<algorithm>
#include<iterator>
#include<iomanip>
#include<limits.h>
using namespace std;

#define Pi 3.14159265358979323846264338327950288419716939937510582;
typedef long long int lld;
#define MOD 1000000007;
#define pb push_back
#define mp make_pair
#define pf push_front
#define ppb pop_back
lld modpow(lld a,lld n,lld temp){lld res=1;while(n>0){res=(res*res)%temp;if(n&1)res=(res*a)%temp;n/=2;}return res;}
lld gcd(lld a,lld b){if(a==0)return(b);else return(gcd(b%a,a));}

int main()
{
	lld n,k,a[200001],d[200001],del[200001]={0};
	cin>>n>>k;
	for(int i=1;i<=n;i++)
		cin>>a[i];
	lld dum=0;
	for(int i=1;i<=n;i++)
	{
		if(i==1)
		{
			d[i]=0;
			continue;
		}
		d[i]=dum-(i-1)*(n-i)*a[i];
		dum+=a[i]*(i-1);
	}
	int tot=n;
	while(1)
	{
		int done=1;
		for(int i=1;i<=n;i++)
		{
			if(d[i]<k&&del[i]==0)
			{
				cout<<i<<endl;
				del[i]=1;
				tot--;
				done=0;
				break;
			}
		}
		if(done==1)
			break;
		int cur=1;
		dum=0;
		for(int i=1;i<=n;i++)
		{
			if(del[i]==0)
			{
				if(cur==1)
				{
					d[i]=0;
					cur++;
					continue;
				}
				d[i]=dum-(cur-1)*(tot-cur)*a[i];
				if(d[i]<k)
					break;
				dum+=a[i]*(cur-1);
				cur++;
			}
		}
	}
	return 0;

}


#include<cstdio>
#include<iostream>

using namespace std;

int main()
{
    long long n, k, store, notdel, i, j, f, f1, del;

    while((scanf("%I64d %I64d", &n, &k)) != EOF)
    {
        store = f = f1 = 0;
        notdel = 1;
        del = 1;
        scanf("%I64d",&i);

        for(j = 2; j <= n; j++)
        {
            scanf("%I64d",&i);
            if((store - (n - j) * i * notdel) < k)
            {
                printf("%I64d\n",j);
                if(f1) del++;
                else f1 = 1;
            }
            else
            {
                store += i * (j - del - 1);
                notdel++;

            }

        }

    }

    return 0;
}


#include<cstdio>
#include<iostream>

using namespace std;

int main()
{
    long long n, k, store, notdel, i, j, f, f1, del;

    while(cin >> n >> k)
    {
        store = f = f1 = 0;
        notdel = 1;
        del = 1;
        cin >> i;

        for(j = 2; j <= n; j++)
        {
            cin >> i;
            if((store - (n - j) * i * notdel) < k)
            {
                cout << j << endl;
                if(f1) del++;
                else f1 = 1;
            }
            else
            {
                store += i * (j - del - 1);
                notdel++;

            }

        }

    }

    return 0;
}


#include<stdio.h>

int main()
{
    long long n, k, store, notdel, i, j, f, f1, del;

    while((scanf("%I64d %I64d", &n, &k)) != EOF)
    {
        store = f = f1 = 0;
        notdel = 1;
        del = 1;
        scanf("%I64d",&i);

        for(j = 2; j <= n; j++)
        {
            scanf("%I64d",&i);
            if((store - (n - j) * i * notdel) < k)
            {
                printf("%I64d\n",j);
                if(f1) del++;
                else f1 = 1;
            }
            else
            {
                store += i * (j - del - 1);
                notdel++;

            }

        }

    }

    return 0;
}


#include <algorithm>
#include <map>
#include <vector>
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <cstdlib>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <numeric>
using namespace std;

#define REP(i,n) for(int i=0; i<n; ++i)
#define IREP(it,array) for(vector<int>::iterator it=array.begin(); it!=array.end(); ++it)
#define PREP(it,array) for(vector<P>::iterator it=array.begin(); it!=array.end(); ++it)
#define SREP(it,array) for(vector<string>::iterator it=array.begin(); it!=array.end(); ++it)

#define MP       make_pair
#define PB       push_back
#define ALL(x)   (x).begin(),(x).end()

const int INF = 1<<29;
const double EPS = 1e-9;
double zero(double d){
  return d < EPS ? 0.0 : d;
}

typedef long long LL;
typedef pair<int,int> P;

int main()
{
  cout.setf(ios::fixed, ios::floatfield);
  cout.precision(8);
  ios_base::sync_with_stdio(false);

  int n,k;
  cin>>n>>k;

  int a[n+1];
  REP(i,n+1)
    cin>>a[i+1];

  LL sum=0L;
  int del=0;
  REP(i,n){
    int size = n-del;
    int ii = i+1-del;
    int d = sum - (LL)(size-ii)*(ii-1)*a[i+1];
    if( d < k ){
      cout << i+1 << endl;
      del++;
    }
    else
      sum += a[i+1] * i;
  }

}


#include <algorithm>
#include <map>
#include <vector>
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <cstdlib>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <numeric>
using namespace std;

#define REP(i,n) for(int i=0; i<n; ++i)
#define IREP(it,array) for(vector<int>::iterator it=array.begin(); it!=array.end(); ++it)
#define PREP(it,array) for(vector<P>::iterator it=array.begin(); it!=array.end(); ++it)
#define SREP(it,array) for(vector<string>::iterator it=array.begin(); it!=array.end(); ++it)

#define MP       make_pair
#define PB       push_back
#define ALL(x)   (x).begin(),(x).end()

const int INF = 1<<29;
const double EPS = 1e-9;
double zero(double d){
  return d < EPS ? 0.0 : d;
}

typedef long long LL;
typedef pair<int,int> P;

int main()
{
  cout.setf(ios::fixed, ios::floatfield);
  cout.precision(8);
  ios_base::sync_with_stdio(false);

  int n,k;
  cin>>n>>k;

  int a[n+1];
  REP(i,n+1)
    cin>>a[i+1];

  LL sum=0L;
  int del=0;
  REP(i,n){
    LL size = n-del;
    LL ii = i+1-del;
    LL d = sum - (size-ii)*(ii-1)*(LL)a[i+1];
//    cout << d << " " << ii << endl;
    if( d < k ){
      cout << i+1 << endl;
      del++;
    }
    else
      sum += a[i+1] * (ii-1);
  }

}


#include <algorithm>
#include <map>
#include <vector>
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <cstdlib>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <numeric>
using namespace std;

#define REP(i,n) for(int i=0; i<n; ++i)
#define IREP(it,array) for(vector<int>::iterator it=array.begin(); it!=array.end(); ++it)
#define PREP(it,array) for(vector<P>::iterator it=array.begin(); it!=array.end(); ++it)
#define SREP(it,array) for(vector<string>::iterator it=array.begin(); it!=array.end(); ++it)

#define MP       make_pair
#define PB       push_back
#define ALL(x)   (x).begin(),(x).end()

const int INF = 1<<29;
const double EPS = 1e-9;
double zero(double d){
  return d < EPS ? 0.0 : d;
}

typedef long long LL;
typedef pair<int,int> P;

int main()
{
  cout.setf(ios::fixed, ios::floatfield);
  cout.precision(8);
  ios_base::sync_with_stdio(false);

  int n,k;
  cin>>n>>k;

  int a[n+1];
  REP(i,n+1)
    cin>>a[i+1];

  LL sum=0L;
  int del=0;
  REP(i,n){
    LL size = n-del;
    LL ii = i+1-del;
    int d = sum - (size-ii)*(ii-1)*(LL)a[i+1];
//    cout << d << " " << ii << endl;
    if( d < k ){
      cout << i+1 << endl;
      del++;
    }
    else
      sum += a[i+1] * (ii-1);
  }

}


#include <algorithm>
#include <map>
#include <vector>
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <cstdlib>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <numeric>
using namespace std;

#define REP(i,n) for(int i=0; i<n; ++i)
#define IREP(it,array) for(vector<int>::iterator it=array.begin(); it!=array.end(); ++it)
#define PREP(it,array) for(vector<P>::iterator it=array.begin(); it!=array.end(); ++it)
#define SREP(it,array) for(vector<string>::iterator it=array.begin(); it!=array.end(); ++it)

#define MP       make_pair
#define PB       push_back
#define ALL(x)   (x).begin(),(x).end()

const int INF = 1<<29;
const double EPS = 1e-9;
double zero(double d){
  return d < EPS ? 0.0 : d;
}

typedef long long LL;
typedef pair<int,int> P;

int main()
{
  cout.setf(ios::fixed, ios::floatfield);
  cout.precision(8);
  ios_base::sync_with_stdio(false);

  int n,k;
  cin>>n>>k;

  int a[n+1];
  REP(i,n+1)
    cin>>a[i+1];

  LL sum=0L;
  int del=0;
  REP(i,n){
    LL size = n-del;
    LL ii = i+1-del;
    int d = sum - (size-ii)*(ii-1)*(LL)a[i+1];
    if( d < k ){
      cout << i+1 << endl;
      del++;
    }
    else
      sum += a[i+1] * i;
  }

}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<map>
#include<vector>
#include<list>
#include<set>
#include<queue>
#include<numeric>
#include<sstream>
#include<string>
#include<cmath>
#include<algorithm>
#include<stack>
using namespace std;
#define pb      push_back
#define mp      make_pair
#define EPS     1e-9
#define ll long long
#define vi vector<int>
#define pii pair<int,int>
#define fi first
#define se second
#define inf 1000000000
#define mod 1000000009
#define N 200010
#define M 30002

int main()
{
 // freopen("in.txt","r",stdin);
  int n,i,j,m,w,k;ll d=0,a,b;
  while(~scanf("%d%d",&n,&k))
  {
   int c=0;d=0;
   for(i=1;i<=n;i++)
   {
    scanf("%I64d",&a);
    ll t=d-c*(n-i)*a;
    if(t<k){printf("%d\n",i);}
    else d+=c*a,c++;
   }
  }
  return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<map>
#include<vector>
#include<list>
#include<set>
#include<queue>
#include<numeric>
#include<sstream>
#include<string>
#include<cmath>
#include<algorithm>
#include<stack>
using namespace std;
#define pb      push_back
#define mp      make_pair
#define EPS     1e-9
#define ll long long
#define vi vector<int>
#define pii pair<int,int>
#define fi first
#define se second
#define inf 1000000000
#define mod 1000000009
#define N 100010
#define M 30002
int a[N],b[N];ll d[N];
int main()
{
 // freopen("in.txt","r",stdin);
  int n,i,j,m,w,k;
  while(~scanf("%d%d",&n,&k))
  {
   for(i=1;i<=n;i++)
   {
    scanf("%d",&a[i]),b[i]=i;
   }
   while(1)
   {
    d[0]=0;a[0]=0;int c;
    for(i=1;i<=n;i++)
    {
     d[i]=d[i-1]+((n-i+2)*(i-2))*(ll)a[i-1]-(n-i)*(i-1)*(ll)a[i];
     if(d[i]<k)break;
    }
    if(i>n)break;
    printf("%d\n",b[i]);
    for(;i<n;i++)a[i]=a[i+1],b[i]=b[i+1];
    n--;
   }
  }
  return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<map>
#include<vector>
#include<list>
#include<set>
#include<queue>
#include<numeric>
#include<sstream>
#include<string>
#include<cmath>
#include<algorithm>
#include<stack>
using namespace std;
#define pb      push_back
#define mp      make_pair
#define EPS     1e-9
#define ll long long
#define vi vector<int>
#define pii pair<int,int>
#define fi first
#define se second
#define inf 1000000000
#define mod 1000000009
#define N 200010
#define M 30002
int a[N],b[N];ll d[N];
int main()
{
 // freopen("in.txt","r",stdin);
  int n,i,j,m,w,k;
  while(~scanf("%d%d",&n,&k))
  {
   for(i=1;i<=n;i++)
   {
    scanf("%d",&a[i]),b[i]=i;
   }
   while(1)
   {
    d[0]=0;a[0]=0;int c;
    for(i=1;i<=n;i++)
    {
     d[i]=d[i-1]+((n-i+2)*(i-2))*(ll)a[i-1]-(n-i)*(i-1)*(ll)a[i];
     if(d[i]<k)break;
    }
    if(i>n)break;
    printf("%d\n",b[i]);
    for(;i<n;i++)a[i]=a[i+1],b[i]=b[i+1];
    n--;
   }
  }
  return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<map>
#include<vector>
#include<list>
#include<set>
#include<queue>
#include<numeric>
#include<sstream>
#include<string>
#include<cmath>
#include<algorithm>
#include<stack>
using namespace std;
#define pb      push_back
#define mp      make_pair
#define EPS     1e-9
#define ll long long
#define vi vector<int>
#define pii pair<int,int>
#define fi first
#define se second
#define inf 1000000000
#define mod 1000000009
#define N 200010
#define M 30002

int main()
{
  //freopen("in.txt","r",stdin);
  int n,i,j,m,w,k;ll d=0;
  while(~scanf("%d%d",&n,&k))
  {
   int a,b;b=0;m=n;j=0;d=0;
   for(i=1;i<=n;i++)
   {
    scanf("%d",&a);
    ll t=d+(j-1)*(m-j+1)*b-j*(m-j-1)*a;
    if(t<k){printf("%d\n",i);m--;}
    else d=t,b=a,j++;
   }
  }
  return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<map>
#include<vector>
#include<list>
#include<set>
#include<queue>
#include<numeric>
#include<sstream>
#include<string>
#include<cmath>
#include<algorithm>
#include<stack>
using namespace std;
#define pb      push_back
#define mp      make_pair
#define EPS     1e-9
#define ll long long
#define vi vector<int>
#define pii pair<int,int>
#define fi first
#define se second
#define inf 1000000000
#define mod 1000000009
#define N 100010
#define M 30002
int a[N],b[N],d[N];
int main()
{
  //freopen("in.txt","r",stdin);
  int n,i,j,m,w,k;
  while(~scanf("%d%d",&n,&k))
  {
   for(i=1;i<=n;i++)
   {
    scanf("%d",&a[i]),b[i]=i;
   }
   while(1)
   {
    d[0]=0;a[0]=0;int c;
    for(i=1;i<=n;i++)
    {
     d[i]=d[i-1]+((n-i+2)*(i-2))*a[i-1]-(n-i)*(i-1)*a[i];
     if(d[i]<k)break;
    }
    if(i>n)break;
    printf("%d\n",b[i]);
    for(;i<n;i++)a[i]=a[i+1],b[i]=b[i+1];
    n--;
   }
  }
  return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<map>
#include<vector>
#include<list>
#include<set>
#include<queue>
#include<numeric>
#include<sstream>
#include<string>
#include<cmath>
#include<algorithm>
#include<stack>
using namespace std;
#define pb      push_back
#define mp      make_pair
#define EPS     1e-9
#define ll long long
#define vi vector<int>
#define pii pair<int,int>
#define fi first
#define se second
#define inf 1000000000
#define mod 1000000009
#define N 200010
#define M 30002

int main()
{
  //freopen("in.txt","r",stdin);
  int n,i,j,m,w,k;ll d=0,a,b;
  while(~scanf("%d%d",&n,&k))
  {
   b=0;m=n;j=0;d=0;
   for(i=1;i<=n;i++)
   {
    scanf("%I64d",&a);
    ll t=d+(j-1)*(m-j+1)*b-j*(m-j-1)*a;
    if(t<k){printf("%d\n",i);m--;}
    else d=t,b=a,j++;
   }
  }
  return 0;
}


#include<stdio.h>
#include<iostream>
using namespace std;

long long a[210000];

int main()
{
    int n,k;
    scanf("%d%d",&n,&k);

    int i;
    for(i=1;i<=n;i++)
    {
        cin>>a[i];
    }

    long long sum=0;
    int del=0;
    for(i=2;i<=n;i++)
    {
        if((sum-(i-del-1)*(n-i)*a[i])<k)
        {
            del++;
            printf("%d\n",i);
        }
        else
        {
            sum+=(a[i]*(i-del-1));
        }
    }

    return 0;
}


#include<stdio.h>
#include<iostream>
using namespace std;

long long a[210000];
long long n,k;

bool jud[210000];
long long cal(int id)
{
    int i;
    long long ans=0;
    for(i=1;i<id;i++)
    {
        if(jud[i])continue;
        ans+=((a[i])*(i-1)-(n-id)*a[id]);
    }
    return ans;
}

int main()
{
    cin>>n>>k;

    int i,j;
    for(i=1;i<=n;i++)
    {
        cin>>a[i];
    }

    bool judge=true;
    while(judge)
    {
        judge=false;

        for(i=1;i<=n;i++)
        {
            if(jud[i])continue;
            if(cal(i)<k)
            {
                judge=true;
                break;
            }
        }

        if(judge)
        {
        printf("%d\n",i);
        jud[i]=true;
        }
    }

    return 0;
}


#include<stdio.h>
#include<iostream>
using namespace std;

int a[210000];
int n,k;

bool jud[210000];
long long cal(int id)
{
    int i;
    long long ans=0;
    for(i=1;i<id;i++)
    {
        if(jud[i])continue;
        ans+=((a[i])*(i-1)-(n-id)*a[id]);
    }
    return ans;
}

int main()
{
    scanf("%d%d",&n,&k);

    int i,j;
    for(i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }

    bool judge=true;
    while(judge)
    {
        judge=false;

        for(i=1;i<=n;i++)
        {
            if(jud[i])continue;
            if(cal(i)<k)
            {
                judge=true;
                break;
            }
        }

        if(judge)
        {
        printf("%d\n",i);
        jud[i]=true;
        }
    }

    return 0;
}


#include<stdio.h>

int a[210000];
int n,k;

bool jud[210000];
int cal(int id)
{
    int i;
    int ans=0;
    for(i=1;i<id;i++)
    {
        if(jud[i])continue;
        ans+=((a[i])*(i-1)-(n-id)*a[id]);
    }
    return ans;
}

int main()
{
    scanf("%d%d",&n,&k);

    int i,j;
    for(i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }

    bool judge=true;
    while(judge)
    {
        judge=false;

        for(i=1;i<=n;i++)
        {
            if(jud[i])continue;
            if(cal(i)<k)
            {
                judge=true;
                break;
            }
        }

        if(judge)
        {
        printf("%d\n",i);
        jud[i]=true;
        }
    }

    return 0;
}


#include<stdio.h>
#include<iostream>
using namespace std;

long long a[210000];
int n,k;

bool jud[210000];
long long cal(int id)
{
    int i;
    long long ans=0;
    for(i=1;i<id;i++)
    {
        if(jud[i])continue;
        ans+=((a[i])*(i-1)-(n-id)*a[id]);
    }
    return ans;
}

int main()
{
    scanf("%d%d",&n,&k);

    int i,j;
    for(i=1;i<=n;i++)
    {
        cin>>a[i];
    }

    bool judge=true;
    while(judge)
    {
        judge=false;

        for(i=1;i<=n;i++)
        {
            if(jud[i])continue;
            if(cal(i)<k)
            {
                judge=true;
                break;
            }
        }

        if(judge)
        {
        printf("%d\n",i);
        jud[i]=true;
        }
    }

    return 0;
}


#include <stdio.h>
#include <vector>
#include <iostream>
using namespace std;
struct node
{
	int a,b;
};
int main()
{
	int n, k;
	vector<node> v;
	v.clear();
	scanf("%d%d", &n, &k);
	for(int i=0; i<n; i++)
	{
		node t;
		scanf("%d", &t.a);
		t.b = i+1;
		v.push_back(t);
	}
	while(1)
	{
		bool flag = false;
		long long sum = 0;
		int l = v.size();
		for(int i=1; i<l; i++)
		{

			if(sum - i*(l - (i+1)) * (v[i]).a < k)
			{
				printf("%d\n", v[i].b);
				v.erase(v.begin()+i);
				flag = true;
				break;
			}
			sum += i * (v[i]).a;
		}
		if(flag == false)break;
	}
	return 0;
}


#include <stdio.h>
#include <vector>
#include <iostream>
using namespace std;
struct node
{
	int a,b;
};
int main()
{
	int n, k;
	vector<node> v;
	scanf("%d%d", &n, &k);
	for(int i=0; i<n; i++)
	{
		node t;
		scanf("%d", &t.a);
		t.b = i+1;
		v.push_back(t);
	}
	while(1)
	{
		bool flag = false;
		long long sum = 0;
		int l = v.size();
		for(int i=1; i<l; i++)
		{

			if(sum - i*(l - (i+1)) * (v[i]).a <= k)
			{
				printf("%d\n", v[i].b);
				v.erase(v.begin()+i);
				flag = true;
				break;
			}
			sum += i * (v[i]).a;
		}
		if(flag == false)break;
	}
	return 0;
}


#include <stdio.h>
#include <vector>
#include <iostream>
using namespace std;
struct node
{
	long long a,b;
};
int main()
{
	long long n, k;
	vector<node> v;
	v.clear();
	scanf("%I64d%I64d", &n, &k);
	for(long long i=0; i<n; i++)
	{
		node t;
		scanf("%I64d", &t.a);
		t.b = i+1;
		v.push_back(t);
	}
	while(1)
	{
		bool flag = false;
		long long sum = 0;
		long long l = v.size();
		for(long long i=1; i<l; i++)
		{

			if(sum - i*(l-(i+1))*(v[i]).a < k)
			{
				printf("%I64d\n", v[i].b);
				v.erase(v.begin()+i);
				flag = true;
				break;
			}
			sum += i * (v[i]).a;
		}
		if(flag == false)break;
	}
	return 0;
}


#include <stdio.h>
#include <vector>
#include <iostream>
using namespace std;
struct node
{
	int a,b;
};
int main()
{
	int n, k;
	vector<node> v;
	scanf("%d%d", &n, &k);
	for(int i=0; i<n; i++)
	{
		node t;
		scanf("%d", &t.a);
		t.b = i+1;
		v.push_back(t);
	}
	while(1)
	{
		bool flag = false;
		int sum = 0;
		int l = v.size();
		for(int i=1; i<l; i++)
		{
			//printf("a:%d\n", sum - (l - (i+1)) * (v[i]).a);
			if(sum - i*(l - (i+1)) * (v[i]).a< k)
			{
				//printf("a:%d\n", sum - (l - (i+1)) * (v[i]).a);
				printf("%d\n", v[i].b);
				v.erase(v.begin()+i);
				flag = true;
				break;
			}
			sum += i * (v[i]).a;
		}
		if(flag == false)break;
	}
	return 0;
}


#include <stdio.h>
#include <vector>
#include <iostream>
using namespace std;
struct node
{
	int a,b;
};
int main()
{
	int n, k;
	vector<node> v;
	scanf("%d%d", &n, &k);
	for(int i=0; i<n; i++)
	{
		node t;
		scanf("%d", &t.a);
		t.b = i+1;
		v.push_back(t);
	}
	while(1)
	{
		bool flag = false;
		int sum = 0;
		int l = v.size();
		for(int i=1; i<l; i++)
		{

			if(sum - i*(l - (i+1)) * (v[i]).a <= k)
			{
				printf("%d\n", v[i].b);
				v.erase(v.begin()+i);
				flag = true;
				break;
			}
			sum += i * (v[i]).a;
		}
		if(flag == false)break;
	}
	return 0;
}


#include<iostream>
using namespace std;
int main()
{
int n,k,i,e=0;
long long a,s=0,t=0;
cin>>n>>k;
for(i=1;i<=n;i++)
{
cin>>a;
if(i>1 && t-(n-i)*a*(i-e-1)<k) cout<<i<<endl,e++;
else t+=a*(i-1-e);
}
return 0;
}


#include <stdio.h>
#include <vector>
#include <iostream>
using namespace std;
struct node
{
	int a,b;
};
int main()
{
	int n, k;
	vector<node> v;
	scanf("%d%d", &n, &k);
	for(int i=0; i<n; i++)
	{
		node t;
		scanf("%d", &t.a);
		t.b = i+1;
		v.push_back(t);
	}
	while(1)
	{
		bool flag = false;
		long long sum = 0;
		int l = v.size();
		for(int i=1; i<l; i++)
		{

			if(sum - i*(l - (i+1)) * (v[i]).a < k)
			{
				printf("%d\n", v[i].b);
				v.erase(v.begin()+i);
				flag = true;
				break;
			}
			sum += i * (v[i]).a;
		}
		if(flag == false)break;
	}
	return 0;
}


#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <list>
#include <climits>
#include <iostream>
#include <fstream>
#include <iomanip>

using namespace std;

int compare (const void *a, const void *b) {
	return *(int*)b - *(int*)a;
}

int main() {
	int x[200000];
	int n, k;
	scanf ("%d%d", &n, &k);
	for (int i = 1; i <= n; i++) {
		scanf ("%d", &x[i]);
	}
	//qsort (x + 1, n, sizeof(int), compare);

	int count = 1;
	long long int sum = 0;
	bool excluded = false;

	for (int i = 2; i <= n; i++) {
		if (!excluded)
			sum += x[i - 1] * (i - 2);

		long long int minus = (n - i) * x[i] * count;
		//printf (" >>%d\n", sum - minus);
		if (sum - minus < k) {
			printf ("%d\n", i);
			excluded = true;
			continue;
		}
		count++;
		excluded = false;
	}
	return 0;
}


#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <list>
#include <climits>
#include <iostream>
#include <fstream>
#include <iomanip>

using namespace std;

int compare (const void *a, const void *b) {
	return *(int*)b - *(int*)a;
}

int main() {
	int x[200000];
	int n, k;
	scanf ("%d%d", &n, &k);
	for (int i = 1; i <= n; i++) {
		scanf ("%d", &x[i]);
	}
	//qsort (x + 1, n, sizeof(int), compare);

	int count = 1;
	int sum = 0;
	bool excluded = false;

	for (int i = 2; i <= n; i++) {
		if (!excluded)
			sum += x[i - 1] * (i - 2);

		int minus = (n - i) * x[i] * count;
		//printf ("%d\n", d);
		if (sum - minus < k) {
			printf ("%d\n", i);
			excluded = true;
			continue;
		}
		count++;
		excluded = false;
	}
	return 0;
}


#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <list>
#include <climits>
#include <iostream>
#include <fstream>
#include <iomanip>

using namespace std;

int compare (const void *a, const void *b) {
	return *(int*)b - *(int*)a;
}

int main() {
	long long int x[300000];
	long long int n, k;
	cin >> n >> k;
	for (int i = 1; i <= n; i++) {
		cin >> x[i];
	}
	//qsort (x + 1, n, sizeof(int), compare);

	int count = 1;
	long long int sum = 0;
	bool excluded = false;

	for (int i = 2; i <= n; i++) {
		if (!excluded)
			sum += x[i - 1] * (i - 2);

		long long int minus = (n - i) * x[i] * count;
		//printf (" >>%d\n", sum - minus);
		if (sum - minus < k) {
			cout << i << "\n";
			excluded = true;
			continue;
		}
		count++;
		excluded = false;
	}
	return 0;
}


#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <list>
#include <climits>
#include <iostream>
#include <fstream>
#include <iomanip>

using namespace std;

int compare (const void *a, const void *b) {
	return *(int*)b - *(int*)a;
}

int main() {
	long long int x[300000];
	long long int n, k;
	cin >> n >> k;
	for (int i = 1; i <= n; i++) {
		cin >> x[i];
	}

	int count = 2;
	long long int sum = 0;
	bool excluded = false;
	int exl_count = 0;
	int temp_n = n;

	for (int i = 2; i <= n; i++) {
		if (!excluded)
			sum += x[i - 1] * (count - 2);

		long long int minus = (temp_n - count) * x[i] * (count - 1);
		//cout << sum - minus;
		if (sum - minus < k) {
			cout << i << "\n";
			excluded = true;
			temp_n--;
			continue;
		}
		count++;
		excluded = false;
	}
	return 0;
}


#include <iostream>
using namespace std;
long long n, k, x, tot, a[100001], d[100001];
int main()
{
  cin >> n >> k;
  for (long long i = 1; i <= n; ++i) cin >> a[i];
  for (long long i = 1; i < n; ++i) {
    long long t = d[i - 1] + a[i] * (i - 1 - x);
    if (t - a[i + 1] * (n - i - 1) * (i - x) < k) {
      ++x, d[i] = d[i - 1]; cout << i + 1 << endl;
    } else d[i] = t;
  }
  cout << endl;
  return 0;
}


#include <iostream>
using namespace std;
double n, k, x, tot, a[100001], d[100001];
bool vis[100001];
int main()
{
  cin >> n >> k;
  for (long long i = 1; i <= n; ++i) cin >> a[i];
  for (long long i = 1; i < n; ++i) {
    if (!vis[i]) d[i] = d[i - 1] + a[i] * (i - 1 - x);
    if (d[i - 1] + a[i] * (i - 1 - x) - a[i + 1] * (n - i - 1) * (i - x) < k) {
      ++x, vis[i + 1] = true, cout << i + 1 << endl;
    }
  }
  return 0;
}


#include <iostream>
using namespace std;
double n, k, x, tot, a[100001], d[100001];
int main()
{
  cin >> n >> k;
  for (long long i = 1; i <= n; ++i) cin >> a[i];
  for (long long i = 2; i <= n; ++i) {
    if (d[i - 1] - a[i] * (n - i) * (i - 1 - x) < k) {
      ++x, cout << i << endl, d[i] = d[i - 1];
    } else {
      d[i] = d[i - 1] + a[i] * (i - 1 - x);
    }
  }
  return 0;
}


#include <iostream>
using namespace std;
double n, k, x, tot, a[100001], d[100001];
int main()
{
  cin >> n >> k;
  for (long long i = 1; i <= n; ++i) cin >> a[i];
  for (long long i = 1; i < n; ++i) {
    if (d[i - 1] + a[i] * (i - 1 - x) - a[i + 1] * (n - i - 1) * (i - x) < k) {
      ++x, d[i] = d[i - 1]; cout << i + 1 << endl;;
    } else d[i] = d[i - 1] + a[i] * (i - 1 - x);
  }
  return 0;
}


#include <cstdio>
using namespace std;
long double n, k, x, tot, a[100001], d[100001];
int main()
{
  scanf("%lf%lf", &n, &k);
  for (long long i = 1; i <= n; ++i) scanf("%llf", &a[i]);
  for (long long i = 1; i < n; ++i) {
    long double t = d[i - 1] + a[i] * (i - 1 - x);
    if (t - a[i + 1] * (n - i - 1) * (i - x) < k) {
      ++x, d[i] = d[i - 1]; printf("%lld\n", i + 1);
    } else d[i] = t;
  }
  return 0;
}


#include <cstdio>
using namespace std;
double n, k, x, tot, a[200001], d[200001];
int main()
{
  scanf("%lf%lf", &n, &k);
  for (long long i = 1; i <= n; ++i) scanf("%ld", &a[i]);
  for (long long i = 2; i <= n; ++i) {
    if (d[i - 1] - a[i] * (n - i) * (i - 1 - x) < k) {
      ++x, printf("%lld\n", i), d[i] = d[i - 1];
    } else {
      d[i] = d[i - 1] + a[i] * (i - 1 - x);
    }
  }
  return 0;
}


#include <cstdio>
using namespace std;
double n, k, x, tot, a, pre;
int main()
{
  scanf("%lf%lf", &n, &k);
  for (long long i = 1; i <= n; ++i) {
    scanf("%lf", &a);
    if (pre - a * (n - i) * (i - 1 - x) < k) printf("%lld\n", i), ++x;
    else pre += a * (i - 1 - x);
  }
  return 0;
}


#include <iostream>
using namespace std;
int n, k, x, tot, a[100001], d[100001], pre[100001];
int main()
{
  cin >> n >> k;
  for (int i = 1; i <= n; ++i) cin >> a[i], pre[i] = i - 1;
  for (int i = 1; i < n; ++i) {
    int t = d[i - 1] + a[i] * (i - 1 - x);
    if (t - (n - i - 1) * a[i + 1] * (i - x) < k) {
      ++x, d[i] = d[i - 1]; cout << i + 1 << endl;
    } else d[i] = t;
  }
  return 0;
}


#include <cstdio>
using namespace std;
double n, k, x, tot, a[100001], d[100001];
int main()
{
  scanf("%lf%lf", &n, &k);
  for (long long i = 1; i <= n; ++i) scanf("%lf", &a[i]);
  for (long long i = 1; i < n; ++i) {
    long double t = d[i - 1] + a[i] * (i - 1 - x);
    if (t - a[i + 1] * (n - i - 1) * (i - x) < k) {
      ++x, d[i] = d[i - 1]; printf("%lld\n", i + 1);
    } else d[i] = t;
  }
  return 0;
}


#include <iostream>
using namespace std;
long long n, k, x, tot, a[100001], d[100001];
int main()
{
  cin >> n >> k;
  for (long long i = 1; i <= n; ++i) cin >> a[i];
  for (long long i = 1; i < n; ++i) {
    long long t = d[i - 1] + a[i] * (i - 1 - x);
    if (t - a[i + 1] * (n - i - 1) * (i - x) < k) {
      ++x, d[i] = d[i - 1]; cout << i + 1 << endl;
    } else d[i] = t;
  }
  return 0;
}


#include <iostream>
using namespace std;
long long n, k, x, tot, a[100001], d[100001], pre[100001];
int main()
{
  cin >> n >> k;
  for (long long i = 1; i <= n; ++i) cin >> a[i], pre[i] = i - 1;
  for (long long i = 1; i < n; ++i) {
    long long t = d[i - 1] + a[i] * (i - 1 - x);
    if (t - (n - i - 1) * a[i + 1] * (i - x) < k) {
      ++x, d[i] = d[i - 1]; cout << i + 1 << endl;
    } else d[i] = t;
  }
  return 0;
}


#include <cstdio>
using namespace std;
double n, k, x, tot, a, pre, t;
int main()
{
  scanf("%lf%lf", &n, &k);
  for (long long i = 1; i <= n; ++i) {
    scanf("%lf", &a);
    t = pre - a * (n - i) * (i - 1 - x);
    if (t < k) cout << i << endl, ++x;
    else pre += a * (i - 1 - x);
  }
  return 0;
}


#include <cstdio>
using namespace std;
double n, k, x, tot, a[200001], d[200001];
int main()
{
  scanf("%lf%lf", &n, &k);
  for (long long i = 1; i <= n; ++i) scanf("%lf", &a[i]);
  for (long long i = 2; i <= n; ++i) {
    if (d[i - 1] - a[i] * (n - i) * (i - 1 - x) < k) {
      ++x, printf("%lld\n", i), d[i] = d[i - 1];
    } else {
      d[i] = d[i - 1] + a[i] * (i - 1 - x);
    }
  }
  return 0;
}


#include <cstdio>
using namespace std;
double n, k, x, tot, a, pre, t;
int main()
{
  scanf("%lf%lf", &n, &k);
  for (long long i = 1; i <= n; ++i) {
    scanf("%lf", &a);
    t = pre - a * (n - i) * (i - 1 - x);
    if (t < k) printf("%lld\n", i), ++x;
    else pre += a * (i - 1 - x);
  }
  return 0;
}


#include <iostream>
using namespace std;
double n, k, x, tot, a[100001], d[100001];
bool vis[100001];
int main()
{
  cin >> n >> k;
  for (long long i = 1; i <= n; ++i) cin >> a[i];
  for (long long i = 1; i < n; ++i) {
    if (!vis[i]) d[i] = d[i - 1] + a[i] * (i - 1 - x); else d[i] = d[i - 1];
    if (d[i - 1] + a[i] * (i - 1 - x) - a[i + 1] * (n - i - 1) * (i - x) < k) {
      ++x, vis[i + 1] = true, cout << i + 1 << endl;
    }
  }
  return 0;
}


#include <iostream>
using namespace std;
long double n, k, x, tot, a[100001], d[100001];
int main()
{
  cin >> n >> k;
  for (long long i = 1; i <= n; ++i) cin >> a[i];
  for (long long i = 1; i < n; ++i) {
    long double t = d[i - 1] + a[i] * (i - 1 - x);
    if (t - a[i + 1] * (n - i - 1) * (i - x) < k) {
      ++x, d[i] = d[i - 1]; cout << i + 1 << endl;
    } else d[i] = t;
  }
  cout << endl;
  return 0;
}


#include <iostream>
using namespace std;
double n, k, x, tot, a[200001], d[200001];
int main()
{
  cin >> n >> k;
  for (long long i = 1; i <= n; ++i) cin >> a[i];
  for (long long i = 2; i <= n; ++i) {
    if (d[i - 1] - a[i] * (n - i) * (i - 1 - x) < k) {
      ++x, cout << i << endl, d[i] = d[i - 1];
    } else {
      d[i] = d[i - 1] + a[i] * (i - 1 - x);
    }
  }
  return 0;
}


#include <cstdio>
using namespace std;
double n, k, x, tot, a[100001], d[100001];
int main()
{
  scanf("%lf%lf", &n, &k);
  for (long long i = 1; i <= n; ++i) scanf("%lf", &a[i]);
  for (long long i = 1; i < n; ++i) {
    if (d[i - 1] + a[i] * (i - 1 - x) - a[i + 1] * (n - i - 1) * (i - x) < k) {
      ++x, d[i] = d[i - 1]; printf("%lld\n", i + 1);
    } else d[i] = d[i - 1] + a[i] * (i - 1 - x);
  }
  return 0;
}


#include <bits/stdc++.h>

#define fi first
#define se second
#define sc scanf
#define pr printf
#define pb push_back
#define mp make_pair
#define fin(s) freopen( s, "r", stdin );
#define fout(s) freopen( s, "w", stdout );

const int N = 200100;

using namespace std;

vector < int > v;
long long n, s, k, g;

int main()
{
    //fin("input.txt");
    //fout("output.txt");
    ios_base::sync_with_stdio(0);
    cin >> n >> k;
    for(int i = 1; i <= n; i++){
        long long x;
        cin >> x;
        long long d = s - (n - i) * x * g;
        if(d < k){
            v.pb(i);
            continue;
        }
        s += x * g;
        g++;
    }
    for(int i = 0; i < v.size(); i++)
        cout << v[i] << "\n";
}


#include <bits/stdc++.h>
using namespace std;

const int N = 200200;

int n, k, i, a[N];
long long d, sum;
vector<int> ans;

int main() {
	cin >> n >> k;
	for (i = 0; i < n; ++i) {
		scanf("%d", a + i);
	}
	for (i = 0; i < n; ++i) {
		d = sum - (i - ans.size()) * (n - i - 1LL) * a[i];

		if (d < k)
			ans.push_back(i + 1);
		else
			sum += a[i] * 1LL * i;
	}
	for (int a : ans) {
		printf("%d\n", a);
	}
	return 0;
}


#include <bits/stdc++.h>
using namespace std;

const int N = 200200;

int n, k, i, a[N];
long long d, sum;
vector<int> ans;

int main() {
	cin >> n >> k;
	for (i = 0; i < n; ++i) {
		scanf("%d", a + i);
	}
	for (i = 0; i < n; ++i) {
		d = sum - (i - ans.size()) * (n - i - 1LL) * a[i];

		if (d < k)
			ans.push_back(i + 1);
		else
			sum += a[i] * 1LL * (i - ans.size());
	}
	for (int a : ans) {
		printf("%d\n", a);
	}
	return 0;
}


#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
#include <string>
#include <map>
using namespace std;
int n;
long long k;
vector<int> tab;
long long num[200010];

int main()
{
	int i, j;
	scanf("%d%lld", &n, &k);
	for (i = 1; i <= n; i++)
	{
		scanf("%lld", &num[i]);
	}
	tab.push_back(1);
	long long cnt = 0;
	long long flag = 0;
	for (i = 2; i <= n; i++)
	{
		int len = tab.size();
		long long now = cnt - num[i] * (long long)(len)*(long long)(n - flag - len - 1);
		if (now < k)
		{
			flag++;
			printf("%d\n", i);
		}
		else
		{
			tab.push_back(i);
			len = tab.size();
			cnt += num[i] * (len - 1);
		}
	}
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    long long n,k;
    cin>>n>>k;
    long long a[n+5];
    for(int i=1; i<=n; i++)
    {
        cin>>a[i];
    }
    int num=0,sum=0,d=0;
    for(int i=1; i<=n; i++)
    {
        if(d<k)
            cout<<i<<endl;
        else
        {
            sum+=(a[i]*num);
            num++;
        }
        d=sum-num*(n-i-1)*a[i+1];
    }

    return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    long long n,k;
    cin>>n>>k;
    long long a[n+5];
    for(int i=1; i<=n; i++)
    {
        cin>>a[i];
    }
    long long num=0,sum=0,d=0;
    for(int i=1; i<=n; i++)
    {
        if(d<k)
            cout<<i<<endl;
        else
        {
            sum+=(a[i]*num);
            num++;
        }
        d=sum-num*(n-i-1)*a[i+1];
    }

    return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,k;
    cin>>n>>k;
    int a[n+5];
    for(int i=1; i<=n; i++)
    {
        cin>>a[i];
    }
    int num=0,sum=0,d=0;
    for(int i=1; i<=n; i++)
    {
        if(d<k)
            cout<<i<<endl;
        else
        {
            sum+=(a[i]*num);
            num++;
        }
        if(i!=n)
        {
            d=sum-num*(n-i-1)*a[i+1];
        }
    }

    return 0;
}


#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n, k; cin >> n >> k;
    vector<long long> a(n + 1);
    for (int i = 1; i <= n; i++) cin >> a[i];
    long long d = 0;
    int c = 0;
    for (int i = 1; i <= n; i++) {
        long long t = a[i] * c * (n - i);
        if (d - t < k) cout << i << endl;
        else d += a[i] * c++;
    }
    return 0;
}


#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <string.h>
#include<vector>
#include<queue>
#include <map>
#include <stack>

using namespace std;
#define ll  long long
//200000
const int MAX = 2e5 + 5;
const int inf = MAX * 10;
const ll MOD = 1e9 + 7;
double eps = 1e-9;

int n;
vector<ll> d;
vector<ll> a;
vector<ll> t;

int main()
{

	ll k;
	cin >> n >> k;

	ll t;
	d.push_back(0), a.push_back(0);
	d.push_back(0);
	cin >> t;
	a.push_back(t);
	ll dj;
	ll num = n;

	for (int i = 2; i <= n; i++)
	{
		cin >> t;
		int j = d.size();

		if (j == 2)
		{
			dj = -(num - 2)*t;
		}
		else
			dj = d[j - 1] + (num - j+1)*(j-2)*a[j - 1] + a[j-1] *(j-2) - (num - j)*t*(j-1);

		if (dj < k)
		{
			num--;
			cout << i << endl;
			d[j - 1] += a[j - 1] * (j - 2);
		}
		else
		{
			a.push_back(t);
			d.push_back(dj);
		}
	}

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define all(v) ((v).begin()), ((v).end())
#define INF (ll)1e9 + 10
#define EPS 1e-9
#define bitcount __builtin_popcount
#define sz(v) ((int)((v).size()))
#define clr(v, d) memset(v, d, sizeof(v))
#define rep(i, v) for (int i = 0; i < sz(v); ++i)
#define lp(i, n) for (int i = 0; i < (int)(n); ++i)
#define LSOne(S) (S & (-S))
#define P(x) cout << #x << " = { " << x << " }\n"
#define tests()  \
    int tttt;    \
    cin >> tttt; \
    while (tttt--)
#define fast_IO                       \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);                    \
    cout.tie(NULL);
#define file_IO                       \
    freopen("input.txt", "r", stdin); \
    freopen("output.txt", "w", stdout)
typedef long long ll;
int dcmp(long double x, long double y)
{
    return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1;
}
const int MAX = 2e5 + 10;
ll arr[MAX], sum, k, n;
int main()
{
#ifndef ONLINE_JUDGE
    file_IO;
#else
    fast_IO;
#endif
    cin >> n >> k;
    for (int i = 1; i <= n; i++)
    {
        cin >> arr[i];
    }
    ll cur_n = n, ptr = 2;
    for (int i = 2; i <= n; i++)
    {
        ll cur_di = sum - (ptr - 1LL) * (arr[i] * (cur_n - ptr));
        // P(cur_n);
        // P(ptr);
        // P(cur_di);
        // P(sum);
        if (cur_di < k)
        {
            cout << i << '\n';
            cur_n--;
        }
        else
        {
            sum += arr[i] * (ptr - 1LL);
            ptr++;
        }
    }
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
#include <stdio.h>
#include <algorithm>
#include <set>
#include <map>
#include <math.h>
#include <cmath>
#include <queue>
#include <iomanip>
#include <bitset>
#include <unordered_map>

#define LL long long
#define uLL unsigned long long
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define vI vector<int>
#define vvI vector<vector<int>>
#define forn(it,from,to) for(int (it)=from; (it)<to; (it)++)
#define forI(tmp) for(auto(it)=(tmp).begin();(it)!=(tmp).end();(it)++)
#define PI 3.14159265356
#define sc(a) scanf("%d", &(a))
const LL mod = 1000000007;
const LL Inf = 2 * 1e9;
using namespace std;
int toint(string s) {
	LL ans = 0;
	forn(i, 0, s.length()) ans = ans * 10 + (s[i] - '0');
	return ans;
}
vI a;
vector<pair<int, int>> pr;
int main()
{
#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#else
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
#endif
	ios::sync_with_stdio(false);
	int n, k;
	scanf("%d%d",&n,&k);
	a.resize(n);
	forn(i, 0, n) scanf("%d",&a[i]);
	LL r = 0, ch = 0, count = 0, nn = n;
	forn(i, 2, n) {
		r = ch - (i - 1-count)*(n - i)*a[i-1];
		ch += (i - 1-count)*a[i-1];
		if (r < k) {
			printf("%d\n",i);
			ch-= (i - 1-count)*a[i - 1];
			count++;
		}
	}
	return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
#include <stdio.h>
#include <algorithm>
#include <set>
#include <map>
#include <math.h>
#include <cmath>
#include <queue>
#include <iomanip>
#include <bitset>
#include <unordered_map>

#define LL long long
#define uLL unsigned long long
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define vI vector<int>
#define vvI vector<vector<int>>
#define forn(it,from,to) for(int (it)=from; (it)<to; (it)++)
#define forI(tmp) for(auto(it)=(tmp).begin();(it)!=(tmp).end();(it)++)
#define PI 3.14159265356
#define sc(a) scanf("%d", &(a))
const LL mod = 1000000007;
const LL Inf = 2 * 1e9;
using namespace std;
int toint(string s) {
	LL ans = 0;
	forn(i, 0, s.length()) ans = ans * 10 + (s[i] - '0');
	return ans;
}
vI a;
vector<pair<int, int>> pr;
int main()
{
#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#else
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
#endif
	ios::sync_with_stdio(false);
	int n, k;
	cin >> n >> k;
	a.resize(n);
	forn(i, 0, n) cin >> a[i];
	LL r = 0, ch = 0, count = 0, nn = n;
	forn(i, 2, n) {
		r = ch - (i - 1-count)*(n - i)*a[i-1];
		ch += (i - 1-count)*a[i-1];
		if (r < k) {
			cout << i << endl;
			ch-= (i - 1-count)*a[i - 1];
			count++;
		}
	}
	return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
#include <stdio.h>
#include <algorithm>
#include <set>
#include <map>
#include <math.h>
#include <cmath>
#include <queue>
#include <iomanip>
#include <bitset>
#include <unordered_map>

#define LL long long
#define uLL unsigned long long
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define vI vector<int>
#define vvI vector<vector<int>>
#define forn(it,from,to) for(int (it)=from; (it)<to; (it)++)
#define forI(tmp) for(auto(it)=(tmp).begin();(it)!=(tmp).end();(it)++)
#define PI 3.14159265356
#define sc(a) scanf("%d", &(a))
const LL mod = 1000000007;
const LL Inf = 2 * 1e9;
using namespace std;
int toint(string s) {
	LL ans = 0;
	forn(i, 0, s.length()) ans = ans * 10 + (s[i] - '0');
	return ans;
}
vI a;
vector<pair<int, int>> pr;
int main()
{
#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#else
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
#endif
	ios::sync_with_stdio(false);
	int n, k;
	cin >> n >> k;
	a.resize(n);
	forn(i, 0, n) scanf("%d",&a[i]);
	LL r = 0, ch = 0, count = 0, nn = n;
	forn(i, 2, n) {
		r = ch - (i - 1-count)*(n - i)*a[i-1];
		ch += (i - 1-count)*a[i-1];
		if (r < k) {
			printf("%d\n",i);
			ch-= (i - 1-count)*a[i - 1];
			count++;
		}
	}
	return 0;
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  ll n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  k=0; ll sum=0;

  rep(i,2,n)
     if(sum-(n-i)*(i-1-k)*a[i]<K)
     {
     	cout<<i<<endl;
     	++k;
     }
     else sum+=a[i]*(i-1);
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  int n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  k=0; ll sum=0;

  rep(i,2,n)
     if(sum-(n-i)*(i-1-k)*a[i]<K)
     {
     	cout<<i<<endl;
     	++k;
     }
     else sum+=a[i]*(i-k-1);
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  ll n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  k=0; ll sum=0; vll v;

  rep(i,2,n)
     if(sum-(n-i)*(i-1-k)*a[i]<K)
     {
     	v.pb(i);
     	++k;
     }
     else sum+=a[i]*(i-k-1);

     rep(i,0,sz(v)-1) cout<<v[i]<<'\n';
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  ll n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  k=0; ll sum=0; vll v;

  rep(i,2,n)
     if(sum-(n-i)*(i-1-k)*a[i]<K)
     {
     	v.pb(i);
     	++k;
     }
     else sum+=a[i]*(i-k-1);

     rep(i,0,sz(v)-1) cout<<v[i]<<"\n";
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  ll n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  k=0; ll sum=0; vll v;

  rep(i,2,n)
     if(sum-(n-i)*(i-1-k)*a[i]<K)
     {
     	v.pb(i);
     	++k;
     }
     else sum+=a[i]*(i-k-1);

     rep(i,0,sz(v)-1) cout<<v[i]<<endl;
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  ll n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  k=0; ll sum=0;

  rep(i,2,n)
     if(sum-(n-i)*(i-1-k)*a[i]<K)
     {
     	cout<<i<<endl;
     	++k;
     }
     else sum+=a[i]*(i-k-1);
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  int n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  ll rating[n+1]={0};
  rep(i,2,n)
    rating[i]+=rating[i-1]+a[i-1]*(i-2);
  rep(i,1,n)
    rating[i]-=(n-i)*(i-1)*a[i];

k=0; ll sum=0;
  rep(i,1,n)
    {
    	ll newrating = rating[i] + (n-i)*k*a[i] - sum;

    	trace(newrating);
        if(newrating<K)
        {
    		++k;
    		sum+=a[i]*(i-1);
    		cout<<i<<endl;
        }
    }
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  int n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  ll rating[n+1]={0};
  rep(i,2,n)
    rating[i]+=rating[i-1]+a[i-1]*(i-2);
  rep(i,1,n)
    rating[i]-=(n-i)*(i-1)*a[i];

k=0; ll sum=0;
  rep(i,1,n)
    {
    	ll newrating = rating[i] + (n-i)*k*a[i] - sum;

    	// trace(newrating);
        if(newrating<K)
        {
    		++k;
    		sum+=a[i]*(i-1);
    		cout<<i<<endl;
        }
    }
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  ll n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  k=0; ll sum=0; vll v;

  rep(i,2,n)
     if(sum-(n-i)*(i-1-k)*a[i]<K)
     {
     	v.pb(i);
     	++k;
     }
     else sum+=a[i]*(i-1);

     rep(i,0,sz(v)-1) cout<<v[i]<<'\n';
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  int n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  ll rating[n+1]={0};
  rep(i,2,n)
    rating[i]+=rating[i-1]+a[i-1]*(i-2);
  rep(i,1,n)
    rating[i]-=(n-i)*(i-1)*a[i];

k=0; ll sum=0;
  rep(i,1,n)
    {
    	ll newrating = rating[i] + (n-i)*k*a[i] - sum;

    	// trace(newrating);
        if(newrating<K)
        {
    		++k;
    		sum+=a[i]*(i-k-1);
    		cout<<i<<endl;
        }
    }
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  ll n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  k=0; ll sum=0; vll v;

  rep(i,2,n)
     if(sum-(n-i)*(i-1-k)*a[i]<K)
     {
     	v.pb(i);
     	++k;
     }
     else sum+=a[i]*(i-1);

     rep(i,0,sz(v)-1) cout<<v[i]<<endl;
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  ll n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  k=0; ll sum=0; vll v;

  rep(i,2,n)
     if(sum-(n-i)*(i-1-k)*a[i]<K)
     {
     	v.pb(i);
     	++k;
     }
     else sum+=a[i]*(i-1);

     rep(i,0,sz(v)-1) cout<<v[i]<<"\n";
}


//* Wild.Stone - IIT Roorkee *

#include<bits/stdc++.h>
using namespace std;
   #ifndef WildStone
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("unroll-loops")
   #endif
#define rep(i,a,b) for(i=a;i<=b;++i)
#define rev(i,a,b) for(i=a;i>=b;--i)
#define max2(a,b)  ((a)>(b)?(a):(b))
#define min2(a,b)  ((a)<(b)?(a):(b))
#define all(x)  x.begin(),x.end()
#define sz(x)  (int)x.size()
#define ins insert
#define fi first
#define se second
#define pb emplace_back  //push_back
#define mp make_pair
#define endl '\n'

#ifdef WildStone
  template <typename T>
       void __p(T a) { cout << a << " "; }
  template <typename T, typename F>
       void __p(pair<T,F> a) { cout<<"{ "; __p(a.fi); __p(a.se); cout<<"}"; }
  template <typename T>
       void __p(vector<T> a) { cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T>
       void __p(set<T> a) {cout<<"{ "; for(auto __it: a) { __p(__it); cout<<", "; } cout<<"}"; }
  template <typename T,typename F>
       void __p(map<T,F> a) { cout<<"{ "; for(auto __it: a) { __p(__it.fi); cout<<"-> "; __p(__it.se); cout<<", "; } cout<<"}"; }

  template <typename Arg1>
       void __f(const char* name, Arg1&& arg1)             // for single trace argument
          { cout<<name<<" : "; __p(arg1); cout<<endl; }
  template <typename Arg1, typename ...Args>
       void __f(const char* names, Arg1&& arg1, Args&& ...args)  // for multiple trace arguments
          {
          	 int __bracket=0,__i=0; string __s;
          	 for(;;__i++)
          	 	  if(names[__i]==',' && __bracket==0)  break;
          	 	  else
          	 	  {  __s += names[__i];
          	 	  	     if(names[__i]=='(') __bracket++;
          	 	  	else if(names[__i]==')') __bracket--;
          	 	  }
             cout<<__s<<" : ";   __p(arg1); cout<<" | ";
             __f(names+(__i)+1,args...);
          }
   template <typename Arg1, typename Arg2>                          // for traversing array
        void __f(const char* name , Arg1 arg1[], Arg2&& arg2)
          {
             int __i=0;  string __s;
             for(;;__i++) if(name[__i]==',') break; else __s += name[__i];
             cout<<__s<<" : ";
             for(__i=0;__i<arg2;__i++) __p(arg1[__i]); cout<<endl;
          }
  #define trace(...) cout<<"LINE: "<<__LINE__<<" || "; __f( #__VA_ARGS__, __VA_ARGS__)
  clock_t clk=clock();
  #define checktime() cout<<"\nTime Elapsed : "<<float(clock()-clk)/CLOCKS_PER_SEC<<endl
#else
  #define trace(...);
  #define checktime();
#endif

typedef long long int ll;
typedef long double   ld;
typedef pair<int,int> pii;
typedef pair<ll,ll>   pll;
typedef vector<int>   vi;
typedef vector<ll>    vll;
typedef vector<pii>   vpii;
typedef vector<pll>   vpll;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T>
// using ordered_set =  tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// #define fbo find_by_order //--> *p.fbo(0), *p.fbo(1).... iterating like vector/array
// #define ook order_of_key  //--> p.ook(element) : lowerbound binary search
//  (int)p.size();    // p.erase(value) --> erases element with that value

const ll mod = 1000000007;  //998244353;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-9;
const double PI  = acos(-1);

ll i,j,k;
void solve(void);
inline bool equal(double a, double b) { return fabs(a-b)<eps; }
// inline ll gcd(ll a, ll b) { a=abs(a); b=abs(b); while(a>0 && b>0) (a>b?a%=b:b%=a); return (a==0?b:a); }
// inline ll power(ll x, ll n, ll m = LLONG_MAX)
//        {  ll res=1;
//        	   while(n) { if(n&1) res=(res*x)%m;  x=(x*x)%m;  n >>= 1; }  return res;
//        }

int main()
{
	ios_base::sync_with_stdio(false); cin.tie(0);
	cout<<fixed<<setprecision(10);
	int t = 1;
	// cin>>t;
	    while(t--)  solve();
	checktime();
	return 0;
}

void solve()
{
  int n,K; cin>>n>>K;
  ll a[n+1]={0}; rep(i,1,n) cin>>a[i];

  k=0; ll sum=0;

  rep(i,2,n)
     if(sum-(n-i)*(i-1-k)*a[i]<K)
     {
     	cout<<i<<endl;
     	++k;
     }
     else sum+=a[i]*(i-1);
}


#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
#include <vector>
#include <iostream>
#include <stack>
#include <set>
#include <map>
#define LSON l,m,x<<1
#define RSON m+1,r,x<<1|1
using namespace std;

const int MAX=2e5+5;
long long n,k;
long long a[MAX];

int main(){
	int i;
	long long d[MAX],cnt=0,tmpd;

	scanf("%lld%lld",&n,&k);
	for(i=1;i<=n;i++)
	    scanf("%lld",&a[i]);
	for(i=2;i<=n;i++){
		d[i]=d[i-1-cnt]+a[i-1]*(i-2-cnt);
		tmpd=d[i]-(i-1-cnt)*(n-i)*a[i];
		if(tmpd<k){
		    printf("%d\n",i);
		    cnt++;
		}
	}

	return 0;
}


#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
#include <vector>
#include <iostream>
#include <stack>
#include <set>
#include <map>
#define LSON l,m,x<<1
#define RSON m+1,r,x<<1|1
using namespace std;

const int MAX=2e5+5;
long long n,k;
long long a[MAX];
long long d[MAX],cnt,tmpd;

int main(){
	int i;

	scanf("%lld%lld",&n,&k);
	for(i=1;i<=n;i++)
	    scanf("%lld",&a[i]);
	for(i=2;i<=n;i++){
		d[i-cnt]=d[i-1-cnt]+a[i-1-cnt]*(i-2-cnt);
		tmpd=d[i-cnt]-(i-1-cnt)*(n-i)*a[i];
		if(tmpd<k){
		    printf("%d\n",i);
		    cnt++;
		}
	}

	return 0;
}


#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
#include <vector>
#include <iostream>
#include <stack>
#include <set>
#include <map>
#define LSON l,m,x<<1
#define RSON m+1,r,x<<1|1
using namespace std;

const int MAX=2e5+5;
long long n,k;
long long a[MAX];
long long d[MAX],cnt=0,tmpd;

int main(){
	int i;

	scanf("%lld%lld",&n,&k);
	for(i=1;i<=n;i++)
	    scanf("%lld",&a[i]);
	for(i=2;i<=n;i++){
		d[i-cnt]=d[i-1-cnt]+a[i-1]*(i-2-cnt);
		tmpd=d[i-cnt]-(i-1-cnt)*(n-i)*a[i];
		if(tmpd<k){
		    printf("%d\n",i);
		    cnt++;
		}
	}

	return 0;
}