Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs.

<image>

Each Karafs has a positive integer height. Tavas has an infinite 1-based sequence of Karafses. The height of the i-th Karafs is si = A + (i - 1) × B.

For a given m, let's define an m-bite operation as decreasing the height of at most m distinct not eaten Karafses by 1. Karafs is considered as eaten when its height becomes zero.

Now SaDDas asks you n queries. In each query he gives you numbers l, t and m and you should find the largest number r such that l ≤ r and sequence sl, sl + 1, ..., sr can be eaten by performing m-bite no more than t times or print -1 if there is no such number r.

Input

The first line of input contains three integers A, B and n (1 ≤ A, B ≤ 106, 1 ≤ n ≤ 105).

Next n lines contain information about queries. i-th line contains integers l, t, m (1 ≤ l, t, m ≤ 106) for i-th query.

Output

For each query, print its answer in a single line.

Examples

Input

2 1 4
1 5 3
3 3 10
7 10 2
6 4 8


Output

4
-1
8
-1


Input

1 5 2
1 5 10
2 7 4


Output

1
2
import java.util.*;
import java.io.*;

public class Codeforces {

    static long arr[];
    static long sum[];
    
    public static void main(String[] args) throws IOException {
        Reader.init(System.in);
        int a = Reader.nextInt();
        long b = Reader.nextInt();
        int n = Reader.nextInt();
        StringBuilder ans = new StringBuilder();
        
        arr = new long[1000011];
        sum = new long[1000011];
        arr[0] = a;
        sum[0] = a;
        int i = 1;
        
        for(; i < arr.length-1; i++){
            arr[i] = a + i * b;
            sum[i] = arr[i] + sum[i-1];
        }
        
        
        for(int j = 0; j < n; j++){
            int l = Reader.nextInt() -1, t = Reader.nextInt();
            long m = Reader.nextInt();
            long x = m*t;
            if(l > 0)
                x += sum[l-1];
            
            ans.append(bin(l, i, t, x)).append('\n');
        }
        
        System.out.print(ans);
    }
    
    static int bin(int first, int last, int max, long Sum){
        int pos = -1;
        
        while(first <= last){
            int mid = (first+last)/2;
            
            if(max >= arr[mid] && Sum >= sum[mid]){
                pos = mid+1;
                first = mid + 1;
            }
            
            else
                last = mid - 1;
        }
        
        return pos;
    }
    
}

class Pair implements Comparable<Pair>{

    int x;
    int index;
    
    Pair(int a, int b){
        x = a;
        index = b;
    }
    
    @Override
    public int compareTo(Pair t) {
        return x - t.x;
    }
    
}


class Reader {

    static BufferedReader reader;
    static StringTokenizer tokenizer;

    public static int pars(String x) {
        int num = 0;
        int i = 0;
        if (x.charAt(0) == '-') {
            i = 1;
        }
        for (; i < x.length(); i++) {
            num = num * 10 + (x.charAt(i) - '0');
        }

        if (x.charAt(0) == '-') {
            return -num;
        }

        return num;
    }

    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input));
        tokenizer = new StringTokenizer("");
    }

    static void init(FileReader input) {
        reader = new BufferedReader(input);
        tokenizer = new StringTokenizer("");
    }

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

    static int nextInt() throws IOException {
        return pars(next());
    }

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

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