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 A
{
   public static void main(String[] args)
   {
      new A(new FastScanner());
   }

   int A, B;
   long sum(long n)
   {
      if (n <= 0) return 0;
      return n*(n+1L)/2;
   }

   long countBites(long lo, long hi, int m)
   {
      long height = A+B*hi;
      long numCells = A*(hi-lo+1);
      numCells += B*(sum(hi)-sum(lo-1));
      long numOps = (numCells+m-1)/m;
      return Math.max(height, numOps);
   }

   public A(FastScanner in)
   {
      A = in.nextInt();
      B = in.nextInt();
      int Q = in.nextInt();
      PrintWriter out = new PrintWriter(System.out);

      while (Q-->0)
      {
         int start = in.nextInt()-1;
         int t = in.nextInt();
         int m = in.nextInt();

         if (countBites(start, start, m) > t)
         {
            out.println(-1);
            continue;
         }

         long lo = start, hi = 2*start+1;
         while (countBites(start, hi, m) <= t)
         {
            lo = hi;
            hi *= 2;
         }
         while (lo < hi)
         {
            long mid = (lo+hi+1)/2;
            if (countBites(start, mid, m) <= t)
               lo = mid;
            else
               hi = mid-1;
         }
         out.println(lo+1);
      }
      out.close();
   }
}

class FastScanner{
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    
    public FastScanner()
    {
        stream = System.in;
    }
    
    int read()
    {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars){
            curChar = 0;
            try{
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
    
    boolean isSpaceChar(int c)
    {
        return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
    }
    
    boolean isEndline(int c)
    {
        return c=='\n'||c=='\r'||c==-1;
    }
    
    int nextInt()
    {
        return Integer.parseInt(next());
    }
    
    long nextLong()
    {
        return Long.parseLong(next());
    }
    
    double nextDouble()
    {
        return Double.parseDouble(next());
    }
    
    String next(){
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do{
            res.appendCodePoint(c);
            c = read();
        }while(!isSpaceChar(c));
        return res.toString();
    }
    
    String nextLine(){
        int c = read();
        while (isEndline(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do{
            res.appendCodePoint(c);
            c = read();
        }while(!isEndline(c));
        return res.toString();
    }
}
