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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author OmarYasser
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, Scanner sc, PrintWriter out) {
            int a = sc.nextInt(), b = sc.nextInt(), q = sc.nextInt();
            while (q-- > 0) {
                int l = sc.nextInt(), t = sc.nextInt(), m = sc.nextInt();
                if (1L * a + b * (l - 1) > (int) 1e6) {
                    out.println(-1);
                    continue;
                }
                int lo = l, hi = (int) 1e6, best = -1;
                for (int cnt = 0; cnt <= 20; cnt++) {
                    int last = lo + ((hi - lo) >> 1);
                    int start = a + b * (l - 1);
                    int len = last - l + 1;
//                int d = (len + m - 1) / m;
//                BigInteger dd = BigInteger.valueOf(d);
//                BigInteger firstTerm = dd.multiply(BigInteger.valueOf(start));
//                BigInteger secondTerm = BigInteger.valueOf(b).multiply(dd.multiply(BigInteger.valueOf(len - 1)));
//                BigInteger thirdTerm = BigInteger.valueOf(b).multiply(BigInteger.valueOf(-1).multiply(BigInteger.valueOf(m).multiply(dd.multiply(BigInteger.valueOf(d - 1)).divide(BigInteger.valueOf(2)))));
                    // 1L * d * start + b * (d * (len - 1) - m * (d * (d - 1) / 2))
//                System.err.println(l + " " + last + " " + ((BigInteger.valueOf(a).multiply(BigInteger.valueOf(len))).add(BigInteger.valueOf(b).multiply(BigInteger.valueOf(len).multiply(BigInteger.valueOf(len - 1).divide(BigInteger.valueOf(2)))))));
                    if (((BigInteger.valueOf(start).multiply(BigInteger.valueOf(len))).add(BigInteger.valueOf(b).multiply((BigInteger.valueOf(len).multiply(BigInteger.valueOf(len - 1)).divide(BigInteger.valueOf(2)))))).compareTo(BigInteger.valueOf(1L * m * t)) <= 0 && 1L * a + 1L * b * (last - 1) <= t) {
                        best = last;
                        lo = Math.min(hi, last + 1);
                    } else {
                        hi = Math.max(lo, last - 1);
                    }
                }
                out.println(best);
            }
        }

    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public Scanner(FileReader f) {
            br = new BufferedReader(f);
        }

        public String next() {
            while (st == null || !st.hasMoreTokens())
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

