Problem: There is a light source on the plane. This source is so small that it can be represented as point. The light source is moving from point (a, s_y) to the (b, s_y) (s_y < 0) with speed equal to 1 unit per second. The trajectory of this light source is a straight segment connecting these two points. 

There is also a fence on OX axis represented as n segments (l_i, r_i) (so the actual coordinates of endpoints of each segment are (l_i, 0) and (r_i, 0)). The point (x, y) is in the shade if segment connecting (x,y) and the current position of the light source intersects or touches with any segment of the fence.

<image>

You are given q points. For each point calculate total time of this point being in the shade, while the light source is moving from (a, s_y) to the (b, s_y).

Input

First line contains three space separated integers s_y, a and b (-10^9 ≤ s_y < 0, 1 ≤ a < b ≤ 10^9) — corresponding coordinates of the light source.

Second line contains single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — number of segments in the fence.

Next n lines contain two integers per line: l_i and r_i (1 ≤ l_i < r_i ≤ 10^9, r_{i - 1} < l_i) — segments in the fence in increasing order. Segments don't intersect or touch each other.

Next line contains single integer q (1 ≤ q ≤ 2 ⋅ 10^5) — number of points to check.

Next q lines contain two integers per line: x_i and y_i (1 ≤ x_i, y_i ≤ 10^9) — points to process.

Output

Print q lines. The i-th line should contain one real number — total time of the i-th point being in the shade, while the light source is moving from (a, s_y) to the (b, s_y). The answer is considered as correct if its absolute of relative error doesn't exceed 10^{-6}.

Example

Input

-3 1 6
2
2 4
6 7
5
3 1
1 3
6 1
6 4
7 6


Output

5.000000000000000
3.000000000000000
0.000000000000000
1.500000000000000
2.000000000000000

Note

  * The 1-st point is always in the shade; 
  * the 2-nd point is in the shade while light source is moving from (3, -3) to (6, -3); 
  * the 3-rd point is in the shade while light source is at point (6, -3). 
  * the 4-th point is in the shade while light source is moving from (1, -3) to (2.5, -3) and at point (6, -3); 
  * the 5-th point is in the shade while light source is moving from (1, -3) to (2.5, -3) and from (5.5, -3) to (6, -3); 

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
inline int read() {
  int x = 0, f = 1;
  char ch = getchar();
  while (ch < '0' || ch > '9') {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') {
    x = x * 10 + ch - '0';
    ch = getchar();
  }
  return x * f;
}
namespace Mymath {
long long qp(long long x, long long p, long long mod) {
  long long ans = 1;
  while (p) {
    if (p & 1) ans = ans * x % mod;
    x = x * x % mod;
    p >>= 1;
  }
  return ans;
}
long long inv(long long x, long long mod) { return qp(x, mod - 2, mod); }
long long C(long long N, long long K, long long fact[], long long mod) {
  return fact[N] * inv(fact[K], mod) % mod * inv(fact[N - K], mod) % mod;
}
template <typename Tp>
Tp gcd(Tp A, Tp B) {
  if (B == 0) return A;
  return gcd(B, A % B);
}
template <typename Tp>
Tp lcm(Tp A, Tp B) {
  return A * B / gcd(A, B);
}
};  // namespace Mymath
namespace fwt {
using namespace Mymath;
void FWT(int a[], int n, long long mod) {
  for (int d = 1; d < n; d <<= 1)
    for (int m = d << 1, i = 0; i < n; i += m)
      for (int j = 0; j < d; j++) {
        int x = a[i + j], y = a[i + j + d];
        a[i + j] = (x + y) % mod, a[i + j + d] = (x - y + mod) % mod;
      }
}
void UFWT(int a[], int n, long long mod) {
  long long rev = inv(2, mod);
  for (int d = 1; d < n; d <<= 1)
    for (int m = d << 1, i = 0; i < n; i += m)
      for (int j = 0; j < d; j++) {
        int x = a[i + j], y = a[i + j + d];
        a[i + j] = 1LL * (x + y) * rev % mod,
              a[i + j + d] = (1LL * (x - y) * rev % mod + mod) % mod;
      }
}
void solve(int a[], int b[], int n, long long mod) {
  FWT(a, n, mod);
  FWT(b, n, mod);
  for (int i = 0; i < n; i++) a[i] = 1LL * a[i] * b[i] % mod;
  UFWT(a, n, mod);
}
};  // namespace fwt
const int Maxn = 2e5 + 5;
struct P {
  double x, y;
  P(double X, double Y) { x = X, y = Y; }
  P() { x = 0.0, y = 0.0; }
  P operator+(P p) { return P(x + p.x, y + p.y); }
  P operator-(P p) { return P(x - p.x, y - p.y); }
  P operator*(double k) { return P(x * k, y * k); }
};
P sl, sr;
int n;
double l[Maxn], r[Maxn];
double ps[Maxn];
const double eps = 1e-8;
int main() {
  int sy, a, b;
  sy = read();
  a = read();
  b = read();
  sl = P(a, sy);
  sr = P(b, sy);
  n = read();
  vector<pair<double, int> > V;
  for (int i = 1; i <= n; i++) {
    l[i] = (double)read();
    r[i] = (double)read();
    ps[i] = ps[i - 1] + (r[i] - l[i]);
    V.push_back(make_pair(l[i], i));
    V.push_back(make_pair(r[i], -i));
  }
  int q = read();
  while (q--) {
    double x, y;
    x = read();
    y = read();
    P nowA = P(x, y) - sl, nowB = P(x, y) - sr;
    double coA = -sl.y / nowA.y, coB = -sr.y / nowB.y;
    P intA = sl + nowA * coA, intB = sr + nowB * coB;
    double yl = intA.x, yr = intB.x;
    int pos = lower_bound(V.begin(), V.end(), make_pair(yl, 0)) - V.begin();
    if (pos == V.size()) {
      printf("0.0\n");
      continue;
    }
    if (V[pos].first >= yr - eps) {
      if (V[pos].second > 0) {
        printf("0.0\n");
      } else {
        printf("%.10lf\n", (double)b - a);
      }
      continue;
    } else {
      double Tl = yr - yl;
      double As = 0.0;
      int lo = abs(V[pos].second);
      if (V[pos].second < 0) {
        lo++;
        As += V[pos].first - yl;
      }
      int pos2 = upper_bound(V.begin(), V.end(), make_pair(yr, 1000000000)) -
                 V.begin();
      pos2--;
      int hi = abs(V[pos2].second);
      if (V[pos2].second > 0) {
        As += yr - V[pos2].first;
        hi--;
      }
      if (lo <= hi) {
        As += ps[hi] - ps[lo - 1];
      }
      double rem = As;
      rem = rem / Tl * (double)(b - a);
      printf("%.10lf\n", rem);
    }
  }
  return 0;
}