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 static java.util.Arrays.* ;
import static java.lang.Math.* ;

import java.util.*;
import java.io.*;

public class E {
    StringBuilder sb = new StringBuilder() ;
    int [] parent ;
    void print (int p)
    {
        if(p == -1) return;
        print(parent[p]);
        sb.append(p).append(' ') ;
    }
    void main() throws Exception {
        Scanner sc = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int n = sc.nextInt()  ,  d = sc.nextInt();
        parent = new int [n + 1] ;
        fill(parent , -1);
        int MAX = 0 ;
        int start = 0 ;
        long [] h = new long [n] ;
        Compressor compressor = new Compressor() ;
        for(int i = 0 ; i < n ; i++) {
            h[i] = sc.nextLong() ;
            compressor.add(h[i]);
            if(h[i] - d >= 0) compressor.add(h[i] - d);
            compressor.add(h[i] + d);
        }
        compressor.fix();
        int SIZE = compressor.set.size() ;
        SegmentTree st = new SegmentTree(SIZE) ;
        for(int i = 0 ; i < n ; i++)
        {
            int[] left = null ;
            int [] right = st.query(compressor.get(h[i] + d) , SIZE);
            if(h[i] - d >= 0) left = st.query(1 , compressor.get(h[i] - d)) ;
            int[] ans = left != null && left[1] > right[1] ? left : right ;
            st.update_point(compressor.get(h[i]) , new int []{i + 1, ans[1] + 1});
            parent[i + 1] = ans[0] ;
            if(ans[1] + 1 > MAX)
            {
                MAX = ans[1] + 1 ;
                start = i + 1 ;
            }
        }
        out.println(MAX);
        print(start);
        out.print(sb);
        out.flush();
    }

    class Compressor
    {
        TreeSet<Long> set = new TreeSet<>() ;
        HashMap<Long , Integer> map = new HashMap<>() ;

        void add(long x) {set.add(x);}

        void fix() {for(long x : set) map.put(x, map.size() + 1) ;}

        int get(long x) {return map.get(x) ;}
    }

    class SegmentTree {

        int N;
        int [][] sTree;

        SegmentTree(int n) {
            N = 1 << (32 - Integer.numberOfLeadingZeros(n - 1)) ;
            sTree = new int [2][N << 1] ;
            for(int i = 0 ; i < N << 1  ; i++)
            {
                sTree[0][i] = -1 ;
                sTree[1][i] = 0 ;
            }
        }

        void update_point(int index, int [] val) {
            index += N - 1;
            sTree[0][index] = val[0];
            sTree[1][index] = val[1];

            while(index>1) {
                index >>= 1;
                if(sTree[1][index << 1] > sTree[1][index << 1 | 1]) {
                    sTree[0][index] = sTree[0][index << 1] ;
                    sTree[1][index] = sTree[1][index << 1] ;

                }
                else{
                    sTree[0][index] = sTree[0][index << 1 | 1] ;
                    sTree[1][index] = sTree[1][index << 1 | 1] ;
                }
            }
        }

        int [] query(int i, int j)
        {
            return query(1,1,N,i,j);
        }

        int [] query(int node, int b, int e, int i, int j) {
            if(i >e || j <b) return new int [] {-1 , 0};
            if(b >= i && e <= j) return new int [] {sTree[0][node] , sTree[1][node] };
            int mid = b + e >> 1;
            int [] l = query(node<<1,b,mid,i,j) ;
            int [] r = query(node<<1|1,mid+1,e,i,j) ;
            if(l[1] > r[1])
                return l ;
            return r ;
        }
    }
    class Scanner
    {
        BufferedReader br;
        StringTokenizer st;

        Scanner(InputStream in)
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() throws Exception
        {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        int nextInt() throws Exception { return Integer.parseInt(next()); }

        long nextLong() throws Exception { return Long.parseLong(next()); }

        double nextDouble() throws Exception { return Double.parseDouble(next());}
    }

    public static void main (String [] args) throws Exception {(new E()).main();}

}