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.io.*;
import java.util.*;

public class Main {
	
	static long array[];
	static int n,d;
	static int previous[];
	static TreeSet<node> makeItSmall;
	static TreeSet<node> makeItBig;
	
	public static void main(String[] args) {
	
		MyScanner sc = new MyScanner();
		n = sc.nextInt();
		d = sc.nextInt();
		
		array = new long[n];
		previous = new int[n];
		
		for(int i = 0 ; i < n ; ++ i)
			{
			array[i] = sc.nextLong();
			previous[i] = -1 ; 
			}
		
		makeItSmall = new TreeSet<node>();
		makeItBig = new TreeSet<node>();
		
		makeItSmall.add( new node(0,-1,Long.MIN_VALUE));
		makeItBig.add( new node(0,-1,Long.MAX_VALUE));
		
		
		//System.out.println( makeItSmall);
		//System.out.println( makeItBig);
		
		
		for( int i = 0 ; i < n ; ++i )
			{
			checkOut( i );
			
		/*	System.out.println("After adding : " + array[i] + " @ " + i);
			System.out.println( makeItSmall);
			System.out.println( makeItBig);
			System.out.println();
		*/	
			}
		
		int index =  0 ;
		int length = 0 ; 
		
		node smallTemp = makeItSmall.last();
		node bigTemp = makeItBig.first();
		index = smallTemp.length > bigTemp.length?smallTemp.lastIndex:bigTemp.lastIndex;
		length = smallTemp.length > bigTemp.length?smallTemp.length:bigTemp.length;
		
		System.out.println( length );
		
		ArrayList<Integer> ans = new ArrayList<Integer>();
		
		while( index != -1 )
		{
			ans.add( index +1 );
			index = previous[index];
		}
	
		for( int i = ans.size() - 1 ; i >= 0 ; --i )
			System.out.print( ans.get(i) + " " );

		/*	for( int i : previous )
		System.out.print( i + " " );
		System.out.println();
		System.out.println( makeItSmall);
		System.out.println( makeItBig);
	*/	
	}


	static void checkOut( int index )
	{
		
	// take out from small
	// take out from big

		long height = array[index];
		
		node smallTemp = makeItSmall.floor( new node(0,0,height - d) );
		node bigTemp = makeItBig.ceiling(new node(0,0,height+d));
		
		
		// smallTemp inserted in big
		// bigTemp inserted in small
		
		previous[index] = (smallTemp.length > bigTemp.length) ? smallTemp.lastIndex : bigTemp.lastIndex;
		
		node smallToBeInserted = new node( bigTemp.length +1 , index , array[index]);
		addToSmall( smallToBeInserted);
		addToBig( smallToBeInserted);
		
		node bigToBeInserted = new node( smallTemp.length + 1 , index , array[index]);
		addToBig( bigToBeInserted);
		addToSmall(bigToBeInserted);
		
	}
	
	
	static void addToSmall( node smallToBeInserted )
	{
		node smallToBeDeleted;
		
		while( ( smallToBeDeleted =  makeItSmall.ceiling(smallToBeInserted) ) != null &&
				smallToBeDeleted.length <= smallToBeInserted.length )
		{
			makeItSmall.remove(smallToBeDeleted);
		}
		
		if( ( smallToBeDeleted =  makeItSmall.floor(smallToBeInserted) ) == null ||
				smallToBeDeleted.length < smallToBeInserted.length )
			makeItSmall.add( smallToBeInserted);
		
	}
	
	static void addToBig( node bigToBeInserted )
	{
		node bigToBeDeleted;
		
		while(  (bigToBeDeleted = makeItBig.floor(bigToBeInserted)) != null &&
				bigToBeDeleted.length <= bigToBeInserted.length )
		{
			//System.out.println( " XXX " + bigToBeDeleted + " gonna be deleted ");
			makeItBig.remove(bigToBeDeleted);
		}
	
		if( (bigToBeDeleted = makeItBig.ceiling(bigToBeInserted)) == null ||
				bigToBeInserted.length > bigToBeDeleted.length )
		makeItBig.add(bigToBeInserted);
		
	}
	
	
	static class node implements Comparable<node>
	{
		int length ;
		int lastIndex;
		long height ; 
		
		public node( int l , int i , long h )
		{
			length = l ; 
			lastIndex = i ; 
			height = h ; 
		}
		
		public int compareTo( node o )
		{
			if( height < o.height ) return -1;
			else if( height > o.height ) return +1;
			else return 0 ; 
			
		}
		
		public String toString()
		{
			return ( "(" + length + ":" + height + ")" );
		}


		
	}

	static class MyScanner {
	      BufferedReader br;
	      StringTokenizer st;
	 
	      public MyScanner() {
	         br = new BufferedReader(new InputStreamReader(System.in),8*1024);
	      }
	 
	      String next() {
	          while (st == null || !st.hasMoreElements()) {
	              try {
	                  st = new StringTokenizer(br.readLine());
	              } catch (IOException e) {
	                  e.printStackTrace();
	              }
	          }
	          return st.nextToken();
	      }
	 
	      int nextInt() {
	          return Integer.parseInt(next());
	      }
	 
	      long nextLong() {
	          return Long.parseLong(next());
	      }
	 
	      double nextDouble() {
	          return Double.parseDouble(next());
	      }
	 
	      String nextLine(){
	          String str = "";
		  try {
		     str = br.readLine();
		  } catch (IOException e) {
		     e.printStackTrace();
		  }
		  return str;
	      }

	   }

	static class MyWriter {
	    BufferedWriter bw;

	    public  MyWriter() {
	       bw = new BufferedWriter(new OutputStreamWriter(System.out),8*1024);
	    }

	    void print(String s)
	    {
	    	try {
					bw.write( s , 0 , s.length() );
					
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
	    }
	    
	    void println(String s)
	    {
	    	try {
				bw.write( s , 0 , s.length() );
				bw.newLine();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	    }

	 void close()
	 {
		 try {
			bw.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	 }
	}
	
	
}