Problem:
Score : 800 points

Problem Statement

There are N points on a number line, i-th of which is placed on coordinate X_i.
These points are numbered in the increasing order of coordinates.
In other words, for all i (1 \leq i \leq N-1), X_i < X_{i+1} holds.
In addition to that, an integer K is given.

Process Q queries.

In the i-th query, two integers L_i and R_i are given.
Here, a set s of points is said to be a good set if it satisfies all of the following conditions.
Note that the definition of good sets varies over queries.

Each point in s is one of X_{L_i},X_{L_i+1},\ldots,X_{R_i}.

For any two distinct points in s, the distance between them is greater than or equal to K.

The size of s is maximum among all sets that satisfy the aforementioned conditions.

For each query, find the size of the union of all good sets.

Constraints

1 \leq N \leq 2 \times 10^5

1 \leq K \leq 10^9

0 \leq X_1 < X_2 < \cdots < X_N \leq 10^9

1 \leq Q \leq 2 \times 10^5

1 \leq L_i \leq R_i \leq N

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K
X_1 X_2 \cdots X_N
Q
L_1 R_1
L_2 R_2
\vdots
L_Q R_Q

Output

For each query, print the size of the union of all good sets in a line.

Sample Input 1

5 3
1 2 4 7 8
2
1 5
1 2

Sample Output 1

4
2

In the first query, you can have at most 3 points in a good set.
There exist two good sets: \{1,4,7\} and \{1,4,8\}.
Therefore, the size of the union of all good sets is |\{1,4,7,8\}|=4.

In the second query, you can have at most 1 point in a good set.
There exist two good sets: \{1\} and \{2\}.
Therefore, the size of the union of all good sets is |\{1,2\}|=2.

Sample Input 2

15 220492538
4452279 12864090 23146757 31318558 133073771 141315707 263239555 350278176 401243954 418305779 450172439 560311491 625900495 626194585 891960194
5
6 14
1 8
1 13
7 12
4 12

Sample Output 2

4
6
11
2
3

Solution in Rust (1.42.0) (judge verdict: Accepted)

use proconio::marker::*;
use proconio::*;
use std::cmp::*;
use std::collections::*;
use std::ops::Bound::*;

// 左から貪欲に取っていけばサイズは分かる
// ダブリングでよい集合のサイズがlogで分かる
// Kは固定
// ダブリングじゃなくてセグ木でも可能 -> 嘘
//
// 和集合のサイズ?
// Q=1なら各要素の直近の右、左で最大サイズ作れるかで含まれるかが分かる
// 毎回これするのは無理
// 極大...というとアレだが各点から貪欲に構成した良い集合のサイズは最大か最大-1
// うーん
//
// 左から貪欲した点、右から貪欲した点で適切な範囲の点が答え
// ダブリングに和を持たせる？

#[fastout]
fn run() {
    input! {
        n: usize,
        k: i64,
        mut x: [i64; n],
        q: usize,
        ask: [(usize, usize); q],
    }
    let inf = 10i64.pow(10);
    x.insert(0, -inf);
    x.push(inf);
    let x = x;
    let mut right = vec![(n + 1, n + 1); n + 2];
    {
        let mut r = 0;
        for i in 1..=n {
            while x[r] - x[i] < k {
                r += 1;
            }
            right[i] = (r, i);
        }
//        println!("{:?}", right);
    }
    let mut left = vec![(0, 0); n + 2];
    {
        let mut l = n + 1;
        for i in (1..=n).rev() {
            while x[i] - x[l] < k {
                l -= 1;
            }
            left[i] = (l, i);
        }
//        println!("{:?}", left);
    }
    let mut memo_r = vec![];
    while right.iter().any(|p| p.0 < n + 1) {
        let mut next = right.clone();
        for (next, &(a, b)) in next.iter_mut().zip(right.iter()) {
            let (x, y) = right[a];
            *next = (x, y + b);
        }
        memo_r.push(right);
        right = next;
    }
    memo_r.push(right);
    let right = memo_r;
    let mut memo_l = vec![];
    while left.iter().any(|p| p.0 > 0) {
        let mut next = left.clone();
        for (next, &(a, b)) in next.iter_mut().zip(left.iter()) {
            let (x, y) = left[a];
            *next = (x, y + b);
        }
        memo_l.push(left);
        left = next;
    }
    memo_l.push(left);
    let left = memo_l;
    for (l, r) in ask {
        let mut cnt = 0;
        let mut sum = 0;
        let mut pos = r;
        for (i, x) in left.iter().enumerate().rev() {
            if x[pos].0 >= l {
                cnt += 1 << i;
                sum += x[pos].1;
                pos = x[pos].0;
            }
        }
        while left[0][pos].0 >= l {
            cnt += 1;
            sum += left[0][pos].1;
            pos = left[0][pos].0;
        }
        sum += pos;
        cnt += 1;
        let mut pos = l;
        for (i, x) in right.iter().enumerate().rev() {
            if x[pos].0 <= r {
                sum -= x[pos].1;
                pos = x[pos].0;
            }
        }
        while right[0][pos].0 <= r {
            sum -= right[0][pos].1;
            pos = right[0][pos].0;
        }
        sum -= pos;
        let ans = sum + cnt;
        println!("{}", ans);
        //        println!("{} {} {}", sum, cnt, ans);
    }
}

fn main() {
    run();
}