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

public class Main
{
    private static HashMap<Long, Integer> map;
    private static long[] revMap;

    public static void main(String[] args) throws IOException
    {
        Scanner scan = new Scanner(System.in);

        int n = scan.nextInt();
        long d = scan.nextInt();

        long[] heights = new long[n];
        for(int i = 0;i < n;i++)
            heights[i] = scan.nextLong();

        int[] map = map(heights);
        Node[] nodes = new Node[map.length];
        Node root = makeNode(0, map.length-1, null, nodes);
        Value res = new Value(0, 0, null);

        int[] prev = new int[n];
        int[] next = new int[n];
        for(int i = 0;i < n;i++)
        {
            prev[i] = atMost(heights[i]-d);
            next[i] = atLeast(heights[i]+d);
        }

        for(int i = 0;i < n;i++)
        {
            Value best = new Value(1, i, null);
            int cur = 1;

            if(prev[i] != -1)
            {
                Value value = root.max(0, prev[i]);
                if(value.cnt+1 > cur)
                {
                    cur = value.cnt+1;
                    best = new Value(cur, i, value);
                }
            }

            if(next[i] != Main.map.size())
            {
                Value value = root.max(next[i], map.length-1);
                if(value.cnt+1 > cur)
                {
                    cur = value.cnt+1;
                    best = new Value(cur, i, value);
                }
            }

            if(best.cnt > res.cnt)
                res = best;
            nodes[map[i]].update(best);
        }

        System.out.println(res.cnt);
        Stack<Integer> stack = new Stack<Integer>();
        while(res != null)
        {
            stack.push(res.idx+1);
            res = res.prev;
        }

        boolean first = true;
        PrintWriter writer = new PrintWriter(System.out);
        while(!stack.isEmpty())
        {
            if(!first)
                writer.print(" ");
            first = false;
            writer.print(stack.pop());
        }
        writer.println();
        writer.flush();
    }

    private static int atLeast(long val)
    {
        int left = -1, right = revMap.length;

        while(right-left > 1)
        {
            int mid = (left+right)/2;

            if(revMap[mid] >= val)
                right = mid;
            else
                left = mid;
        }

        return right;
    }

    private static int atMost(long val)
    {
        int left = -1, right = revMap.length;

        while(right-left > 1)
        {
            int mid = (left+right)/2;

            if(revMap[mid] <= val)
                left = mid;
            else
                right = mid;
        }

        return left;
    }

    private static Node makeNode(int from, int to, Node parent, Node[] nodes)
    {
        Node res = new Node(from, to, parent);

        if(from != to)
        {
            res.left = makeNode(from, (from+to)/2, res, nodes);
            res.right = makeNode((from+to)/2+1, to, res, nodes);
        }
        else
            nodes[from] = res;

        return res;
    }

    private static int[] map(long[] heights)
    {
        long[] numbers = heights.clone();
        Arrays.sort(numbers);

        map = new HashMap<Long, Integer>();
        int idx = 0;
        for(long i : numbers)
            if(!map.containsKey(i))
                map.put(i, idx++);

        int[] res = new int[heights.length];
        for(int i = 0;i < res.length;i++)
            res[i] = map.get(heights[i]);

        revMap = new long[idx];
        for(long i : map.keySet())
            revMap[map.get(i)] = i;

        return res;
    }

    static class Node
    {
        Node left;
        Node right;
        Node parent;
        int from;
        int to;
        Value value;

        public Node(int from, int to, Node parent)
        {
            this.from = from;
            this.to = to;
            this.parent = parent;

            value = new Value(0, from, null);
        }

        public Value max(int x, int y)
        {
            if(x <= from && y >= to)
                return value;
            else if(x > to || y < from)
                return new Value(-1, -1, null);
            else
            {
                Value v1 = left.max(x, y);
                Value v2 = right.max(x, y);
                if(v1.cnt >= v2.cnt)
                    return v1;
                else
                    return v2;
            }
        }

        public void update(Value value)
        {
            if(value.cnt > this.value.cnt)
            {
                this.value = value;
                if(parent != null)
                    parent.update(value);
            }
        }
    }

    static class Value
    {
        int cnt;
        int idx;
        Value prev;

        public Value(int cnt, int idx, Value prev)
        {
            this.cnt = cnt;
            this.idx = idx;
            this.prev = prev;
        }
    }
}