#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using dd = double;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vdd = vector<dd>;
using vpll = vector<pll>;
using vtll = vector<tll>;
using vvll = vector<vll>;
using vvdd = vector<vdd>;
using vvpll = vector<vpll>;
using vvtll = vector<vtll>;
using vvvll = vector<vvll>;
using vvvdd = vector<vvdd>;
using vvvpll = vector<vvpll>;
using vvvtll = vector<vvtll>;
using vvvvll = vector<vvvll>;
using vvvvdd = vector<vvvdd>;
using vvvvpll = vector<vvvpll>;
using vvvvtll = vector<vvvtll>;
constexpr ll INF = 1LL << 60;
constexpr dd EPS = 1e-11;
struct Fast {
  Fast() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(std::numeric_limits<double>::max_digits10);
  }
} fast;
template <class T>
inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T>
inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T>
inline T MaxE(vector<T> &v, ll S, ll E) {
  T m = v[S];
  for (ll i = (S); i <= (E); i++) chmax(m, v[i]);
  return m;
}
template <class T>
inline T MinE(vector<T> &v, ll S, ll E) {
  T m = v[S];
  for (ll i = (S); i <= (E); i++) chmin(m, v[i]);
  return m;
}
template <class T>
inline T MaxE(vector<T> &v, ll N) {
  return MaxE(v, 0, N - 1);
}
template <class T>
inline T MinE(vector<T> &v, ll N) {
  return MinE(v, 0, N - 1);
}
template <class T>
inline T MaxE(vector<T> &v) {
  return MaxE(v, (ll)v.size());
}
template <class T>
inline T MinE(vector<T> &v) {
  return MinE(v, (ll)v.size());
}
template <class T>
inline ll MaxI(vector<T> &v, ll S, ll E) {
  ll m = S;
  for (ll i = (S); i <= (E); i++) {
    if (v[i] > v[m]) m = i;
  }
  return m;
}
template <class T>
inline ll MinI(vector<T> &v, ll S, ll E) {
  ll m = S;
  for (ll i = (S); i <= (E); i++) {
    if (v[i] < v[m]) m = i;
  }
  return m;
}
template <class T>
inline ll MaxI(vector<T> &v, ll N) {
  return MaxI(v, 0, N - 1);
}
template <class T>
inline ll MinI(vector<T> &v, ll N) {
  return MinI(v, 0, N - 1);
}
template <class T>
inline ll MaxI(vector<T> &v) {
  return MaxI(v, (ll)v.size());
}
template <class T>
inline ll MinI(vector<T> &v) {
  return MinI(v, (ll)v.size());
}
template <class T>
inline T Sum(vector<T> &v, ll S, ll E) {
  T s = v[S];
  for (ll i = (S + 1); i <= (E); i++) s += v[i];
  return s;
}
template <class T>
inline T Sum(vector<T> &v, ll N) {
  return Sum(v, 0, N - 1);
}
template <class T>
inline T Sum(vector<T> &v) {
  return Sum(v, v.size());
}
template <class T>
inline ll Size(vector<T> &v) {
  return (ll)v.size();
}
template <class T>
inline T POW(T a, ll n) {
  T r = 1;
  for (; n > 0; n >>= 1, a *= a) {
    if (n & 1) r *= a;
  }
  return r;
}
inline ll POW(int a, ll n) { return POW((ll)a, n); }
inline ll MSB(ll a) {
  for (ll o = 63, x = -1;;) {
    ll m = (o + x) / 2;
    if (a < (1LL << m))
      o = m;
    else
      x = m;
    if (o - x == 1) return x;
  }
}
inline ll CEIL(ll a, ll b) { return (a + b - 1) / b; }
ll Gcd(ll a, ll b) { return (b == 0) ? a : Gcd(b, a % b); }
ll Lcm(ll a, ll b) { return a * b / Gcd(a, b); }
inline vll Bit2Idx(ll m) {
  vll v;
  for (ll i = 0; m; m >>= 1, i++)
    if (m & 1) v.push_back(i);
  return move(v);
}
inline ll BitNum(ll m) {
  for (ll c = 0;; m >>= 1) {
    c += m & 1;
    if (!m) return c;
  }
}
inline ll Bit(ll s, ll i) { return (s >> i) & 1; }
inline ll BitOn(ll s, ll i) { return s | (1LL << i); }
inline ll BitOff(ll s, ll i) { return s & ~(1LL << i); }
template <class T>
inline ll UnderNumOf(vector<T> &v, T x) {
  return upper_bound(v.begin(), v.end(), x) - v.begin();
}
template <class T, class Pr>
inline ll UnderNumOf(vector<T> &v, T x, Pr pred) {
  return upper_bound(v.begin(), v.end(), x, pred) - v.begin();
}
template <class T>
inline ll OverNumOf(vector<T> &v, T x) {
  return (ll)v.size() - (lower_bound(v.begin(), v.end(), x) - v.begin());
}
template <class T, class Pr>
inline ll OverNumOf(vector<T> &v, T x, Pr pred) {
  return (ll)v.size() - (lower_bound(v.begin(), v.end(), x, pred) - v.begin());
}
template <class T = ll>
inline vector<T> cinv(ll N) {
  vector<T> v(N);
  for (ll i = (0); i <= ((N)-1); i++) cin >> v[i];
  return move(v);
}
template <class T = ll, class S = ll>
inline vector<pair<T, S>> cinv2(ll N) {
  vector<pair<T, S>> v(N);
  for (ll i = (0); i <= ((N)-1); i++) {
    cin >> v[i].first >> v[i].second;
  }
  return move(v);
}
template <class T = ll, class S = ll, class R = ll>
inline vector<tuple<T, S, R>> cinv3(ll N) {
  vector<tuple<T, S, R>> v(N);
  for (ll i = (0); i <= ((N)-1); i++) {
    cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]);
  }
  return move(v);
}
template <class T = ll, class S = ll, class R = ll, class Q = ll>
inline vector<tuple<T, S, R, Q>> cinv4(ll N) {
  vector<tuple<T, S, R, Q>> v(N);
  for (ll i = (0); i <= ((N)-1); i++) {
    cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]) >> get<3>(v[i]);
  }
  return move(v);
}
template <class T = ll>
inline vector<vector<T>> cinvv(ll N, ll M) {
  vector<vector<T>> vv(N);
  for (ll i = (0); i <= ((N)-1); i++) vv[i] = cinv(M);
  return move(vv);
}
template <class T>
inline void coutv(vector<T> &v, char deli = ' ') {
  ll N = (ll)v.size();
  for (ll i = (0); i <= ((N)-1); i++) {
    cout << v[i] << ((i == N - 1) ? '\n' : deli);
  }
}
template <class T>
void bye(T a) {
  cout << a << '\n';
  exit(0);
}
template <class T>
void Dump(vector<T> &v) {}
template <class T>
void Dump(vector<vector<T>> &v) {}
template <class T>
void Dump(vector<vector<vector<T>>> &v) {}
template <class T>
void Dump(vector<vector<vector<vector<T>>>> &v) {}
template <class T>
void Dump(vector<vector<vector<vector<vector<T>>>>> &v) {}
struct mll {
  static ll MOD;
  ll val;
  mll(ll v = 0) : val(v % MOD) {
    if (val < 0) val += MOD;
  }
  mll operator-() const { return -val; }
  mll operator+(const mll &b) const { return val + b.val; }
  mll operator-(const mll &b) const { return val - b.val; }
  mll operator*(const mll &b) const { return val * b.val; }
  mll operator/(const mll &b) const { return mll(*this) /= b; }
  mll operator+(ll b) const { return *this + mll(b); }
  mll operator-(ll b) const { return *this - mll(b); }
  mll operator*(ll b) const { return *this * mll(b); }
  friend mll operator+(ll a, const mll &b) { return b + a; }
  friend mll operator-(ll a, const mll &b) { return -b + a; }
  friend mll operator*(ll a, const mll &b) { return b * a; }
  friend mll operator/(ll a, const mll &b) { return mll(a) / b; }
  mll &operator+=(const mll &b) {
    val = (val + b.val) % MOD;
    return *this;
  }
  mll &operator-=(const mll &b) {
    val = (val + MOD - b.val) % MOD;
    return *this;
  }
  mll &operator*=(const mll &b) {
    val = (val * b.val) % MOD;
    return *this;
  }
  mll &operator/=(const mll &b) {
    ll c = b.val, d = MOD, u = 1, v = 0;
    while (d) {
      ll t = c / d;
      c -= t * d;
      swap(c, d);
      u -= t * v;
      swap(u, v);
    }
    val = val * u % MOD;
    if (val < 0) val += MOD;
    return *this;
  }
  mll &operator+=(ll b) { return *this += mll(b); }
  mll &operator-=(ll b) { return *this -= mll(b); }
  mll &operator*=(ll b) { return *this *= mll(b); }
  mll &operator/=(ll b) { return *this /= mll(b); }
  bool operator==(const mll &b) { return val == b.val; }
  bool operator!=(const mll &b) { return val != b.val; }
  bool operator==(ll b) { return *this == mll(b); }
  bool operator!=(ll b) { return *this != mll(b); }
  friend bool operator==(ll a, const mll &b) { return mll(a) == b.val; }
  friend bool operator!=(ll a, const mll &b) { return mll(a) != b.val; }
  friend ostream &operator<<(ostream &os, const mll &a) { return os << a.val; }
  friend istream &operator>>(istream &is, mll &a) { return is >> a.val; }
  static mll Combination(ll a, ll b) {
    chmin(b, a - b);
    if (b < 0) return mll(0);
    mll c = 1;
    for (ll i = (0); i <= ((b)-1); i++) c *= a - i;
    for (ll i = (0); i <= ((b)-1); i++) c /= i + 1;
    return c;
  }
};
ll mll::MOD = 1000000007LL;
using vmll = std::vector<mll>;
using vvmll = std::vector<vmll>;
using vvvmll = std::vector<vvmll>;
using vvvvmll = std::vector<vvvmll>;
using vvvvvmll = std::vector<vvvvmll>;
class Dubling {
 private:
  vvll next;
  ll N;
  ll next_(ll v, ll i) { return (v == INF) ? INF : next[v][i]; }

 public:
  ll B;
  Dubling() : N(0), B(0) {}
  Dubling(const vll &nxt, ll nextTimesMax) { Init(nxt, nextTimesMax); }
  void Init(const vll &nxt, ll nextTimesMax) {
    N = (ll)nxt.size();
    B = MSB(nextTimesMax) + 1;
    next.resize(N, vll(B, INF));
    for (ll v = (0); v <= ((N)-1); v++) next[v][0] = nxt[v];
    for (ll i = (1); i <= (B - 1); i++)
      for (ll v = (0); v <= ((N)-1); v++)
        next[v][i] = next_(next_(v, i - 1), i - 1);
  }
  ll Times(ll v, ll times) {
    for (ll i = (MSB(times)); i >= (0); i--)
      if ((times >> i) & 1) v = next_(v, i);
    return v;
  }
  ll TimesPow2(ll v, ll i) { return next[v][i]; }
};
void solve() {
  ll N;
  cin >> N;
  vector<ll> x = cinv<ll>(N);
  ll L, Q;
  cin >> L >> Q;
  vector<pair<ll, ll>> ab = cinv2<ll, ll>(Q);
  for (auto &&e : ab) {
    e.first--;
    e.second--;
    if (e.first > e.second) {
      swap(e.first, e.second);
    }
  }
  vll p(N);
  ll l = 0, r = 1;
  while (true) {
    bool isInner;
    if (r == N)
      isInner = false;
    else
      isInner = (x[r] - x[l] <= L);
    if (isInner) {
      r++;
    } else {
      p[l] = r - 1;
      l++;
      if (l == N) break;
    }
  }
  p[N - 1] = INF;
  Dubling dbl(p, N + 10);
  for (ll i = (0); i <= (Q - 1); i++) {
    ll a;
    ll b;
    tie(a, b) = ab[i];
    ll dayCount = 0;
    for (ll i = (dbl.B - 1); i >= (0); i--) {
      ll c = dbl.TimesPow2(a, i);
      if (c <= b) {
        a = c;
        dayCount += (1LL << i);
      }
    }
    cout << dayCount << '\n';
  }
}
int main() {
  solve();
  return 0;
}
