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.awt.List;
import java.awt.Polygon;
import java.awt.geom.Area;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.function.BinaryOperator;

public class WCS {
	
	public static class Segment {
		int from, to;
		public Segment(int f, int t) {
			from = f;
			to = t;
		}
	}

	public static double getX(int x1, int y1, int x2, int y2) {
		if(x2 == x1)
			return x2;
		double m = (y2 - y1) / (double)(x2 - x1);
		double q = -x1 * m + y1;
		return -q / m;
	}
	
	public static int find(int x, Segment[] seg) {
		int l = 0, r = seg.length - 1, c = r / 2;
		while(l < r) {
			if(seg[c].from <= x && seg[c].to >= x)
				break;
			if(seg[c].to < x)
				l = c + 1;
			else 
				r = c - 1;
			c = (l + r) / 2;
		}
		return c;
	}
	
	public static void main(String[] args) {
		int sy = in.nextInt();
		int a = in.nextInt();
		int b = in.nextInt();
		int n = in.nextInt();
		Segment[] seg = new Segment[n];
		for(int i = 0; i < n; i ++)
			seg[i] = new Segment(in.nextInt(), in.nextInt());
		int[] sum = new int[n];
		for(int i = 0; i < n; i ++)
			sum[i] = seg[i].to - seg[i].from + (i > 0 ? sum[i - 1] : 0);
		StringBuilder buffer = new StringBuilder();
		int q = in.nextInt();
		while(q -- > 0) {
			//System.out.println("QUERY " + q);
			int x = in.nextInt();
			int y = in.nextInt();
			double xa = getX(x, y, a, sy);
			double xb = getX(x, y, b, sy);
			//System.out.println(xa + " " + xb);
			double ans = 0.0;
			int pa = find((int)xa, seg);
			int pb = find((int)xb + 1, seg);
			//System.out.println(pa + " " + pb);
			ans += sum[pb] - (pa > 0 ? sum[pa - 1] : 0);
			if(seg[pb].from > xb)
				ans -= seg[pb].to - seg[pb].from;
			else if(seg[pb].to >= xb)
				ans -= seg[pb].to - xb;
			if(seg[pa].to < xa)
				ans -= seg[pa].to - seg[pa].from;
			else 
				ans -= Math.max(0, xa - seg[pa].from);
			buffer.append((ans / (xb - xa) * (b - a)) + "\n");
		}
		System.out.println(buffer);
	}
	
	static class FastReader {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        int nextInt() {
            return Integer.parseInt(next());
        }
 
        long nextLong() {
            return Long.parseLong(next());
        }
 
        double nextDouble() {
            return Double.parseDouble(next());
        }
 
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
	
    public static FastReader in = new FastReader();
}