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 JAVA):

Solution:
//package com.company;

import java.io.*;
import java.util.*;

public class Main {
    static long TIME_START, TIME_END;

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
//        Scanner sc = new Scanner(new FileInputStream("Test.in"));
        PrintWriter pw = new PrintWriter(System.out);
//        PrintWriter pw = new PrintWriter(new FileOutputStream("Test.out"));

        Runtime runtime = Runtime.getRuntime();
        long usedMemoryBefore = runtime.totalMemory() - runtime.freeMemory();
        TIME_START = System.currentTimeMillis();
        Task t = new Task();
        t.solve(sc, pw);
        TIME_END = System.currentTimeMillis();
        long usedMemoryAfter = runtime.totalMemory() - runtime.freeMemory();
        pw.close();
        System.out.println("Memory increased:" + (usedMemoryAfter - usedMemoryBefore) / 1000000);
        System.out.println("Time used: " + (TIME_END - TIME_START) + ".");
    }

    public static class Task {

        // y1 < 0, y2 > 0
        public double getIntersection(long x1, long y1, long x2, long y2) {
            return (double) (x1 * y2 - x2 * y1) / (y2 - y1);
        }

        public void solve(Scanner sc, PrintWriter pw) throws IOException {
            long sy = sc.nextInt();
            long a = sc.nextInt();
            long b = sc.nextInt();
            int n = sc.nextInt();
            double[] l = new double[n + 2], r = new double[n + 2];
            l[0] = -10000;
            r[0] = -10000;
            for (int i = 0; i < n; i++) {
                l[i + 1] = sc.nextInt();
                r[i + 1] = sc.nextInt();
            }
            l[n + 1] = Long.MAX_VALUE;
            r[n + 1] = Long.MAX_VALUE;
            double[] lengthPrifix = new double[n + 1];
            lengthPrifix[0] = 0;
            for (int i = 1; i <= n; i++) {
                lengthPrifix[i] = lengthPrifix[i - 1] + r[i] - l[i];
            }
            int q = sc.nextInt();
            for (int i = 0; i < q; i++) {
                long x = sc.nextInt();
                long y = sc.nextInt();
                double length = 0.0;
                double left = getIntersection(a, sy, x, y);
                double right = getIntersection(b, sy, x, y);
                int leftIdx = Arrays.binarySearch(l, left);
                if (leftIdx < 0) leftIdx = -leftIdx - 2;
                if (l[leftIdx] <= left && left <= r[leftIdx]) {
                    length += r[leftIdx] - left;
                }
                int rightIdx = Arrays.binarySearch(r,  right);
                if (rightIdx < 0) rightIdx = -rightIdx - 1;
                if (l[rightIdx] <= right && right <= r[rightIdx]) {
                    length += right - l[rightIdx];
                }
                if (leftIdx == n + 1 || rightIdx == 0 || rightIdx < leftIdx || l[leftIdx] > left || r[rightIdx] < right) {
                    throw new RuntimeException("" + leftIdx + " " + rightIdx + " " + l[leftIdx] + " " + r[rightIdx]);
                }
                length += lengthPrifix[rightIdx - 1] - lengthPrifix[leftIdx];
                pw.println(length * (y - sy) / y);
            }
//            int[] arr = new int[]{1, 3, 5};
//            pw.println(Arrays.binarySearch(arr,0)); // -1
//            pw.println(Arrays.binarySearch(arr, 2)); // -2
//            pw.println(Arrays.binarySearch(arr, 1)); // 0
//            pw.println(Arrays.binarySearch(arr,5)); // 2
//            pw.println(Arrays.binarySearch(arr, 6)); // -4
        }
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public Scanner(FileReader s) throws FileNotFoundException {
            br = new BufferedReader(s);
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public String nextLine() throws IOException {
            return br.readLine();
        }

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public boolean ready() throws IOException {
            return br.ready();
        }
    }
}