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;
long long modx(long long Base, long long exponent) {
  long long ans = 1;
  if (Base == 1) return Base;
  while (exponent) {
    if (exponent & 1) ans = (ans * Base) % 1000000007LL;
    Base = (Base * Base) % 1000000007LL;
    exponent = exponent >> 1;
  }
  return ans;
}
long long inmodx(long long num) { return (modx(num, 1000000007LL - 2LL)); }
bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
  if (a.first.first / 1100 < b.first.first / 1100) return 1;
  if (a.first.first / 1100 > b.first.first / 1100) return 0;
  if (a.first.second <= b.first.second) return 1;
  return 0;
}
const int N = (3e5) + 9;
const int M = (N << 2) + 9;
const int LOGN = ((int)log2(N)) + 3;
const int LOGM = ((int)log2(M)) + 3;
const int BUCK = 450;
pair<long long, long long> fence[N];
long long sum[N];
long long calc_sum(int l, int r) {
  if (l > r) return 0LL;
  return (sum[r] - sum[l - 1]);
}
int binsea_pre(int l, int r, pair<long long, long long> pt) {
  if (l > r) return 0;
  int mid = (l + r) >> 1;
  if (fence[mid].second * pt.second < pt.first)
    return max(mid, binsea_pre(mid + 1, r, pt));
  return binsea_pre(l, mid - 1, pt);
}
int binsea_suf(int l, int r, pair<long long, long long> pt, int z) {
  if (l > r) return z;
  int mid = (l + r) >> 1;
  if (fence[mid].first * pt.second > pt.first)
    return min(mid, binsea_suf(l, mid - 1, pt, z));
  return binsea_suf(mid + 1, r, pt, z);
}
void solve() {
  int n, i, l, r, q;
  long long s, a, b, x, y;
  pair<long long, long long> pt1, pt2;
  double ans, factor;
  cin >> s >> a >> b;
  cin >> n;
  for (i = (1); i < (n + 1); i++) cin >> fence[i].first >> fence[i].second;
  sort(fence + 1, fence + n + 1);
  for (i = (1); i < (n + 1); i++)
    sum[i] = sum[i - 1] + (fence[i].second - fence[i].first);
  cin >> q;
  while (q--) {
    cin >> x >> y;
    pt1 = make_pair((a * y - x * s), (y - s));
    pt2 = make_pair((b * y - x * s), (y - s));
    factor = ((double)(y - s)) / ((double)y);
    if (pt2.first < fence[1].first * pt2.second)
      ans = 0.0;
    else if (pt1.first > fence[n].second * pt1.second)
      ans = 0.0;
    else {
      l = binsea_pre(1, n, pt1);
      r = binsea_suf(1, n, pt2, n + 1);
      if (r == l + 1)
        ans = 0.0;
      else if (l + 1 == r - 1) {
        ans = 0.0;
        if (fence[l + 1].first * pt1.second > pt1.first)
          ans -= ((double)fence[l + 1].first);
        else
          ans -= (((double)pt1.first) / ((double)pt1.second));
        if (fence[r - 1].second * pt2.second < pt2.first)
          ans += ((double)fence[r - 1].second);
        else
          ans += (((double)pt2.first) / ((double)pt2.second));
      } else {
        ans = 0.0;
        if (fence[l + 1].first * pt1.second <= pt1.first &&
            fence[l + 1].second * pt1.second >= pt1.first)
          ans += (((double)fence[l + 1].second) -
                  (((double)pt1.first) / ((double)pt1.second)));
        else
          ans += ((double)(fence[l + 1].second - fence[l + 1].first));
        if (fence[r - 1].first * pt2.second <= pt2.first &&
            fence[r - 1].second * pt2.second >= pt2.first)
          ans += ((((double)pt2.first) / ((double)pt2.second)) -
                  ((double)fence[r - 1].first));
        else
          ans += ((double)(fence[r - 1].second - fence[r - 1].first));
        ans += ((double)calc_sum(l + 2, r - 2));
      }
    }
    ans *= factor;
    cout << ans << '\n';
  }
  return;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int t = 1, cs;
  cout << fixed << setprecision(9);
  for (cs = (1); cs < (t + 1); cs++) {
    solve();
  }
  return 0;
}