#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
using namespace std;
const int INF = 1000 * 1000 * 1000 + 322;
const long long LLINF =
    2LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL + 57;
const int MOD = 1000 * 1000 * 1000 + 7;
const long long FFT_MOD = 998244353;
const int P1M = 1336337;
const int P1K = 1009;
const long double PI = acos(-1.);
const long double EPS = 1e-7;
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
  _out << _p.x << " " << _p.y;
  return _out;
}
template <typename T, typename U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
  _in >> _p.x >> _p.y;
  return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
  if (_v.empty()) return _out;
  _out << _v.front();
  for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) _out << ' ' << *_it;
  return _out;
}
template <typename T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
  for (auto &_i : _v) _in >> _i;
  return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
  if (_s.empty()) return _out;
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
  if (_s.empty()) return _out;
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
  if (_s.empty()) return _out;
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
  if (_s.empty()) return _out;
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
  return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
  if (_m.empty()) return _out;
  _out << '(' << _m.begin()->x << ": " << _m.begin()->y << ')';
  for (auto _it = ++_m.begin(); _it != _m.end(); ++_it)
    _out << ", (" << _it->x << ": " << _it->y << ')';
  return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
  if (_m.empty()) return _out;
  _out << '(' << _m.begin()->x << ": " << _m.begin()->y << ')';
  for (auto _it = ++_m.begin(); _it != _m.end(); ++_it)
    _out << ", (" << _it->x << ": " << _it->y << ')';
  return _out;
}
const char *infile = "";
const char *outfile = "";
inline long long gcd(long long a, long long b) {
  while (b) {
    a %= b;
    swap(a, b);
  }
  return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline int pwm(long long xx, long long pow, int MD = MOD) {
  if (pow < 0) {
    return pwm(pwm(xx, MD - 2, MD), -pow, MD);
  }
  long long mlt = 1;
  while (pow) {
    if (pow & 1) {
      mlt *= xx;
      mlt %= MD;
    }
    xx *= xx;
    pow >>= 1;
    xx %= MD;
  }
  return (int)mlt;
}
inline int inv(long long r, int _mod = MOD) {
  return pwm(r % _mod, _mod - 2, _mod);
}
const int N = 200 * 1000 + 57;
vector<int> g[N];
bool can[N];
long long cnt = 1;
long long get_s(long long n) { return n * (n + 1) / 2; }
inline void solve() {
  long long m;
  cin >> m;
  long long a, b;
  cin >> a >> b;
  long long gc = gcd(a, b);
  long long ans = 1;
  can[0] = true;
  for (int i = 1; i < min(a + b, m + 1); ++i) {
    if (i - a >= 0 && can[i - a]) {
      can[i] = true;
      ++cnt;
      int j = i;
      bool ok = true;
      while (ok) {
        ok = false;
        if (j + a <= i && !can[j + a]) {
          j += a;
          can[j] = true;
          ok = true;
          ++cnt;
        } else if (j - b >= 0 && !can[j - b]) {
          j -= b;
          can[j] = true;
          ok = true;
          ++cnt;
        }
      }
    }
    ans += cnt;
  }
  if (a + b <= m) {
    ans += (m - a - b + 1);
    long long i;
    for (i = a + b; i % gc; ++i) {
      ans += i / gc;
    }
    long long cnt = (m - i) / gc;
    assert(i + gc * cnt <= m);
    ans += (get_s(i / gc + cnt - 1) - get_s(i / gc - 1)) * gc;
    i += gc * cnt;
    for (; i <= m; ++i) {
      ans += i / gc;
    }
  }
  cout << ans << '\n';
}
int main() {
  if (*infile != '\0') (void)freopen(infile, "r", stdin);
  if (*outfile != '\0') (void)freopen(outfile, "w", stdout);
  cout.tie(nullptr);
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  cout << setprecision(20);
  cout << fixed;
  solve();
  return 0;
}

### Prompt

Your challenge is to write a CPP solution to the following problem:

A frog is initially at position 0 on the number line. The frog has two positive integers a and b. From a position k, it can either jump to position k+a or k-b.

Let f(x) be the number of distinct integers the frog can reach if it never jumps on an integer outside the interval [0, x]. The frog doesn't need to visit all these integers in one trip, that is, an integer is counted if the frog can somehow reach it if it starts from 0.

Given an integer m, find ∑_{i=0}^{m} f(i). That is, find the sum of all f(i) for i from 0 to m.

Input

The first line contains three integers m, a, b (1 ≤ m ≤ 10^9, 1 ≤ a,b ≤ 10^5).

Output

Print a single integer, the desired sum.

Examples

Input


7 5 3


Output


19


Input


1000000000 1 2019


Output


500000001500000001


Input


100 100000 1


Output


101


Input


6 4 5


Output


10

Note

In the first example, we must find f(0)+f(1)+…+f(7). We have f(0) = 1, f(1) = 1, f(2) = 1, f(3) = 1, f(4) = 1, f(5) = 3, f(6) = 3, f(7) = 8. The sum of these values is 19.

In the second example, we have f(i) = i+1, so we want to find ∑_{i=0}^{10^9} i+1.

In the third example, the frog can't make any jumps in any case.

### Response

```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
using namespace std;
const int INF = 1000 * 1000 * 1000 + 322;
const long long LLINF =
    2LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL + 57;
const int MOD = 1000 * 1000 * 1000 + 7;
const long long FFT_MOD = 998244353;
const int P1M = 1336337;
const int P1K = 1009;
const long double PI = acos(-1.);
const long double EPS = 1e-7;
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
  _out << _p.x << " " << _p.y;
  return _out;
}
template <typename T, typename U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
  _in >> _p.x >> _p.y;
  return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
  if (_v.empty()) return _out;
  _out << _v.front();
  for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) _out << ' ' << *_it;
  return _out;
}
template <typename T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
  for (auto &_i : _v) _in >> _i;
  return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
  if (_s.empty()) return _out;
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
  if (_s.empty()) return _out;
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
  if (_s.empty()) return _out;
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
  if (_s.empty()) return _out;
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
  return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
  if (_m.empty()) return _out;
  _out << '(' << _m.begin()->x << ": " << _m.begin()->y << ')';
  for (auto _it = ++_m.begin(); _it != _m.end(); ++_it)
    _out << ", (" << _it->x << ": " << _it->y << ')';
  return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
  if (_m.empty()) return _out;
  _out << '(' << _m.begin()->x << ": " << _m.begin()->y << ')';
  for (auto _it = ++_m.begin(); _it != _m.end(); ++_it)
    _out << ", (" << _it->x << ": " << _it->y << ')';
  return _out;
}
const char *infile = "";
const char *outfile = "";
inline long long gcd(long long a, long long b) {
  while (b) {
    a %= b;
    swap(a, b);
  }
  return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline int pwm(long long xx, long long pow, int MD = MOD) {
  if (pow < 0) {
    return pwm(pwm(xx, MD - 2, MD), -pow, MD);
  }
  long long mlt = 1;
  while (pow) {
    if (pow & 1) {
      mlt *= xx;
      mlt %= MD;
    }
    xx *= xx;
    pow >>= 1;
    xx %= MD;
  }
  return (int)mlt;
}
inline int inv(long long r, int _mod = MOD) {
  return pwm(r % _mod, _mod - 2, _mod);
}
const int N = 200 * 1000 + 57;
vector<int> g[N];
bool can[N];
long long cnt = 1;
long long get_s(long long n) { return n * (n + 1) / 2; }
inline void solve() {
  long long m;
  cin >> m;
  long long a, b;
  cin >> a >> b;
  long long gc = gcd(a, b);
  long long ans = 1;
  can[0] = true;
  for (int i = 1; i < min(a + b, m + 1); ++i) {
    if (i - a >= 0 && can[i - a]) {
      can[i] = true;
      ++cnt;
      int j = i;
      bool ok = true;
      while (ok) {
        ok = false;
        if (j + a <= i && !can[j + a]) {
          j += a;
          can[j] = true;
          ok = true;
          ++cnt;
        } else if (j - b >= 0 && !can[j - b]) {
          j -= b;
          can[j] = true;
          ok = true;
          ++cnt;
        }
      }
    }
    ans += cnt;
  }
  if (a + b <= m) {
    ans += (m - a - b + 1);
    long long i;
    for (i = a + b; i % gc; ++i) {
      ans += i / gc;
    }
    long long cnt = (m - i) / gc;
    assert(i + gc * cnt <= m);
    ans += (get_s(i / gc + cnt - 1) - get_s(i / gc - 1)) * gc;
    i += gc * cnt;
    for (; i <= m; ++i) {
      ans += i / gc;
    }
  }
  cout << ans << '\n';
}
int main() {
  if (*infile != '\0') (void)freopen(infile, "r", stdin);
  if (*outfile != '\0') (void)freopen(outfile, "w", stdout);
  cout.tie(nullptr);
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  cout << setprecision(20);
  cout << fixed;
  solve();
  return 0;
}

```