import std.stdio, std.string, std.conv, std.range;
import std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, std.random, core.bitop;

enum inf = 1_001_001_001;
enum infl = 1_001_001_001_001_001_001L;


void main() {
    int N;
    scan(N);
    auto x = readln.split.to!(int[]);
    int L, Q;
    scan(L);
    scan(Q);

    auto dp = new int[][](N, 20);
    int r = N - 1;
    foreach_reverse (i ; 0 .. N) {
        while (x[r] - x[i] > L) {
            r--;
        }
        assert(r >= i);
        dp[i][0] = r;
    }
    foreach (j ; 1 .. 20) {
        foreach (i ; 0 .. N) {
            dp[i][j] = dp[dp[i][j - 1]][j - 1];
        }
    }

    debug {
        writefln("%(%s\n%)", dp);
    }

    foreach (_ ; 0 .. Q) {
        int a, b;
        scan(a, b);
        a--, b--;
        if (a > b) swap(a, b);
        int ans;
        foreach_reverse (i ; 0 .. 20) {
            if (a == b) break;
            if (dp[a][i] < b) {
                a = dp[a][i];
                ans += 1 << i;
            }
        }
        assert(a <= b);
        if (a < b) ans++;
        writeln(ans);
    }
}



void scan(T...)(ref T args) {
    auto line = readln.split;
    foreach (ref arg; args) {
        arg = line.front.to!(typeof(arg));
        line.popFront;
    }
    assert(line.empty);
}

void fillAll(R, T)(ref R arr, T value) {
    static if (is(typeof(arr[] = value))) {
        arr[] = value;
    }
    else {
        foreach (ref e; arr) {
            fillAll(e, value);
        }
    }
}

bool chmin(T, U...)(ref T x, U args) {
    bool isChanged;
    foreach (arg; args) if (x > arg) {
        x = arg;
        isChanged = true;
    }
    return isChanged;
}

bool chmax(T, U...)(ref T x, U args) {
    bool isChanged;
    foreach (arg; args) if (x < arg) {
        x = arg;
        isChanged = true;
    }
    return isChanged;
}

void yes(bool ok, string y = "Yes", string n = "No") {
    return writeln(ok ? y : n);
}
