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;
double eps = 1e-7;
bool eq(double a, double b) { return abs(a - b) <= eps; }
struct vec {
  double x, y;
  int id;
  vec(double a = 0, double b = 0) : x(a), y(b) {}
  vec operator+(const vec &o) const { return {x + o.x, y + o.y}; }
  vec operator-(const vec &o) const { return {x - o.x, y - o.y}; }
  vec operator*(double t) const { return {x * t, y * t}; }
  vec operator/(double t) const { return {x / t, y / t}; }
  double operator*(const vec &o) const { return x * o.x + y * o.y; }
  double operator^(const vec &o) const { return x * o.y - y * o.x; }
  bool operator==(const vec &o) const { return eq(x, o.x) && eq(y, o.y); }
  bool operator<(const vec &o) const {
    if (!eq(x, o.x)) return x < o.x;
    return y < o.y;
  }
  double cross(const vec &a, const vec &b) const {
    return (a - (*this)) ^ (b - (*this));
  }
  double dot(const vec &a, const vec &b) const {
    return (a - (*this)) * (b - (*this));
  }
  double len() const { return sqrt(x * x + y * y); }
  double angle(const vec &a, const vec &b) const {
    return atan2(cross(a, b), dot(a, b));
  }
  double tan(const vec &a, const vec &b) const {
    return cross(a, b) / dot(a, b);
  }
  vec unit() const { return operator/(len()); }
  int quad() const {
    if (x > 0 && y >= 0) return 0;
    if (x <= 0 && y > 0) return 1;
    if (x < 0 && y <= 0) return 2;
    return 3;
  }
  bool comp(const vec &a, const vec &b) const {
    return (a - *this).comp(b - *this);
  }
  bool comp(vec b) {
    if (quad() != b.quad()) return quad() < b.quad();
    if (!eq(operator^(b), 0)) return operator^(b) > 0;
    return (*this) * (*this) < b * b;
  }
  template <class T>
  void sort_by_angle(T first, T last) const {
    std::sort(first, last,
              [=](const vec &a, const vec &b) { return comp(a, b); });
  }
  vec rot90() const { return {-y, x}; }
  vec rot(double a) const {
    return {cos(a) * x - sin(a) * y, sin(a) * x + cos(a) * y};
  }
};
struct line {
  double a, b, c;
  vec n;
  line(vec q, vec w) {
    a = -(w.y - q.y);
    b = w.x - q.x;
    c = -(a * q.x + b * q.y);
    n = {a, b};
  }
  double dist(const vec &o) const { return abs(eval(o)) / n.len(); }
  bool contains(const vec &o) const { return eq(a * o.x + b * o.y + c, 0); }
  double dist(const line &o) const {
    if (!parallel(o)) return 0;
    if (!eq(o.a * b, o.b * a)) return 0;
    if (!eq(a, 0)) return abs(c - o.c * a / o.a) / n.len();
    if (!eq(b, 0)) return abs(c - o.c * b / o.b) / n.len();
    return abs(c - o.c);
  }
  bool parallel(const line &o) const { return eq(n ^ o.n, 0); }
  bool operator==(const line &o) const {
    if (!eq(a * o.b, b * o.a)) return false;
    if (!eq(a * o.c, c * o.a)) return false;
    if (!eq(c * o.b, b * o.c)) return false;
    return true;
  }
  bool intersect(const line &o) const { return !parallel(o) || *this == o; }
  vec inter(const line &o) const {
    if (parallel(o)) {
      if (*this == o) {
      } else {
      }
    }
    auto tmp = n ^ o.n;
    return {(o.c * b - c * o.b) / tmp, (o.a * c - a * o.c) / tmp};
  }
  vec at_x(double x) const { return {x, (-c - a * x) / b}; }
  vec at_y(double y) const { return {(-c - b * y) / a, y}; }
  double eval(const vec &o) const { return a * o.x + b * o.y + c; }
};
const int N = 200005;
long long sy, a, b;
int n;
long long l[N], r[N], x[N], y[N];
double ans[N];
int main() {
  scanf("%lld %lld %lld", &sy, &a, &b);
  scanf("%d", &n);
  vector<pair<double, int>> v;
  int st = N, en = N - 1;
  for (int i = 0; i < n; i++) {
    scanf("%lld %lld", l + i, r + i);
    v.emplace_back(l[i], st);
    v.emplace_back(r[i], en);
  }
  int q;
  scanf("%d", &q);
  for (int i = 1; i <= q; i++) {
    scanf("%lld %lld", x + i, y + i);
    double t1, t2;
    t1 = line(vec(x[i], y[i]), vec(a, sy)).at_y(0).x;
    t2 = line(vec(x[i], y[i]), vec(b, sy)).at_y(0).x;
    v.emplace_back(t1, -i);
    v.emplace_back(t2, i);
  }
  sort(v.begin(), v.end());
  double val;
  int t;
  double sum = 0, last = 1e20;
  for (auto tmp : v) {
    tie(val, t) = tmp;
    if (t == st)
      last = val;
    else if (t == en)
      sum += val - last, last = 1e20;
    else {
      if (t < 0) {
        ans[-t] -= sum + max(val - last, 0.0);
      } else {
        ans[t] += sum + max(val - last, 0.0);
      }
    }
  }
  for (int i = 1; i <= q; i++) printf("%.20lf\n", ans[i] * (y[i] - sy) / y[i]);
}