#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <bitset>
#include <numeric>
#include <utility>
#include <iomanip>
#include <algorithm>
#include <functional>
#include <unordered_map>
using namespace std;

template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

template<class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template<class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
  return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template<class T, class V>
typename enable_if<is_class<T>::value == 0>::type fill(T &t, const V &v) {
    t = v;
}
template<class T, class V>
typename enable_if<is_class<T>::value != 0>::type fill(T &t, const V &v){
    for (auto &e : t) fill(e, v);
}

#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
template<class T1, class T2> ostream& operator << (ostream &s, pair<T1,T2> P)
{ return s << '<' << P.first << ", " << P.second << '>'; }
template<class T> ostream& operator << (ostream &s, vector<T> P)
{ for (int i = 0; i < P.size(); ++i) { if (i > 0) { s << " "; } s << P[i]; } return s; }
template<class T> ostream& operator << (ostream &s, vector<vector<T> > P)
{ for (int i = 0; i < P.size(); ++i) { s << endl << P[i]; } return s << endl; }

#define EACH(i, s) for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
template<class T> ostream& operator << (ostream &s, set<T> P)
{ EACH(it, P) { s << "<" << *it << "> "; } return s << endl; }
template<class T1, class T2> ostream& operator << (ostream &s, map<T1,T2> P)
{ EACH(it, P) { s << "<" << it->first << "->" << it->second << "> "; } return s << endl; }


long long GCD(long long x, long long y) {
    return y ? GCD(y, x%y) : x;
}

// 0 + 1 + ... + (k-1)
long long left(long long k) {
    return k * (k-1) / 2;
}

// (N-1) + (N-2) + ... + (N-k)
long long right(long long k, long long N) {
    return k * (N*2-k-1) / 2;
}
    

long long solve(long long N, long long a, long long d) {
    if (a == 0) {
        if (d == 0) return 1;
        else return N * (N-1) / 2 + 1;
    }
    else if (d == 0) {
        return N+1;
    }
    
    long long g = GCD(a, d);
    a /= g, d /= g;
    swap(a, d);
    if (a < 0) a = -a, d = -d;

    //COUT(a); COUT(d);

    long long res = 0;
    for (long long k = 0; k <= N; ++k) {
        long long l = left(k), r = right(k, N);
        long long tmp = r - l + 1;
        long long sub = 0;

        //COUT("--------------"); COUT(k); COUT(l); COUT(r); COUT(tmp);
        
        if (k - a >= 0) {
            long long l2 = left(k-a), r2 = right(k-a, N);
            l2 -= d; r2 -= d;
            long long ml = max(l, l2), mr = min(r, r2);
            sub = max(0LL, mr - ml + 1);

            //COUT(l2); COUT(r2); COUT(sub);
        }

        res += tmp - sub;
    }
    return res;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    long long N, a, d;
    while (cin >> N >> a >> d) {
        cout << solve(N, a, d) << endl;
    }
}


















Measured memory_bytes: 256