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.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;



    
    
public class Solution  {
    
    static class FastScanner{
        BufferedReader s;
        StringTokenizer st;
        
        
        public FastScanner(){
            st = new StringTokenizer("");
            s = new BufferedReader(new InputStreamReader(System.in));
        }
        
        public FastScanner(File f) throws FileNotFoundException{
            st = new StringTokenizer("");
            s = new BufferedReader (new FileReader(f));
        }
        
        public int nextInt() throws IOException{
            if(st.hasMoreTokens())
                return Integer.parseInt(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextInt();
            }
        }
        
        public double nextDouble() throws IOException{
            if(st.hasMoreTokens())
                return Double.parseDouble(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextDouble();
            }
        }
        
        public long nextLong() throws IOException{
            if(st.hasMoreTokens())
                return Long.parseLong(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextLong();
            }
        }
        
        public String nextString() throws IOException{
            if(st.hasMoreTokens())
                return st.nextToken();
            else{
                st = new StringTokenizer(s.readLine());
                return nextString();
            }
            
        }
        public String readLine() throws IOException{
            return s.readLine();
        }
        
        public void close() throws IOException{
            s.close();
        }
        
    }
    
    
    
    
    //FastScanner s = new FastScanner(new File("input.txt"));       copy inside void solve
    //PrintWriter ww = new PrintWriter(new FileWriter("output.txt"));
    static FastScanner s = new FastScanner();   
    static PrintWriter ww = new PrintWriter(new OutputStreamWriter(System.out));
    
    public static void main(String args[])throws IOException{
        //Main ob=new Main();
        Solution ob=new Solution();
        ob.solve();
            ww.close();
    }
    /////////////////////////////////////////////
    
    
    /////////////////////////////////////////////
    void solve() throws IOException {
        long A=s.nextLong();
        long B=s.nextLong();
        int size=(int)10e5+100;
        long arr[]=new long[size];
        long dp[]=new long[size];
        for(int i=1;i<size;i++)
            arr[i]=A+(i-1)*B;
        
        dp[1]=A;
        for(int i=2;i<size;i++){
            dp[i]=dp[i-1]+arr[i];
   //       System.out.println(dp[i]);
        }
        
            
        int q=s.nextInt();
        while(q-->0){
            int l=s.nextInt();
            int t=s.nextInt();
            int m=s.nextInt();
            
            long maxbyte=1L*t*m;
            if(arr[l] > t){
                ww.println("-1");
                continue;
            }
            else if(t==arr[l]){
                ww.println(l);
                continue;
            }
            int low=l;
            int high=size-1;
            while(low+1<high){
                int mid=(low+high)/2;
                long amt=dp[mid]-dp[l-1];
                if(amt<=maxbyte&&arr[mid]<=t)
                    low=mid;
                else
                    high=mid;
                
                //System.out.println(amt+" "+low+" "+high+" "+maxbyte);
            }
            long amt=dp[high]-dp[l-1];
            if(amt<=maxbyte&&dp[high]<=t)
                ww.println(high);
            else
                ww.println(low);
                    
                
                        
        }
            
            
            
        
        
                
        
    }//solve
  }