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;
const double E = 1e-5;
const int N = 2e5 + 100;
struct P {
  double x, y;
} lb[N], rb[N];
pair<P, int> pt[N];
int ls[N], rs[N], sum[N];
int sy, a, b, n, q;
double ans[N];
P operator*(P a, double k) { return {a.x * k, a.y * k}; }
double operator/(P a, P b) { return a.x * b.y - a.y * b.x; }
P operator-(P a, P b) { return {a.x - b.x, a.y - b.y}; }
P operator+(P a, P b) { return {a.x + b.x, a.y + b.y}; }
void f(P z, int b[N]) {
  for (int i = 0; i < q; i++) {
    pt[i].first = pt[i].first - z;
  }
  for (int i = 0; i < n; i++) {
    lb[i] = lb[i] - z;
    rb[i] = rb[i] - z;
  }
  sort(pt, pt + q,
       [](pair<P, int> a, pair<P, int> b) { return a.first / b.first < 0; });
  int i = 0, j = 0;
  while (i < q && pt[i].first / lb[0] < 0) b[pt[i++].second] = -1;
  for (; i < q; j = j < n ? j + 1 : n) {
    while (i < q && j == n || pt[i].first / rb[j] < 0) {
      b[pt[i].second] = j;
      i++;
    }
  }
  for (int i = 0; i < q; i++) {
    pt[i].first = pt[i].first + z;
  }
  for (int i = 0; i < n; i++) {
    lb[i] = lb[i] + z;
    rb[i] = rb[i] + z;
  }
}
bool inter(P a, P b, P x, P y) {
  a = a - b;
  x = x - b;
  y = y - b;
  return (a / x) * (a / y) <= 0;
}
int main() {
  scanf("%d%d%d%d", &sy, &a, &b, &n);
  for (int i = 0; i < n; i++) {
    int l, r;
    scanf("%d%d", &l, &r);
    lb[i] = {(double)l, 0};
    rb[i] = {(double)r, 0};
    sum[i + 1] = sum[i] + r - l;
  }
  scanf("%d", &q);
  for (int i = 0; i < q; i++) {
    double x, y;
    scanf("%lf%lf", &x, &y);
    pt[i] = {{x, y}, i};
  }
  P sa = {(double)a, (double)sy}, sb = {(double)b, (double)sy};
  f(sa, ls);
  f(sb, rs);
  for (int i = 0; i < q; i++) {
    int j = pt[i].second;
    if (ls[j] != -1 && !inter(pt[i].first, sa, lb[ls[j]], rb[ls[j]])) ls[j]--;
    if (ls[j] > rs[j]) {
      ans[j] = 0;
    } else {
      bool lt = ls[j] != -1 && inter(pt[i].first, sa, lb[ls[j]], rb[ls[j]]),
           rt = rs[j] < n && inter(pt[i].first, sb, lb[rs[j]], rb[rs[j]]);
      if (lt && rt && ls[j] == rs[j]) {
        ans[j] = b - a;
      } else {
        double h = pt[i].first.y, H = abs(sy) + pt[i].first.y, k = H / h;
        if (ls[j] != rs[j])
          ans[j] += (sum[rs[j]] - sum[ls[j] + 1]) * pt[i].first.y * k * k / H;
        if (lt) {
          auto t = ((rb[ls[j]] - pt[i].first) * k) + pt[i].first;
          ans[j] += t.x - a;
        }
        if (rt) {
          auto t = (lb[rs[j]] - pt[i].first) * k + pt[i].first;
          ans[j] += b - t.x;
        }
      }
    }
  }
  for (int i = 0; i < q; i++) {
    printf("%.10f\n", ans[i]);
  }
  return 0;
}