Problem: Well, here is another math class task. In mathematics, GCD is the greatest common divisor, and it's an easy task to calculate the GCD between two positive integers.

A common divisor for two positive numbers is a number which both numbers are divisible by.

But your teacher wants to give you a harder task, in this task you have to find the greatest common divisor d between two integers a and b that is in a given range from low to high (inclusive), i.e. low ≤ d ≤ high. It is possible that there is no common divisor in the given range.

You will be given the two integers a and b, then n queries. Each query is a range from low to high and you have to answer each query.

Input

The first line contains two integers a and b, the two integers as described above (1 ≤ a, b ≤ 109). The second line contains one integer n, the number of queries (1 ≤ n ≤ 104). Then n lines follow, each line contains one query consisting of two integers, low and high (1 ≤ low ≤ high ≤ 109).

Output

Print n lines. The i-th of them should contain the result of the i-th query in the input. If there is no common divisor in the given range for any query, you should print -1 as a result for this query.

Examples

Input

9 27
3
1 5
10 11
9 11


Output

3
-1
9

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;


public class ModifiedGCD {

    private void solve() throws IOException {
        int a = nextInt();
        int b = nextInt();
        
        int g = gcd(a, b);
        
        ArrayList<Integer> Factors = new ArrayList<Integer>();
        
        Factors.add(1);
        Factors.add(g);
        
        for (int i = 2; i * i <= g; i++)
            if (g % i == 0) {
                if (!Factors.contains(i))
                    Factors.add(i);
                if (!Factors.contains(g / i))
                    Factors.add(g / i);
            }
        
        Collections.sort(Factors);
        
        int n = nextInt();
        for (int i = 0; i < n; i++) {
            int l = nextInt();
            int h = nextInt();
            
            int index = search(Factors, h);
            
            if (Factors.get(index) < l) {
                System.out.println(-1);
            }
            else {
                System.out.println(Factors.get(index));
            }
        }
    }

    public int search(ArrayList<Integer> L, int val) {
        int low = 0;
        int high = L.size();
        int mid = 0;
        while(low + 1 < high) {
            mid = (low + high) / 2;
            if (L.get(mid) > val) {
                high = mid;
            }
            else {
                low = mid;
            }
        }
        return low;
    }
    private int gcd(int a , int b) {
        if (b == 0) return a;
        return gcd(b , a%b);
    }
    public static void main(String[] args) {
        new ModifiedGCD().run();
    }

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter writer;

    public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.close();
        }
        catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

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

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

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

    BigInteger nextBigInteger() throws IOException {
        return new BigInteger(nextToken());
    }

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