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
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
  return x * x;
}
template <typename T>
inline T abs(T x) {
  return x > T() ? x : -x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}
const int N = 100100;
struct Input {
  int A, B, n;
  int l[N], t[N], m[N];
  bool read() {
    if (scanf("%d %d %d", &A, &B, &n) != 3) return 0;
    for (int i = int(0); i < int(n); ++i) {
      scanf("%d %d %d", &l[i], &t[i], &m[i]);
    }
    return 1;
  }
  void init(const Input& input) { *this = input; }
};
struct Data : Input {
  int ans[N];
  void write() {
    for (int i = int(0); i < int(n); ++i) {
      printf("%d\n", ans[i]);
    }
  }
  virtual void solve() {}
  virtual void clear() { *this = Data(); }
};
struct Solution : Data {
  inline long long f(int l) {
    if (l <= 0) return 0;
    return (1ll * l * (l - 1)) / 2;
  }
  inline long long f(int l, int r) { return f(r) - f(l - 1); }
  inline bool check(int tekm, int i) {
    long long all = 1ll * (tekm - l[i] + 1) * A + 1ll * B * (f(l[i], tekm));
    ;
    return 1ll * (tekm - 1) * B + A <= t[i] && all <= 1ll * m[i] * t[i];
  }
  void solve() {
    for (int i = int(0); i < int(n); ++i) {
      int tekl = l[i], tekr = tekl + 1000000;
      while (tekl < tekr) {
        int tekm = (tekl + tekr + 1) >> 1;
        if (check(tekm, i)) {
          tekl = tekm;
        } else {
          tekr = tekm - 1;
        }
      }
      if (check(tekl, i)) {
        ans[i] = tekl;
      } else {
        ans[i] = -1;
      }
    }
  }
  void clear() { *this = Solution(); }
};
Solution sol;
int main() {
  cout.setf(ios::showpoint | ios::fixed);
  cout.precision(20);
  sol.read();
  sol.solve();
  sol.write();
  return 0;
}
