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.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main
{

	public static void main(String[] args) throws IOException
	{

		Main main = new Main();
		main.read();
	}

	/* IO */
	private StringBuilder ans;
	private BufferedReader in;
	private StringTokenizer tok;

	/* fields */
	private long a;
	private long b;
	private int nQueries;
	private int n = 2 * 1000000 + 6;
	private long[] acc;

	private void read() throws IOException
	{
		// streams
		boolean file = false;
		if (file)
			in = new BufferedReader(new FileReader("input.txt"));
		else
			in = new BufferedReader(new InputStreamReader(System.in));
		ans = new StringBuilder();

		// read all
		StringBuilder strb = new StringBuilder();
		String str = in.readLine().replace(",", "");
		while (str != null)
		{
			strb.append(str.trim());
			strb.append(" ");
			str = in.readLine();
		}
		tok = new StringTokenizer(strb.toString().trim());

		// read
		a = Integer.parseInt(tok.nextToken());
		b = Integer.parseInt(tok.nextToken());
		nQueries = Integer.parseInt(tok.nextToken());

		// precompute stuff
		accSum();

		// solve queries
		for (int i = 0; i < nQueries; i++)
		{
			int l = Integer.parseInt(tok.nextToken());
			int t = Integer.parseInt(tok.nextToken());
			int m = Integer.parseInt(tok.nextToken());
			ans.append(bs(l, t, m) + "\n");
		}

		// output
		System.out.print(ans.toString());
	}

	private int bs(int lQ, int t, int m)
	{
		if (value(lQ) > t)
			return -1;

		int l = lQ;
		int r = n;
		while (l <= r)
		{
			int mid = (l + r) / 2;
			boolean validMid = valid(lQ, mid, t, m);
			boolean validNext = valid(lQ, mid + 1, t, m);
			if (validMid && !validNext)
				return mid;
			else if (!validMid)
				r = mid - 1;
			else
				l = mid + 1;
		}
		return -1;
	}

	private boolean valid(int l, int r, int t, int m)
	{
		return acc[r] - acc[l - 1] <= 1l * t * m && value(r) <= t;
	}

	private void accSum()
	{
		acc = new long[n + 1];
		for (int i = 1; i < acc.length; i++)
			acc[i] = acc[i - 1] + value(i);
	}

	private long value(int i)
	{
		return a + 1l * (i - 1) * b;
	}

}
