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:
import java.io.*;
import java.util.*;

public class A {

	static int S, a, b, L[], R[];

	static int[] prefix;

	static int relevant(int x, int y, int segIdx) {
		double left = getX(L[segIdx], x, y);
		double right = getX(R[segIdx], x, y);
		return !(right < a || left > b) ? 0 : left > b ? 1 : -1;

	}

	static double getX(int seg, int x, int y) {
		return (seg * 1L * (y - S) + S * 1L * x) * 1.0 / y;
	}

	static double processRange(int l, int r, int y) {
		if (l > r)
			return 0;
		double ans = prefix[r];
		if (l > 0)
			ans -= prefix[l - 1];
		return ans * (y - S) / y;

	}

	static double process(int x, int y, int segIdx) {
		double left = getX(L[segIdx], x, y);
		double right = getX(R[segIdx], x, y);
		return Math.min(right, b) - Math.max(left, a);

	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner();
		PrintWriter out = new PrintWriter(System.out);
		S = sc.nextInt();
		a = sc.nextInt();
		b = sc.nextInt();
		int n = sc.nextInt();
		L = new int[n];
		R = new int[n];
		for (int i = 0; i < n; i++) {
			L[i] = sc.nextInt();
			R[i] = sc.nextInt();

		}
		prefix = new int[n];
		for (int i = 0; i < n; i++) {
			prefix[i] = R[i] - L[i];
			if (i > 0)
				prefix[i] += prefix[i - 1];
		}
		int q = sc.nextInt();
		while (q-- > 0) {
			int x = sc.nextInt(), y = sc.nextInt();
			int lo = 0, hi = n - 1, first = -1;
			while (lo <= hi) {
				int mid = lo + hi >> 1;
				int k = relevant(x, y, mid);
				if (k == 0) {
					first = mid;
					hi = mid - 1;
				} else if (k == 1) {
					hi = mid - 1;
				} else
					lo = mid + 1;
			}
			if (first == -1) {
				out.println(0);
				continue;
			}
			int last = -1;
			lo = 0;
			hi = n - 1;
			while (lo <= hi) {
				int mid = lo + hi >> 1;
				int k = relevant(x, y, mid);
				if (k == 0) {
					last = mid;
					lo = mid + 1;
				} else if (k == 1) {
					hi = mid - 1;
				} else
					lo = mid + 1;
			}
			double ans = process(x, y, first);
			if (first != last)
				ans += process(x, y, last);
			ans += processRange(first + 1, last - 1, y);
			out.println(ans);

		}
		out.close();

	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		Scanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		Scanner(String fileName) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(fileName));
		}

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

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

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

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

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

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

	}

	static void sort(int[] a) {
		shuffle(a);
		Arrays.sort(a);
	}

	static void shuffle(int[] a) {
		int n = a.length;
		Random rand = new Random();
		for (int i = 0; i < n; i++) {
			int tmpIdx = rand.nextInt(n);
			int tmp = a[i];
			a[i] = a[tmpIdx];
			a[tmpIdx] = tmp;
		}
	}

}