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.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class R271D2E {
    static class Data{
        int index;
        int length;
        public Data(int index, int length){
            this.index = index;
            this.length = length;
        }
    }
    static class BinaryIndexedTree{
        private Data[] bit;
        public BinaryIndexedTree(int size){
            bit = new Data[size];
        }

        /**
         * @param index
         * @return sum from 0 -> index
         */
        public Data query(int index){
            index++;
            Data ret = null;
            while(index>0){
                if(bit[index-1]!=null && (ret==null || ret.length<bit[index-1].length)) ret=bit[index-1];
                index -= index&-index;
            }
            return ret;
        }
        public void update(int index, Data data){
            index++;
            while(index<=bit.length){
                if(bit[index-1]==null || bit[index-1].length<data.length) bit[index-1]=data;
                index += index&-index;
            }
        }
    }

    static int findIncreasingIndex(long key, long[] a){
        int l=0, r=a.length-1;
        while(l<r){
            int mid = (r-l+1)/2+l;
            if(a[mid]<=key) l=mid; else r=mid-1;
        }
        if(a[l]<=key) return l; else return -1;
    }
    static int findDecreasingIndex(long key, long[] a){
        int l=0, r=a.length-1;
        while(l<r){
            int mid = (r-l)/2+l;
            if(a[mid]>=key) r=mid; else l=mid+1;
        }
        if(a[l]>=key) return a.length-1-l; else return -1;
    }
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int d = Integer.parseInt(st.nextToken());
        long[] h = new long[n];
        long[] sortedH = new long[n];
        st = new StringTokenizer(br.readLine());
        for(int i=0; i<n; i++){
            h[i] = Long.parseLong(st.nextToken());
            sortedH[i] = h[i];
        }
        Arrays.sort(sortedH);
        BinaryIndexedTree increasingBit = new BinaryIndexedTree(n);
        BinaryIndexedTree decreasingBit = new BinaryIndexedTree(n);
        Data maxData = new Data(0, 1);
        int[] tracking = new int[n];
        for(int i=0; i<n; i++){
            int increasingIndex = findIncreasingIndex(h[i] - d, sortedH);
            int decreasingIndex = findDecreasingIndex(h[i] + d, sortedH);
            Data curData = new Data(i, 1);
            Data data;
            int prev=-1;
            if(increasingIndex>=0 && (data=increasingBit.query(increasingIndex))!=null){
                curData = new Data(i, data.length+1);
                prev=data.index;
            }
            if(decreasingIndex>=0 && (data=decreasingBit.query(decreasingIndex))!=null && data.length+1>curData.length){
                curData = new Data(i, data.length+1);
                prev=data.index;
            }
            increasingIndex = findIncreasingIndex(h[i], sortedH);
            increasingBit.update(increasingIndex, curData);
            decreasingIndex = findDecreasingIndex(h[i], sortedH);
            decreasingBit.update(decreasingIndex, curData);
            tracking[i]=prev;
            if(maxData.length<curData.length) maxData = curData;
        }
        System.out.println(maxData.length);
        int cursor = maxData.index;
        int[] indices = new int[maxData.length];
        int i=-1;
        while(cursor!=-1){
            indices[++i]=cursor;
            cursor=tracking[cursor];
        }
        while(i>=0){
            if(i==0) System.out.println(indices[i]+1); else System.out.print((indices[i]+1)+" ");
            i--;
        }
    }
}
