Marmot found a row with n pillars. The i-th pillar has the height of hi meters. Starting from one pillar i1, Marmot wants to jump on the pillars i2, ..., ik. (1 ≤ i1 < i2 < ... < ik ≤ n). From a pillar i Marmot can jump on a pillar j only if i < j and |hi - hj| ≥ d, where |x| is the absolute value of the number x.

Now Marmot is asking you find out a jump sequence with maximal length and print it.

Input

The first line contains two integers n and d (1 ≤ n ≤ 105, 0 ≤ d ≤ 109).

The second line contains n numbers h1, h2, ..., hn (1 ≤ hi ≤ 1015).

Output

The first line should contain one integer k, the maximal length of a jump sequence.

The second line should contain k integers i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), representing the pillars' indices from the maximal length jump sequence.

If there is more than one maximal length jump sequence, print any.

Examples

Input

5 2
1 3 6 7 4


Output

4
1 2 3 5 


Input

10 3
2 1 3 6 9 11 7 3 20 18


Output

6
1 4 6 7 8 9 

Note

In the first example Marmot chooses the pillars 1, 2, 3, 5 with the heights 1, 3, 6, 4. Another jump sequence of length 4 is 1, 2, 4, 5.
import java.util.*;
import java.math.*;
import java.io.*;

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

public class Main{
	
	// ArrayList<Integer> lis = new ArrayList<Integer>();
	// ArrayList<String> lis = new ArrayList<String>();
	//  PriorityQueue<P> que = new PriorityQueue<P>();
	// PriorityQueue<Integer> que = new PriorityQueue<Integer>();
	//  Stack<Integer> que = new Stack<Integer>();
	//HashMap<Long,Long> map = new HashMap<Long,Long>();
    //	static long sum=0;
	// 1000000007 (10^9+7)
	static int mod = 1000000007;
	//static int mod = 1000000009,r=0; ArrayList<Integer> l[]= new ArrayList[n];
   // static int dx[]={1,-1,0,0};
//	static int dy[]={0,0,1,-1};
//	static int dx[]={1,-1,0,0,1,1,-1,-1};
//  static int dy[]={0,0,1,-1,1,-1,1,-1};
	//static Set<Integer> set = new HashSet<Integer>();

	//static ArrayList<Integer> l[];
    //static int parent[][],depth[],node,max_log;


	
public  static void main(String[] args)   throws Exception, IOException{
   //String line=""; throws Exception, IOException
   //(line=br.readLine())!=null
	//Scanner sc =new Scanner(System.in);
	// !!caution!! int long //  
	Reader sc = new Reader(System.in);
   

    //,a=sc.nextInt(),b=sc.nextInt();
 	// int n=sc.nextInt(),p[]=new int[n],q[]=new int[n];
	//int n=sc.nextInt(),a[]=new int[n],b[]=new int[n];
	//int n=sc.nextInt(); //,k=sc.nextInt();
	//long n=sc.nextLong(),k=0,r=0;
	

	
	int n=sc.nextInt(),d=sc.nextInt(); 
	long h[]=new long[n];
	
	//HashMap<Long,Integer> map = new HashMap<Long,Integer>();
	Set<Long> set = new HashSet<Long>();
	
	
	for (int i = 0; i < n; i++) {
		long x=sc.nextLong();
		h[i]=x;
		set.add(x);
	}
	
	int l=set.size(),k=0;
	Long v[]=new Long[l];
	v=set.toArray(v);
	
	sort(v);


	SegTree2 sg=new SegTree2(l);
	int pr[]=new int[n];
	
	
	sg.update(  binarySearch(v, h[0]), 1 , 1 );
	int mx=0,id=-1;
	
	//db(v,v.length);
	
	for (int i = 1; i < n; i++) {
		
		long a=h[i]-d;
		int e[]=new int[2],c=binarySearch(v, h[i]);
		int f[]=new int[2];
		
		int b=binarySearch(v, a);
		if(b<0)b=~b;
		else b++;
		
		//db(h[i],a,b);
		
		if( b>0 ){
			e=sg.query(0, b, 0, 0, sg.n);
		}
		
		

		a=h[i]+d;
	    b=binarySearch(v, a);
	    if(b<0)b=~b;
	    
	   // db(a,b);
	    
	    if( b<l ){
			f=sg.query(b, l, 0, 0, sg.n);
		}
	    


	    
	//    db(f,e,mx);
	    if( f[0]<1 &&e[0]<1 ){
	    	sg.update(c, 1 ,i+1);
	    	continue;}
	    
	    if( f[0]>e[0] )e=f;

	      pr[i]=e[1]; sg.update(c, ++e[0] ,i+1);
		  if( mx<e[0] ){ mx=e[0]; id=i; }
		  
		
		
	}
	
//	db(mx,id); db(pr);
	
	if(mx<1){System.out.println(0); return;}
	  
	StringBuilder sb=new StringBuilder();
	k=1;
	int j=2;
//	db(v);
	int jp[]=new int[mx];	
	 jp[mx-1]=id+1;
	 while( mx>k++ ){
		 jp[mx-j++]=pr[id]--;
		// StringBuilder s=new StringBuilder(pr[id]--+" ");
	//	sb=s.append(sb);	
		id=pr[id];
	 }
	
	 for (int m = 0; m < mx; m++) {
		sb.append(jp[m]+" ");
	}
	 
//	 db(sb);
	 
	
System.out.println(mx);
    System.out.println(sb);
   
}

/*
  static class P implements Comparable<P>{
	int id, d; ;
	P(int id,int d){
		this.id=id;
		this.d=d;
	} 
	
	public int compareTo(P x){
	//	return  (-x.d+d)>=0?1:-1  ; // ascend long
		return   -x.d+d  ; // ascend
	//	 return   x.d-d  ; //descend
	   }
 
}
*/



  

static void db(Object... os){
    System.err.println(Arrays.deepToString(os));

}


}


class SegTree2{

  int dat[][],n,MAX_N=1<<17,IntMax=1<<20;
 
  
  SegTree2(int n){ this.n=1; while(this.n<n)this.n*=2;  dat=new int[MAX_N*2-1][2];    };
  
  void update(int k,int a,int id){ //change element_k to a
	  
	 
	  
	  k+=n-1;
	  dat[k][0]=a;   
	  dat[k][1]=id;  
	  
	  
	  while(0<k){ k=(k-1)/2;  
	 
	  
	     if( dat[2*k+1][0]>dat[k*2+2][0] ){

	    	 dat[k][0]=dat[2*k+1][0];
	    	 dat[k][1]=dat[2*k+1][1];
	    	 
	     }
	     else{
	    	 dat[k][0]=dat[2*k+2][0];
	    	 dat[k][1]=dat[2*k+2][1];
	    	 
	     }
	  
	  }
  }
  
  int[] query(int a,int b, int k, int l,int r){  //find minimum in [a,b)  call by query(a,b,0,0,n(this)!!!!) from local
	  
	  int e[]=new int[2];
	  if( r<=a || b<=l )return e ;
	  else if( a<=l && r<=b ){ e[0]=dat[k][0];e[1]=dat[k][1]; }
	  
	  else{
		  int vl[]=query(a,b,k*2+1,l,(l+r)/2);
		  int vr[]=query(a,b,k*2+2,(l+r)/2,r);
			
		  if( vl[0]<vr[0] ){
			  e[0]=vr[0];
			  e[1]=vr[1];
			  
		  }
		  else { e[0]=vl[0];
		  e[1]=vl[1];
		  }
	  }

	 // Main.db(a,b,k,e,l,r,dat[k]);
	  
	  return e;
	  
   }
  
}




class Reader
{ 
	private BufferedReader x;
	private StringTokenizer st;
	
	public Reader(InputStream in)
	{
		x = new BufferedReader(new InputStreamReader(in));
		st = null;
	}
	public String nextString() throws IOException
	{
		while( st==null || !st.hasMoreTokens() )
			st = new StringTokenizer(x.readLine());
		return st.nextToken();
	}
	public int nextInt() throws IOException
	{
		return Integer.parseInt(nextString());
	}
	public long nextLong() throws IOException
	{
		return Long.parseLong(nextString());
	}
	public double nextDouble() throws IOException
	{
		return Double.parseDouble(nextString());
	}
}